/** * 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(TypeToken<?> type) { return type.isSubtypeOf(getType()); }
/** * 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()); }
/** * Returns true if this type is a subtype of the given {@code type}. "Subtype" 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 isSubtypeOf(TypeToken<?> type) { return isSubtypeOf(type.getType()); }
private static void assertAssignable(TypeToken<?> from, TypeToken<?> to) { assertTrue( from.getType() + " is expected to be assignable to " + to.getType(), to.isSupertypeOf(from)); assertTrue( to.getType() + " is expected to be a supertype of " + from.getType(), to.isSupertypeOf(from)); assertTrue( from.getType() + " is expected to be a subtype of " + to.getType(), from.isSubtypeOf(to)); }
private static void assertNotAssignable(TypeToken<?> from, TypeToken<?> to) { assertFalse( from.getType() + " shouldn't be assignable to " + to.getType(), to.isSupertypeOf(from)); assertFalse( to.getType() + " shouldn't be a supertype of " + from.getType(), to.isSupertypeOf(from)); assertFalse( from.getType() + " shouldn't be a subtype of " + to.getType(), from.isSubtypeOf(to)); }
public void testInnerClassWithParameterizedOwner() throws Exception { Type fieldType = ParameterizedOuter.class.getField("field").getGenericType(); assertEquals( fieldType, TypeToken.of(ParameterizedOuter.class).resolveType(fieldType).getType()); }
public void testClassWrapper() { TypeToken<String> typeExpression = TypeToken.of(String.class); assertEquals(String.class, typeExpression.getType()); assertEquals(String.class, typeExpression.getRawType()); }
public void testGenericArrayType() { TypeToken<List<String>[]> token = new TypeToken<List<String>[]>() {}; assertEquals(List[].class, token.getRawType()); assertThat(token.getType()).isInstanceOf(GenericArrayType.class); }
public void testFalseRecursiveType_intermediaryTypeMappingDoesNotConfuseMe() { Type returnType = genericReturnType(SubtypeOfWithFalseRecursiveType.class, "revertKeyAndValueTypes"); TypeToken<?> keyType = TypeToken.of(returnType).resolveType(WithFalseRecursiveType.class.getTypeParameters()[0]); assertEquals("java.util.List<K1>", keyType.getType().toString()); }
public void testGetSupertype_withArray() { assertEquals( new TypeToken<Iterable<List<String>>[]>() {}, TypeToken.of(StringListIterable[].class).getSupertype(Iterable[].class)); assertEquals(int[].class, TypeToken.of(int[].class).getSupertype(int[].class).getType()); assertEquals(Object.class, TypeToken.of(int[].class).getSupertype(Object.class).getType()); assertEquals(int[][].class, TypeToken.of(int[][].class).getSupertype(int[][].class).getType()); assertEquals( Object[].class, TypeToken.of(String[].class).getSupertype(Object[].class).getType()); assertEquals(Object.class, TypeToken.of(String[].class).getSupertype(Object.class).getType()); }
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()); }
@SuppressWarnings("rawtypes") // purpose is to test raw type public void testGetSupertype_fromRawClass() { assertEquals( Types.newParameterizedType(Iterable.class, List.class.getTypeParameters()[0]), new TypeToken<List>() {}.getSupertype(Iterable.class).getType()); }
public void testGetSubtype_baseClassWithNoTypeArgs() { class SingleGenericExtendsBase<T> extends Base {} TypeToken<Base> supertype = new TypeToken<Base>() {}; TypeToken<SingleGenericExtendsBase<String>> subtype = new TypeToken<SingleGenericExtendsBase<String>>() {}; assertTrue(subtype.isSubtypeOf(supertype)); ParameterizedType actualSubtype = (ParameterizedType) supertype.getSubtype(subtype.getRawType()).getType(); assertEquals(SingleGenericExtendsBase.class, actualSubtype.getRawType()); }
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 testWildcardCaptured_typeVariableDeclaresTypeBound_wildcardHasExplicitUpperBound() throws Exception { TypeToken<Counter<? extends Number>> type = new TypeToken<Counter<? extends Number>>() {}; TypeToken<?> fieldType = type.resolveType(Counter.class.getDeclaredField("counts").getGenericType()); Type[] typeArgs = ((ParameterizedType) fieldType.getType()).getActualTypeArguments(); assertThat(typeArgs).asList().hasSize(1); TypeVariable<?> captured = (TypeVariable<?>) typeArgs[0]; assertThat(captured.getBounds()).asList().containsExactly(Number.class); assertThat(new TypeToken<List<? extends Number>>() {}.isSupertypeOf(fieldType)).isTrue(); assertThat(new TypeToken<List<? extends Iterable<?>>>() {}.isSupertypeOf(fieldType)).isFalse(); }
public void testGetSubtype_genericSubtypeOfNonGenericType() { TypeToken<Serializable> supertype = new TypeToken<Serializable>() {}; TypeToken<ArrayList<String>> subtype = new TypeToken<ArrayList<String>>() {}; assertTrue(subtype.isSubtypeOf(supertype)); ParameterizedType actualSubtype = (ParameterizedType) supertype.getSubtype(subtype.getRawType()).getType(); assertEquals(ArrayList.class, actualSubtype.getRawType()); assertThat(actualSubtype.getActualTypeArguments()[0]).isInstanceOf(TypeVariable.class); assertTrue(TypeToken.of(actualSubtype).isSubtypeOf(supertype)); }
public void testWildcardCaptured_methodParameter_upperBound() throws Exception { TypeToken<Holder<?>> type = new TypeToken<Holder<?>>() {}; ImmutableList<Parameter> parameters = type.method(Holder.class.getDeclaredMethod("setList", List.class)).getParameters(); assertThat(parameters).hasSize(1); TypeToken<?> parameterType = parameters.get(0).getType(); assertEquals(List.class, parameterType.getRawType()); assertFalse( parameterType.getType().toString(), parameterType.isSupertypeOf(new TypeToken<List<Integer>>() {})); }
public void testGetSupertype_withoutTypeVariable() { ParameterizedType expectedType = Types.newParameterizedType( Iterable.class, Types.newParameterizedType(List.class, String.class)); assertEquals( expectedType, TypeToken.of(StringListIterable.class).getSupertype(Iterable.class).getType()); }
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()); }