@Override public boolean apply(TypeToken<?> type) { return type.getRawType().isInterface(); } }
private ImmutableList<TypeToken<? super T>> boundsAsInterfaces(Type[] bounds) { ImmutableList.Builder<TypeToken<? super T>> builder = ImmutableList.builder(); for (Type bound : bounds) { @SuppressWarnings("unchecked") // upper bound of T TypeToken<? super T> boundType = (TypeToken<? super T>) of(bound); if (boundType.getRawType().isInterface()) { builder.add(boundType); } } return builder.build(); }
private @Nullable TypeToken<? super T> boundAsSuperclass(Type bound) { TypeToken<?> token = of(bound); if (token.getRawType().isInterface()) { return null; } @SuppressWarnings("unchecked") // only upper bound of T is passed in. TypeToken<? super T> superclass = (TypeToken<? super T>) token; return superclass; }
static void verifyConsitentRawType() { for (Method method : RawTypeConsistencyTester.class.getDeclaredMethods()) { assertEquals( method.getReturnType(), TypeToken.of(method.getGenericReturnType()).getRawType()); for (int i = 0; i < method.getParameterTypes().length; i++) { assertEquals( method.getParameterTypes()[i], TypeToken.of(method.getGenericParameterTypes()[i]).getRawType()); } } } }
public void testClassWrapper() { TypeToken<String> typeExpression = TypeToken.of(String.class); assertEquals(String.class, typeExpression.getType()); assertEquals(String.class, typeExpression.getRawType()); }
public void testMultiDimensionalGenericArrayType() { TypeToken<List<Long>[][][]> token = new TypeToken<List<Long>[][][]>() {}; assertEquals(List[][][].class, token.getRawType()); assertThat(token.getType()).isInstanceOf(GenericArrayType.class); }
public void testGenericArrayType() { TypeToken<List<String>[]> token = new TypeToken<List<String>[]>() {}; assertEquals(List[].class, token.getRawType()); assertThat(token.getType()).isInstanceOf(GenericArrayType.class); }
public void testWildcardCaptured_field_upperBound() throws Exception { TypeToken<Holder<?>> type = new TypeToken<Holder<?>>() {}; TypeToken<?> matrixType = type.resolveType(Holder.class.getDeclaredField("matrix").getGenericType()); assertEquals(List[].class, matrixType.getRawType()); assertThat(matrixType.getType()).isNotEqualTo(new TypeToken<List<?>[]>() {}.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()); }
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 testGetSubtype_toWildcardWithBounds() { class TwoTypeArgs<K, V> {} class StringForFirstTypeArg<V> extends TwoTypeArgs<String, V> {} TypeToken<TwoTypeArgs<?, ? extends Number>> supertype = new TypeToken<TwoTypeArgs<?, ? extends Number>>() {}; TypeToken<StringForFirstTypeArg<Integer>> subtype = new TypeToken<StringForFirstTypeArg<Integer>>() {}; assertTrue(subtype.isSubtypeOf(supertype)); // TODO(benyu): This should check equality to an expected value, see discussion in cl/98674873 TypeToken<?> unused = supertype.getSubtype(subtype.getRawType()); }
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 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_baseClassInGenericClassWithNoTypeArgs() { class SingleGenericExtendsBase<T> implements GenericClass.Base {} TypeToken<GenericClass.Base> supertype = new TypeToken<GenericClass.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()); assertTrue(TypeToken.of(actualSubtype).isSubtypeOf(supertype)); }
public void testGetSubtype_toWildcard() { class TwoTypeArgs<K, V> {} class StringForFirstTypeArg<V> extends TwoTypeArgs<String, V> {} TypeToken<TwoTypeArgs<?, ?>> supertype = new TypeToken<TwoTypeArgs<?, ?>>() {}; TypeToken<StringForFirstTypeArg<String>> subtype = new TypeToken<StringForFirstTypeArg<String>>() {}; assertTrue(subtype.isSubtypeOf(supertype)); assertEquals( new TypeToken<StringForFirstTypeArg<?>>() {}, supertype.getSubtype(subtype.getRawType())); }
public <T> void testGetSubtype_manyGenericArgs() { class FourTypeArgs<T1, T2, T3, T4> {} class ThreeTypeArgs<T1, T2, T3> extends FourTypeArgs<T1, T2, T3, String> {} TypeToken<FourTypeArgs<T, Integer, ?, ?>> supertype = new TypeToken<FourTypeArgs<T, Integer, ?, ?>>() {}; TypeToken<ThreeTypeArgs<T, Integer, String>> subtype = new TypeToken<ThreeTypeArgs<T, Integer, String>>() {}; assertTrue(subtype.isSubtypeOf(supertype)); assertEquals( new TypeToken<ThreeTypeArgs<T, Integer, ?>>() {}, supertype.getSubtype(subtype.getRawType())); }
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()); }
public void testGetSubtype_genericSubtypeOfRawTypeWithFewerTypeParameters() { TypeToken<List> supertype = new TypeToken<List>() {}; TypeToken<MySpecialList> subtype = new TypeToken<MySpecialList>() {}; assertTrue(subtype.isSubtypeOf(supertype)); Class<?> actualSubtype = (Class<?>) supertype.getSubtype(subtype.getRawType()).getType(); assertEquals(MySpecialList.class, actualSubtype); assertTrue(TypeToken.of(actualSubtype).isSubtypeOf(supertype)); }
public void testWhere() { assertEquals(new TypeToken<Map<String, Integer>>() {}, mapOf(String.class, Integer.class)); assertEquals(new TypeToken<int[]>() {}, arrayOf(int.class)); assertEquals(int[].class, arrayOf(int.class).getRawType()); }