boolean isSubtypeOf(Type supertype) { for (Type bound : bounds) { if (of(bound).isSubtypeOf(supertype) == target) { return target; } } return !target; }
private TypeToken<?> resolveSupertype(Type type) { TypeToken<?> supertype = of(getCovariantTypeResolver().resolveType(type)); // super types' type mapping is a subset of type mapping of this type. supertype.covariantTypeResolver = covariantTypeResolver; supertype.invariantTypeResolver = invariantTypeResolver; return supertype; }
/** * Returns true if this type is a supertype of the given {@code type}. "Supertype" is defined * according to <a * href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.5.1">the rules for type * arguments</a> introduced with Java generics. * * @since 19.0 */ public final boolean isSupertypeOf(Type type) { return of(type).isSubtypeOf(getType()); }
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 testGetGenericSuperclass_withSuperclass() { TypeToken<? super ArrayList<String>> superToken = new TypeToken<ArrayList<String>>() {}.getGenericSuperclass(); assertEquals(ArrayList.class.getSuperclass(), superToken.getRawType()); assertEquals( String.class, ((ParameterizedType) superToken.getType()).getActualTypeArguments()[0]); assertEquals(TypeToken.of(Base.class), TypeToken.of(Sub.class).getGenericSuperclass()); assertEquals(TypeToken.of(Object.class), TypeToken.of(Sub[].class).getGenericSuperclass()); }
public void testInnerClassWithParameterizedOwner() throws Exception { Type fieldType = ParameterizedOuter.class.getField("field").getGenericType(); assertEquals( fieldType, TypeToken.of(ParameterizedOuter.class).resolveType(fieldType).getType()); }
public <T extends List<String>> void testMethod_parameterTypes() throws NoSuchMethodException { Method setMethod = List.class.getMethod("set", int.class, Object.class); Invokable<T, ?> invokable = new TypeToken<T>(getClass()) {}.method(setMethod); ImmutableList<Parameter> params = invokable.getParameters(); assertEquals(2, params.size()); assertEquals(TypeToken.of(int.class), params.get(0).getType()); assertEquals(TypeToken.of(String.class), params.get(1).getType()); }
public void testClassWrapper() { TypeToken<String> typeExpression = TypeToken.of(String.class); assertEquals(String.class, typeExpression.getType()); assertEquals(String.class, typeExpression.getRawType()); }
public <T extends List<String> & CharSequence, T1 extends T> void testGetGenericSuperclass_typeVariable_boundIsTypeVariableAndInterface() { assertNull(TypeToken.of(new TypeCapture<T1>() {}.capture()).getGenericSuperclass()); assertEquals(TypeToken.of(Object.class), new TypeToken<T1[]>() {}.getGenericSuperclass()); }
public void testMethod_declaredBySuperclass() throws Exception { Method toStringMethod = Object.class.getMethod("toString"); ImmutableList<String> list = ImmutableList.of("foo"); assertEquals(list.toString(), TypeToken.of(List.class).method(toStringMethod).invoke(list)); }
public <T extends Number & List<String>> void testMethod_returnType_resolvedAgainstTypeBound() throws NoSuchMethodException { Method getMethod = List.class.getMethod("get", int.class); Invokable<T, String> invokable = new TypeToken<T>(getClass()) {}.method(getMethod).returning(String.class); assertEquals(TypeToken.of(String.class), invokable.getReturnType()); }
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()); }
public static void testSubtypeOfInnerClass_staticAnonymousClass() { TypeToken<?> supertype = new TypeToken<Mall<Outdoor>.Shop<Electronics>>() {}; Class<?> subclass = new Mall<Outdoor>().new Shop<Electronics>() {}.getClass(); assertTrue(TypeToken.of(subclass).isSubtypeOf(supertype)); }
public void testGetSubtype_genericSubtypeOfGenericTypeWithFewerParameters() { TypeToken<List<String>> supertype = new TypeToken<List<String>>() {}; TypeToken<MySpecialList<String, ?>> subtype = new TypeToken<MySpecialList<String, ?>>() {}; assertTrue(subtype.isSubtypeOf(supertype)); ParameterizedType actualSubtype = (ParameterizedType) supertype.getSubtype(subtype.getRawType()).getType(); assertEquals(MySpecialList.class, actualSubtype.getRawType()); assertThat(actualSubtype.getActualTypeArguments()[0]).isEqualTo(String.class); assertThat(actualSubtype.getActualTypeArguments()[1]).isInstanceOf(TypeVariable.class); assertTrue(TypeToken.of(actualSubtype).isSubtypeOf(supertype)); }
public void testInnerClassWithAnnotatedConstructorParameter() { Constructor<?> constructor = InnerWithAnnotatedConstructorParameter.class.getDeclaredConstructors()[0]; Invokable<?, ?> invokable = Invokable.from(constructor); assertEquals(1, invokable.getParameters().size()); assertEquals(TypeToken.of(String.class), invokable.getParameters().get(0).getType()); }
public <T> void testGetComponentType_genericArrayClasses() { assertNull(TypeToken.of(new TypeCapture<T>() {}.capture()).getComponentType()); assertEquals( TypeToken.of(new TypeCapture<T>() {}.capture()), new TypeToken<T[]>() {}.getComponentType()); assertEquals(new TypeToken<T[]>() {}, new TypeToken<T[][]>() {}.getComponentType()); }
public void testToGenericType() { assertEquals(TypeToken.of(String.class), TypeToken.toGenericType(String.class)); assertEquals(new TypeToken<int[]>() {}, TypeToken.toGenericType(int[].class)); @SuppressWarnings("rawtypes") // Iterable.class TypeToken<? extends Iterable> genericType = TypeToken.toGenericType(Iterable.class); assertEquals(Iterable.class, genericType.getRawType()); assertEquals( Types.newParameterizedType(Iterable.class, Iterable.class.getTypeParameters()[0]), genericType.getType()); }
private static void assertIsPrimitive(TypeToken<?> type) { assertTrue(type.isPrimitive()); assertNotWrapper(type); assertEquals(TypeToken.of(Primitives.wrap((Class<?>) type.getType())), type.wrap()); }
public void testAssignableArrayClassToBoundedWildcard() { TypeToken<?> subtypeOfArray = TypeToken.of(Types.subtypeOf(Object[].class)); TypeToken<?> supertypeOfArray = TypeToken.of(Types.supertypeOf(Object[].class)); assertFalse(subtypeOfArray.isSupertypeOf(Object[].class)); assertFalse(subtypeOfArray.isSupertypeOf(Object[][].class)); assertFalse(subtypeOfArray.isSupertypeOf(String[].class)); assertTrue(supertypeOfArray.isSupertypeOf(Object[].class)); assertFalse(supertypeOfArray.isSupertypeOf(Object.class)); assertTrue(supertypeOfArray.isSupertypeOf(Object[][].class)); assertTrue(supertypeOfArray.isSupertypeOf(String[].class)); }