public SqlDateDeserializer(Class cl) throws NoSuchMethodException { _cl = cl; _constructor = cl.getConstructor(new Class[]{long.class}); }
private boolean isWrapperClass(Class<?> clazz) { try { clazz.getConstructor(type); return true; } catch (NoSuchMethodException e) { return false; } }
public StringValueDeserializer(Class cl) { try { _cl = cl; _constructor = cl.getConstructor(new Class[]{String.class}); } catch (Exception e) { throw new RuntimeException(e); } }
public CertificateChainCleaner buildCertificateChainCleaner(X509TrustManager trustManager) { try { Class<?> extensionsClass = Class.forName("android.net.http.X509TrustManagerExtensions"); Constructor<?> constructor = extensionsClass.getConstructor(X509TrustManager.class); Object extensions = constructor.newInstance(trustManager); Method checkServerTrusted = extensionsClass.getMethod( "checkServerTrusted", X509Certificate[].class, String.class, String.class); return new AndroidCertificateChainCleaner(extensions, checkServerTrusted); } catch (Exception e) { throw new AssertionError(e); } }
private static @Nullable Constructor<Thread> getBigThreadConstructor() { try { return Thread.class.getConstructor( ThreadGroup.class, Runnable.class, String.class, long.class, boolean.class); } catch (Throwable t) { // Probably pre Java 9. We'll fall back to Thread.inheritableThreadLocals. return null; } } }
public static Constructor findConstructor(String desc, ClassLoader loader) { try { int lparen = desc.indexOf('('); String className = desc.substring(0, lparen).trim(); return getClass(className, loader).getConstructor(parseTypes(desc, loader)); } catch (ClassNotFoundException | NoSuchMethodException ex) { throw new CodeGenerationException(ex); } }
public void testConstructor_notDeclaredByType() throws NoSuchMethodException { Constructor<String> constructor = String.class.getConstructor(); try { TypeToken.of(Object.class).constructor(constructor); fail(); } catch (IllegalArgumentException expected) { } }
public void testConstructor_declaredBySuperclass() throws NoSuchMethodException { Constructor<Object> constructor = Object.class.getConstructor(); try { TypeToken.of(String.class).constructor(constructor); fail(); } catch (IllegalArgumentException expected) { } }
public <T extends CannotConstruct<AssertionError>> void testConstructor_exceptionTypes() throws NoSuchMethodException { @SuppressWarnings("rawtypes") // Reflection API skew Constructor<CannotConstruct> constructor = CannotConstruct.class.getConstructor(); Invokable<T, ?> invokable = new TypeToken<T>(getClass()) {}.constructor(constructor); assertThat(invokable.getExceptionTypes()).contains(TypeToken.of(AssertionError.class)); }
public <T extends Container<String>> void testConstructor_parameterTypes() throws NoSuchMethodException { @SuppressWarnings("rawtypes") // Reflection API skew Constructor<Container> constructor = Container.class.getConstructor(Object.class); Invokable<T, ?> invokable = new TypeToken<T>(getClass()) {}.constructor(constructor); ImmutableList<Parameter> params = invokable.getParameters(); assertEquals(1, params.size()); assertEquals(TypeToken.of(String.class), params.get(0).getType()); }
@Test public void forConstructorParameter() throws Exception { Constructor<Constructors> constructor = Constructors.class.getConstructor(List.class); ResolvableType type = ResolvableType.forConstructorParameter(constructor, 0); assertThat(type.getType(), equalTo(constructor.getGenericParameterTypes()[0])); }
@Test public void javaLangAnnotationTypeViaFindMergedAnnotation() throws Exception { Constructor<?> deprecatedCtor = Date.class.getConstructor(String.class); assertEquals(deprecatedCtor.getAnnotation(Deprecated.class), findMergedAnnotation(deprecatedCtor, Deprecated.class)); assertEquals(Date.class.getAnnotation(Deprecated.class), findMergedAnnotation(Date.class, Deprecated.class)); }
public void testConstructor_getOwnerType() throws NoSuchMethodException { @SuppressWarnings("rawtypes") // raw class ArrayList.class Constructor<ArrayList> constructor = ArrayList.class.getConstructor(); assertEquals( TypeToken.of(ArrayList.class), TypeToken.of(ArrayList.class).constructor(constructor).getOwnerType()); assertEquals( new TypeToken<ArrayList<String>>() {}, new TypeToken<ArrayList<String>>() {}.constructor(constructor).getOwnerType()); }
@Test public void resolveTypeVariableFromConstructorParameter() throws Exception { Constructor<?> constructor = Constructors.class.getConstructor(List.class); ResolvableType type = ResolvableType.forConstructorParameter(constructor, 0); assertThat(type.resolve(), equalTo((Class) List.class)); assertThat(type.resolveGeneric(0), equalTo((Class) CharSequence.class)); }
@Test public void resolveTypeVariableFromConstructorParameterWithImplementsClass() throws Exception { Constructor<?> constructor = Constructors.class.getConstructor(Map.class); ResolvableType type = ResolvableType.forConstructorParameter( constructor, 0, TypedConstructors.class); assertThat(type.resolve(), equalTo((Class) Map.class)); assertThat(type.resolveGeneric(0), equalTo((Class) String.class)); }
@Test public void resolveUnknownTypeVariableFromConstructorParameter() throws Exception { Constructor<?> constructor = Constructors.class.getConstructor(Map.class); ResolvableType type = ResolvableType.forConstructorParameter(constructor, 0); assertThat(type.resolve(), equalTo((Class) Map.class)); assertThat(type.resolveGeneric(0), nullValue()); }
@Test public void consParameterNameDiscoveryNoArgs() throws NoSuchMethodException { Constructor<TestObject> noArgsCons = TestObject.class.getConstructor(); String[] names = discoverer.getParameterNames(noArgsCons); assertNotNull("should find cons info", names); assertEquals("no argument names", 0, names.length); }
@Test public void consParameterNameDiscoveryArgs() throws NoSuchMethodException { Constructor<TestObject> twoArgCons = TestObject.class.getConstructor(String.class, int.class); String[] names = discoverer.getParameterNames(twoArgCons); assertNotNull("should find cons info", names); assertEquals("one argument", 2, names.length); assertEquals("name", names[0]); assertEquals("age", names[1]); }
@Test public void serialize() throws Exception { testSerialization(ResolvableType.forClass(List.class)); testSerialization(ResolvableType.forField(Fields.class.getField("charSequenceList"))); testSerialization(ResolvableType.forMethodParameter(Methods.class.getMethod("charSequenceParameter", List.class), 0)); testSerialization(ResolvableType.forMethodReturnType(Methods.class.getMethod("charSequenceReturn"))); testSerialization(ResolvableType.forConstructorParameter(Constructors.class.getConstructor(List.class), 0)); testSerialization(ResolvableType.forField(Fields.class.getField("charSequenceList")).getGeneric()); ResolvableType deserializedNone = testSerialization(ResolvableType.NONE); assertThat(deserializedNone, sameInstance(ResolvableType.NONE)); }
public void testConstructor_equals() throws NoSuchMethodException { Constructor<?> defaultConstructor = ArrayList.class.getConstructor(); Constructor<?> oneArgConstructor = ArrayList.class.getConstructor(int.class); new EqualsTester() .addEqualityGroup(Invokable.from(defaultConstructor), Invokable.from(defaultConstructor)) .addEqualityGroup(Invokable.from(oneArgConstructor)) .addEqualityGroup(new TypeToken<ArrayList<Integer>>() {}.constructor(defaultConstructor)) .addEqualityGroup(new TypeToken<ArrayList<String>>() {}.constructor(defaultConstructor)) .addEqualityGroup(new TypeToken<ArrayList<Integer>>() {}.constructor(oneArgConstructor)) .addEqualityGroup(new TypeToken<ArrayList<String>>() {}.constructor(oneArgConstructor)) .testEquals(); }