public <K, V> void testWhere_actualArgHasWildcard() { TypeResolver resolver = new TypeResolver() .where( new TypeCapture<Iterable<Map<?, V>>>() {}.capture(), new TypeCapture<Iterable<Map<String, Integer>>>() {}.capture()); assertEquals( new TypeCapture<K>() {}.capture(), resolver.resolveType(new TypeCapture<K>() {}.capture())); assertEquals(Integer.class, resolver.resolveType(new TypeCapture<V>() {}.capture())); }
public <T> void testRejectTypeVariable_withTypeVariable() { assertHasTypeVariable(new TypeCapture<T>() {}.capture()); assertHasTypeVariable(new TypeCapture<T[]>() {}.capture()); assertHasTypeVariable(new TypeCapture<Iterable<T>>() {}.capture()); assertHasTypeVariable(new TypeCapture<Map<String, T>>() {}.capture()); assertHasTypeVariable(new TypeCapture<Map<String, ? extends T>>() {}.capture()); assertHasTypeVariable(new TypeCapture<Map<String, ? super T[]>>() {}.capture()); }
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 testGetSupertype_fromWildcard() { @SuppressWarnings("unchecked") // can't do new TypeToken<? extends ...>() {} TypeToken<? extends List<String>> type = (TypeToken<? extends List<String>>) TypeToken.of(Types.subtypeOf(new TypeToken<List<String>>() {}.getType())); assertEquals(new TypeToken<Iterable<String>>() {}, type.getSupertype(Iterable.class)); }
public void testGetSubtype_fromWildcard() { @SuppressWarnings("unchecked") // can't do new TypeToken<? extends ...>() {} TypeToken<? super Iterable<String>> type = (TypeToken<? super Iterable<String>>) TypeToken.of(Types.supertypeOf(new TypeToken<Iterable<String>>() {}.getType())); assertEquals(new TypeToken<List<String>>() {}, type.getSubtype(List.class)); }
public void testGetSubtype_fromWildcard_upperBounded() { @SuppressWarnings("unchecked") // can't do new TypeToken<? extends ...>() {} TypeToken<? extends Iterable<String>> type = (TypeToken<? extends Iterable<String>>) TypeToken.of(Types.subtypeOf(new TypeToken<Iterable<String>>() {}.getType())); try { type.getSubtype(Iterable.class); fail(); } catch (IllegalArgumentException expected) { } }
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 <L extends List<R>, R extends List<L>> void testisSupertypeOf_recursiveTypeVariableBounds() { assertAssignable( TypeToken.of(new TypeCapture<L>() {}.capture()), TypeToken.of(new TypeCapture<L>() {}.capture())); assertNotAssignable( TypeToken.of(new TypeCapture<R>() {}.capture()), TypeToken.of(new TypeCapture<L>() {}.capture())); assertAssignable(TypeToken.of(new TypeCapture<L>() {}.capture()), new TypeToken<List<R>>() {}); }
public void testGetGenericSuperclass_noSuperclass() { assertNull(new TypeToken<Object>() {}.getGenericSuperclass()); assertEquals(TypeToken.of(Object.class), new TypeToken<Object[]>() {}.getGenericSuperclass()); assertNull(new TypeToken<List<String>>() {}.getGenericSuperclass()); assertEquals( TypeToken.of(Object.class), new TypeToken<List<String>[]>() {}.getGenericSuperclass()); }
public void testGetSupertype_fullySpecializedType() { Type expectedType = new TypeToken<Map<String, List<Object>>>() {}.getType(); assertEquals( expectedType, new TypeToken<ListMap<String, Object>>() {}.getSupertype(Map.class).getType()); }
public <V> void testGetSupertype_partiallySpecializedType() { Type expectedType = new TypeToken<Map<String, List<V>>>() {}.getType(); assertEquals( expectedType, new TypeToken<StringListMap<V>>() {}.getSupertype(Map.class).getType()); }
public void testTypeResolution() { assertEquals(String.class, new IKnowMyType<String>() {}.type().getType()); assertEquals( new TypeToken<Map<String, Integer>>() {}, new IKnowMyType<Map<String, Integer>>() {}.type()); }
public <T> void testWhere_mapFromWildcardToParameterized() { Type subtype = new TypeCapture<TypedListKeyMap<T>>() {}.capture(); assertEquals( new TypeCapture<TypedListKeyMap<String>>() {}.capture(), new TypeResolver() .where( new TypeCapture<Map<List<Integer>, T>>() {}.capture(), new TypeCapture<Map<?, String>>() {}.capture()) .resolveType(subtype)); }
public <T> void testWhere_mapFromWildcard() { Type subtype = new TypeCapture<TypedKeyMap<T>>() {}.capture(); assertEquals( new TypeCapture<TypedKeyMap<String>>() {}.capture(), new TypeResolver() .where( new TypeCapture<Map<Integer, T>>() {}.capture(), new TypeCapture<Map<?, String>>() {}.capture()) .resolveType(subtype)); }
public <T> void testWhere_primitiveArrayMapping() { Type t = new TypeCapture<T>() {}.capture(); assertEquals( int.class, new TypeResolver().where(new TypeCapture<T[]>() {}.capture(), int[].class).resolveType(t)); }
public <T> void testWhere_mapFromBoundedWildcard() { Type subtype = new TypeCapture<TypedKeyMap<T>>() {}.capture(); // TODO(benyu): This should check equality to an expected value, see discussion in cl/98674873 Type unused = new TypeResolver() .where( new TypeCapture<Map<Integer, T>>() {}.capture(), new TypeCapture<Map<? extends Number, ? extends Number>>() {}.capture()) .resolveType(subtype); }
public <T> void testWhere_incompatibleWildcardBounds() { try { new TypeResolver() .where( new TypeCapture<List<? extends T>>() {}.capture(), new TypeCapture<List<? super String>>() {}.capture()); fail(); } catch (IllegalArgumentException expected) { } }
public void testAssignableWildcardTypeParameterBoundedByIntArrayToArrayClassTypeParameter() { TypeToken<?> wildcardType = new TypeToken<Iterable<? extends int[]>>() {}; assertFalse(new TypeToken<Iterable<int[]>>() {}.isSupertypeOf(wildcardType)); assertFalse(new TypeToken<Iterable<Object>>() {}.isSupertypeOf(wildcardType)); assertTrue(wildcardType.isSupertypeOf(wildcardType)); assertFalse(new TypeToken<Iterable<Object[]>>() {}.isSupertypeOf(wildcardType)); }
public <From extends String & List<? extends String>> void testMultipleTypeBoundsAssignability() { assertTrue(new Assignability<From, String>() {}.isAssignable()); assertFalse(new Assignability<From, Number>() {}.isAssignable()); assertTrue(new Assignability<From, Iterable<? extends CharSequence>>() {}.isAssignable()); assertFalse(new Assignability<From, Iterable<Object>>() {}.isAssignable()); }
public <T, T1 extends T> void testAssignableGenericArrayToGenericArray() { assertTrue(new TypeToken<T[]>() {}.isSupertypeOf(new TypeToken<T[]>() {})); assertTrue(new TypeToken<T[]>() {}.isSupertypeOf(new TypeToken<T1[]>() {})); assertFalse(new TypeToken<T[]>() {}.isSupertypeOf(new TypeToken<T[][]>() {})); }