@Override public Type getType() { return this.field.getGenericType(); }
public SpringValue(String key, String placeholder, Object bean, String beanName, Field field, boolean isJson) { this.beanRef = new WeakReference<>(bean); this.beanName = beanName; this.field = field; this.key = key; this.placeholder = placeholder; this.targetType = field.getType(); this.isJson = isJson; if(isJson){ this.genericType = field.getGenericType(); } }
@Override void deserialize(AbstractHessianInput in, Object obj) throws IOException { Object value = null; try { Type[] types = ((ParameterizedType)_field.getGenericType()).getActualTypeArguments(); value = in.readObject(_field.getType(), isPrimitive(types[0]) ? (Class<?>)types[0] : null ); _field.set(obj, value); } catch (Exception e) { logDeserializeError(_field, obj, value, e); } } }
@Override void deserialize(AbstractHessianInput in, Object obj) throws IOException { Object value = null; try { Type[] types = ((ParameterizedType)_field.getGenericType()).getActualTypeArguments(); value = in.readObject(_field.getType(), isPrimitive(types[0]) ? (Class<?>)types[0] : null, isPrimitive(types[1]) ? (Class<?>)types[1] : null ); _field.set(obj, value); } catch (Exception e) { logDeserializeError(_field, obj, value, e); } } }
@Test public void withWildcardTypes() throws Exception { ParameterizedType openObjectsType = (ParameterizedType) getClass().getField("openObjects").getGenericType(); ParameterizedType openNumbersType = (ParameterizedType) getClass().getField("openNumbers").getGenericType(); Type storableObjectListType = getClass().getField("storableObjectList").getGenericType(); Type objectType = getClass().getField("object").getGenericType(); Type numberType = getClass().getField("number").getGenericType(); Type stringType = getClass().getField("string").getGenericType(); Type openWildcard = openObjectsType.getActualTypeArguments()[0]; // '?' Type openNumbersWildcard = openNumbersType.getActualTypeArguments()[0]; // '? extends number' assertTrue(TypeUtils.isAssignable(openWildcard, objectType)); assertTrue(TypeUtils.isAssignable(openNumbersWildcard, numberType)); assertFalse(TypeUtils.isAssignable(openNumbersWildcard, stringType)); assertFalse(TypeUtils.isAssignable(storableObjectListType, openObjectsType)); }
public void testInnerClassWithParameterizedOwner() throws Exception { Type fieldType = ParameterizedOuter.class.getField("field").getGenericType(); assertEquals( fieldType, TypeToken.of(ParameterizedOuter.class).resolveType(fieldType).getType()); }
public void testGetSubtype_subtypeSameAsDeclaringType() throws Exception { class Bar<T> {} class SubBar<T> extends Bar<T> { @SuppressWarnings("unused") Bar<T> delegate; TypeToken<SubBar<T>> fieldTypeAsSubBar() { return new TypeToken<SubBar<T>>() {}; } } Field delegateField = SubBar.class.getDeclaredField("delegate"); // barType is Bar<T>, a ParameterizedType with no generic arguments specified TypeToken<?> barType = TypeToken.of(delegateField.getGenericType()); assertThat(barType.getSubtype(SubBar.class)).isEqualTo(new SubBar<Void>().fieldTypeAsSubBar()); }
@SuppressWarnings("boxing") // boxing is deliberate here @Test public void testIsInstance() throws SecurityException, NoSuchFieldException { final Type intComparableType = getClass().getField("intComparable").getGenericType(); final Type uriComparableType = getClass().getField("uriComparable").getGenericType(); intComparable = 1; assertTrue(TypeUtils.isInstance(1, intComparableType)); // uriComparable = 1; assertFalse(TypeUtils.isInstance(1, uriComparableType)); }
@Test public void testDetermineTypeVariableAssignments() throws SecurityException, NoSuchFieldException, NoSuchMethodException { final ParameterizedType iterableType = (ParameterizedType) getClass().getField("iterable") .getGenericType(); final Map<TypeVariable<?>, Type> typeVarAssigns = TypeUtils.determineTypeArguments(TreeSet.class, iterableType); final TypeVariable<?> treeSetTypeVar = TreeSet.class.getTypeParameters()[0]; assertTrue(typeVarAssigns.containsKey(treeSetTypeVar)); assertEquals(iterableType.getActualTypeArguments()[0], typeVarAssigns .get(treeSetTypeVar)); }
@Test public void forField() throws Exception { Field field = Fields.class.getField("charSequenceList"); ResolvableType type = ResolvableType.forField(field); assertThat(type.getType(), equalTo(field.getGenericType())); }
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 testWildcardCaptured_typeVariableDeclaresTypeBound_wildcardHasNoExplicitUpperBound() throws Exception { TypeToken<Counter<?>> type = new TypeToken<Counter<?>>() {}; 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 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(); }
@Test public void hashCodeAndEquals() throws Exception { ResolvableType forClass = ResolvableType.forClass(List.class); ResolvableType forFieldDirect = ResolvableType.forField(Fields.class.getDeclaredField("stringList")); ResolvableType forFieldViaType = ResolvableType.forType(Fields.class.getDeclaredField("stringList").getGenericType(), (VariableResolver) null); ResolvableType forFieldWithImplementation = ResolvableType.forField(Fields.class.getDeclaredField("stringList"), TypedFields.class); assertThat(forClass, equalTo(forClass)); assertThat(forClass.hashCode(), equalTo(forClass.hashCode())); assertThat(forClass, not(equalTo(forFieldDirect))); assertThat(forClass, not(equalTo(forFieldWithImplementation))); assertThat(forFieldDirect, equalTo(forFieldDirect)); assertThat(forFieldDirect, not(equalTo(forFieldViaType))); assertThat(forFieldDirect, not(equalTo(forFieldWithImplementation))); }
@Test public void getComponentTypeForClassArray() throws Exception { Field field = Fields.class.getField("arrayClassType"); ResolvableType type = ResolvableType.forField(field); assertThat(type.isArray(), equalTo(true)); assertThat(type.getComponentType().getType(), equalTo((Type) ((Class) field.getGenericType()).getComponentType())); }
public void testWildcardCaptured_typeVariableDeclaresTypeBound_wildcardAddsNewUpperBound() throws Exception { TypeToken<Counter<? extends Iterable<?>>> type = new TypeToken<Counter<? extends Iterable<?>>>() {}; 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().contains(Number.class); assertThat(captured.getBounds()) .asList() .containsNoneOf(Object.class, new TypeToken<Iterable<Number>>() {}.getType()); assertThat(new TypeToken<List<? extends Number>>() {}.isSupertypeOf(fieldType)).isTrue(); assertThat(new TypeToken<List<? extends Iterable<?>>>() {}.isSupertypeOf(fieldType)).isTrue(); assertThat(new TypeToken<List<? extends Iterable<Number>>>() {}.isSupertypeOf(fieldType)) .isFalse(); }
@Test public void resolveTypeWithCustomVariableResolver() throws Exception { VariableResolver variableResolver = mock(VariableResolver.class); given(variableResolver.getSource()).willReturn(this); ResolvableType longType = ResolvableType.forClass(Long.class); given(variableResolver.resolveVariable(any())).willReturn(longType); ResolvableType variable = ResolvableType.forType( Fields.class.getField("typeVariableType").getGenericType(), variableResolver); ResolvableType parameterized = ResolvableType.forType( Fields.class.getField("parameterizedType").getGenericType(), variableResolver); assertThat(variable.resolve(), equalTo((Class) Long.class)); assertThat(parameterized.resolve(), equalTo((Class) List.class)); assertThat(parameterized.resolveGeneric(), equalTo((Class) Long.class)); verify(variableResolver, atLeastOnce()).resolveVariable(this.typeVariableCaptor.capture()); assertThat(this.typeVariableCaptor.getValue().getName(), equalTo("T")); }
@Test public void forPrivateField() throws Exception { Field field = Fields.class.getDeclaredField("privateField"); ResolvableType type = ResolvableType.forField(field); assertThat(type.getType(), equalTo(field.getGenericType())); assertThat(type.resolve(), equalTo((Class) List.class)); assertThat(type.getSource(), sameInstance(field)); Field field2 = Fields.class.getDeclaredField("otherPrivateField"); ResolvableType type2 = ResolvableType.forField(field2); assertThat(type2.getType(), equalTo(field2.getGenericType())); assertThat(type2.resolve(), equalTo((Class) List.class)); assertThat(type2.getSource(), sameInstance(field2)); assertEquals(type, type2); assertEquals(type.hashCode(), type2.hashCode()); }
@Test public void withGenericArrayTypes() throws Exception { Type arrayType = getClass().getField("array").getGenericType(); Type openArrayType = getClass().getField("openArray").getGenericType(); assertTrue(TypeUtils.isAssignable(Object.class, arrayType)); assertTrue(TypeUtils.isAssignable(Object.class, openArrayType)); assertTrue(TypeUtils.isAssignable(List[].class, arrayType)); assertTrue(TypeUtils.isAssignable(List[].class, openArrayType)); assertTrue(TypeUtils.isAssignable(arrayType, List[].class)); assertTrue(TypeUtils.isAssignable(openArrayType, List[].class)); assertTrue(TypeUtils.isAssignable(arrayType, arrayType)); assertTrue(TypeUtils.isAssignable(openArrayType, openArrayType)); assertTrue(TypeUtils.isAssignable(openArrayType, arrayType)); }
@Test public void testToStringLang1311() { assertEquals("int[]", TypeUtils.toString(int[].class)); assertEquals("java.lang.Integer[]", TypeUtils.toString(Integer[].class)); final Field stringListField = FieldUtils.getDeclaredField(getClass(), "stringListArray"); assertEquals("java.util.List<java.lang.String>[]", TypeUtils.toString(stringListField.getGenericType())); }