/** Explicitly specifies the return type of this {@code Invokable}. */ public final <R1 extends R> Invokable<T, R1> returning(TypeToken<R1> returnType) { if (!returnType.isSupertypeOf(getReturnType())) { throw new IllegalArgumentException( "Invokable is known to return " + getReturnType() + ", not " + returnType); } @SuppressWarnings("unchecked") // guarded by previous check Invokable<T, R1> specialized = (Invokable<T, R1>) this; return specialized; }
public void testAssignableClassToClass() { @SuppressWarnings("rawtypes") // To test TypeToken<List> TypeToken<List> tokL = new TypeToken<List>() {}; assertTrue(tokL.isSupertypeOf(List.class)); assertTrue(tokL.isSupertypeOf(ArrayList.class)); assertFalse(tokL.isSupertypeOf(List[].class)); TypeToken<Number> tokN = new TypeToken<Number>() {}; assertTrue(tokN.isSupertypeOf(Number.class)); assertTrue(tokN.isSupertypeOf(Integer.class)); }
public void testAssignableArrayToClass() { @SuppressWarnings("rawtypes") // Trying to test raw class TypeToken<List[]> tokL = new TypeToken<List[]>() {}; assertTrue(tokL.isSupertypeOf(List[].class)); assertFalse(tokL.isSupertypeOf(List.class)); @SuppressWarnings("rawtypes") // Trying to test raw class TypeToken<Second[]> tokS = new TypeToken<Second[]>() {}; assertTrue(tokS.isSupertypeOf(Second[].class)); assertTrue(tokS.isSupertypeOf(Third[].class)); }
public void testAssignableClassToArrayType() { TypeToken<List<String>[]> tokenL = new TypeToken<List<String>[]>() {}; assertTrue(tokenL.isSupertypeOf(StringList[].class)); assertFalse(tokenL.isSupertypeOf(List[].class)); }
public void testAssignableWildcardTypeParameterToWildcardTypeParameter() { TypeToken<?> subtypeOfArray = new TypeToken<Iterable<? extends Object[]>>() {}; TypeToken<?> supertypeOfArray = new TypeToken<Iterable<? super Object[]>>() {}; assertFalse(supertypeOfArray.isSupertypeOf(subtypeOfArray)); assertTrue(supertypeOfArray.isSupertypeOf(supertypeOfArray)); assertTrue(subtypeOfArray.isSupertypeOf(subtypeOfArray)); assertFalse(subtypeOfArray.isSupertypeOf(supertypeOfArray)); }
public void testAssignableParameterizedTypeToClass() { @SuppressWarnings("rawtypes") // Trying to test raw class TypeToken<List> tokL = new TypeToken<List>() {}; assertTrue(tokL.isSupertypeOf(StringList.class)); assertTrue(tokL.isSupertypeOf(StringList.class.getGenericInterfaces()[0])); @SuppressWarnings("rawtypes") // Trying to test raw class TypeToken<Second> tokS = new TypeToken<Second>() {}; assertTrue(tokS.isSupertypeOf(Second.class)); assertTrue(tokS.isSupertypeOf(Third.class.getGenericSuperclass())); }
public void testAssignableParameterizedTypeToType() { TypeToken<List<String>> tokenL = new TypeToken<List<String>>() {}; assertTrue(tokenL.isSupertypeOf(StringList.class.getGenericInterfaces()[0])); assertFalse(tokenL.isSupertypeOf(IntegerList.class.getGenericInterfaces()[0])); TypeToken<First<String>> tokenF = new TypeToken<First<String>>() {}; assertTrue(tokenF.isSupertypeOf(ConcreteIS.class.getGenericSuperclass())); assertFalse(tokenF.isSupertypeOf(ConcreteSI.class.getGenericSuperclass())); }
public void testAssignableClassTypeParameterToWildcardTypeParameter() { TypeToken<?> subtypeOfArray = new TypeToken<Iterable<? extends Object[]>>() {}; TypeToken<?> supertypeOfArray = new TypeToken<Iterable<? super Object[]>>() {}; assertTrue(subtypeOfArray.isSupertypeOf(new TypeToken<Iterable<Object[]>>() {})); assertTrue(subtypeOfArray.isSupertypeOf(new TypeToken<Iterable<Object[][]>>() {})); assertTrue(subtypeOfArray.isSupertypeOf(new TypeToken<Iterable<String[]>>() {})); assertTrue(supertypeOfArray.isSupertypeOf(new TypeToken<Iterable<Object[]>>() {})); assertTrue(supertypeOfArray.isSupertypeOf(new TypeToken<Iterable<Object>>() {})); assertFalse(supertypeOfArray.isSupertypeOf(new TypeToken<Iterable<Object[][]>>() {})); assertFalse(supertypeOfArray.isSupertypeOf(new TypeToken<Iterable<String[]>>() {})); }
public <T, T1 extends T> void testAssignableGenericArrayToClass() { assertTrue(TypeToken.of(Object[].class.getSuperclass()).isSupertypeOf(new TypeToken<T[]>() {})); for (Class<?> interfaceType : Object[].class.getInterfaces()) { assertTrue(TypeToken.of(interfaceType).isSupertypeOf(new TypeToken<T[]>() {})); } assertTrue(TypeToken.of(Object.class).isSupertypeOf(new TypeToken<T[]>() {})); assertFalse(TypeToken.of(String.class).isSupertypeOf(new TypeToken<T[]>() {})); }
public <T> void testAssignableGenericArrayToArrayClass() { assertTrue(TypeToken.of(Object[].class).isSupertypeOf(new TypeToken<T[]>() {})); assertTrue(TypeToken.of(Object[].class).isSupertypeOf(new TypeToken<T[][]>() {})); assertTrue(TypeToken.of(Object[][].class).isSupertypeOf(new TypeToken<T[][]>() {})); }
public void testAssignableClassToType() { TypeToken<List<String>> tokenL = new TypeToken<List<String>>() {}; assertTrue(tokenL.isSupertypeOf(StringList.class)); assertFalse(tokenL.isSupertypeOf(List.class)); TypeToken<First<String>> tokenF = new TypeToken<First<String>>() {}; assertTrue(tokenF.isSupertypeOf(ConcreteIS.class)); assertFalse(tokenF.isSupertypeOf(ConcreteSI.class)); }
public void testAssignableWildcardBoundedByIntArrayToArrayClass() { Type wildcardType = Types.subtypeOf(int[].class); assertTrue(TypeToken.of(int[].class).isSupertypeOf(wildcardType)); assertTrue(TypeToken.of(Object.class).isSupertypeOf(wildcardType)); assertFalse(TypeToken.of(wildcardType).isSupertypeOf(wildcardType)); assertFalse(TypeToken.of(Object[].class).isSupertypeOf(wildcardType)); }
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)); }
public void testAssignableWildcardToWildcard() { TypeToken<?> subtypeOfArray = TypeToken.of(Types.subtypeOf(Object[].class)); TypeToken<?> supertypeOfArray = TypeToken.of(Types.supertypeOf(Object[].class)); assertTrue(supertypeOfArray.isSupertypeOf(subtypeOfArray)); assertFalse(supertypeOfArray.isSupertypeOf(supertypeOfArray)); assertFalse(subtypeOfArray.isSupertypeOf(subtypeOfArray)); assertFalse(subtypeOfArray.isSupertypeOf(supertypeOfArray)); }
public <T> void testAssignableParameterizedTypeToObject() { assertTrue( TypeToken.of(Object.class).isSupertypeOf(TypeToken.of(new TypeCapture<T>() {}.capture()))); assertFalse( TypeToken.of(int.class).isSupertypeOf(TypeToken.of(new TypeCapture<T>() {}.capture()))); }
public void testGenericArrayTypeToArrayType() { TypeToken<List<String>[]> tokL = new TypeToken<List<String>[]>() {}; TypeToken<ArrayList<String>[]> token = new TypeToken<ArrayList<String>[]>() {}; assertTrue(tokL.isSupertypeOf(tokL.getType())); assertTrue(tokL.isSupertypeOf(token.getType())); }
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>>() {})); }
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 testAssignableWildcardTypeParameterToClassTypeParameter() { TypeToken<?> wildcardType = new TypeToken<Iterable<? extends Object[]>>() {}; assertFalse(new TypeToken<Iterable<Object[]>>() {}.isSupertypeOf(wildcardType)); assertFalse(new TypeToken<Iterable<Object>>() {}.isSupertypeOf(wildcardType)); assertTrue(wildcardType.isSupertypeOf(wildcardType)); assertFalse(new TypeToken<Iterable<int[]>>() {}.isSupertypeOf(wildcardType)); }