@Override public <S, T> void addConverter(Class<S> sourceType, Class<T> targetType, Converter<? super S, ? extends T> converter) { addConverter(new ConverterAdapter( converter, ResolvableType.forClass(sourceType), ResolvableType.forClass(targetType))); }
@Test public void emptyListToObject() { conversionService.addConverter(new CollectionToObjectConverter(conversionService)); conversionService.addConverterFactory(new StringToNumberConverterFactory()); List<String> list = new ArrayList<>(); TypeDescriptor sourceType = TypeDescriptor.forObject(list); TypeDescriptor targetType = TypeDescriptor.valueOf(Integer.class); assertTrue(conversionService.canConvert(sourceType, targetType)); assertNull(conversionService.convert(list, sourceType, targetType)); }
@Bean public ConversionService webSocketConversionService() { GenericConversionService conversionService = new DefaultConversionService(); conversionService.addConverter(new MyTypeToStringConverter()); conversionService.addConverter(new MyTypeToBytesConverter()); conversionService.addConverter(new StringToMyTypeConverter()); conversionService.addConverter(new BytesToMyTypeConverter()); return conversionService; }
@Test public void stringToCollectionCanConvert() throws Exception { conversionService.addConverter(new StringToCollectionConverter(conversionService)); assertTrue(conversionService.canConvert(String.class, Collection.class)); TypeDescriptor targetType = new TypeDescriptor(getClass().getField("integerCollection")); assertFalse(conversionService.canConvert(TypeDescriptor.valueOf(String.class), targetType)); conversionService.addConverterFactory(new StringToNumberConverterFactory()); assertTrue(conversionService.canConvert(TypeDescriptor.valueOf(String.class), targetType)); }
@Override public void addConverterFactory(ConverterFactory<?, ?> factory) { ResolvableType[] typeInfo = getRequiredTypeInfo(factory.getClass(), ConverterFactory.class); if (typeInfo == null && factory instanceof DecoratingProxy) { typeInfo = getRequiredTypeInfo(((DecoratingProxy) factory).getDecoratedClass(), ConverterFactory.class); } if (typeInfo == null) { throw new IllegalArgumentException("Unable to determine source type <S> and target type <T> for your " + "ConverterFactory [" + factory.getClass().getName() + "]; does the class parameterize those types?"); } addConverter(new ConverterFactoryAdapter(factory, new ConvertiblePair(typeInfo[0].toClass(), typeInfo[1].toClass()))); }
@Test public void conditionalConverterFactory() { MyConditionalConverterFactory converter = new MyConditionalConverterFactory(); conversionService.addConverter(new ColorConverter()); conversionService.addConverterFactory(converter); assertEquals(Color.BLACK, conversionService.convert("#000000", Color.class)); assertTrue(converter.getMatchAttempts() > 0); assertTrue(converter.getNestedMatchAttempts() > 0); }
@Test public void collectionMapNotGenericTargetCollectionToObjectInteraction() throws Exception { Map<String, List<String>> map = new HashMap<>(); map.put("1", Arrays.asList("9", "12")); map.put("2", Arrays.asList("37", "23")); conversionService.addConverter(new CollectionToCollectionConverter(conversionService)); conversionService.addConverter(new CollectionToObjectConverter(conversionService)); assertTrue(conversionService.canConvert(Map.class, Map.class)); assertSame(map, conversionService.convert(map, Map.class)); }
@Test public void convertSuperSourceType() { conversionService.addConverter(new Converter<CharSequence, Integer>() { @Override public Integer convert(CharSequence source) { return Integer.valueOf(source.toString()); } }); Integer result = conversionService.convert("3", Integer.class); assertEquals(Integer.valueOf(3), result); }
@Test public void testEnumWithInterfaceToStringConversion() { // SPR-9692 conversionService.addConverter(new EnumToStringConverter(conversionService)); conversionService.addConverter(new MyEnumInterfaceToStringConverter<MyEnum>()); assertEquals("1", conversionService.convert(MyEnum.A, String.class)); }
@Test public void collectionToObjectInteraction() throws Exception { List<List<String>> list = new ArrayList<>(); list.add(Arrays.asList("9", "12")); list.add(Arrays.asList("37", "23")); conversionService.addConverter(new CollectionToObjectConverter(conversionService)); assertTrue(conversionService.canConvert(List.class, List.class)); assertSame(list, conversionService.convert(list, List.class)); }
@Test public void testObjectArrayToStringArray() { conversionService.addConverter(new MyBaseInterfaceToStringConverter()); conversionService.addConverter(new ArrayToArrayConverter(conversionService)); String[] converted = conversionService.convert(new MyInterfaceImplementer[] {new MyInterfaceImplementer()}, String[].class); assertEquals("RESULT", converted[0]); }
@Test public void shouldNotSupportNullConvertibleTypesFromNonConditionalGenericConverter() { GenericConverter converter = new NonConditionalGenericConverter(); try { conversionService.addConverter(converter); fail("Did not throw IllegalStateException"); } catch (IllegalStateException ex) { assertEquals("Only conditional converters may return null convertible types", ex.getMessage()); } }
@Test public void testInterfaceArrayToStringArray() { conversionService.addConverter(new MyBaseInterfaceToStringConverter()); conversionService.addConverter(new ArrayToArrayConverter(conversionService)); String[] converted = conversionService.convert(new MyInterface[] {new MyInterfaceImplementer()}, String[].class); assertEquals("RESULT", converted[0]); }
@Test public void conditionalConversionForAllTypes() { MyConditionalGenericConverter converter = new MyConditionalGenericConverter(); conversionService.addConverter(converter); assertEquals((Integer) 3, conversionService.convert(3, Integer.class)); assertThat(converter.getSourceTypes().size(), greaterThan(2)); assertTrue(converter.getSourceTypes().stream().allMatch(td -> Integer.class.equals(td.getType()))); }
@Test public void conditionalConverter() { MyConditionalConverter converter = new MyConditionalConverter(); conversionService.addConverter(new ColorConverter()); conversionService.addConverter(converter); assertEquals(Color.BLACK, conversionService.convert("#000000", Color.class)); assertTrue(converter.getMatchAttempts() > 0); }
@Test public void testStringArrayToIntegerArray() { conversionService.addConverter(new MyStringArrayToIntegerArrayConverter()); Integer[] converted = conversionService.convert(new String[] {"x1", "z3"}, Integer[].class); assertArrayEquals(new Integer[] { 1, 3 }, converted); }
@Test public void testSubclassOfEnumToString() throws Exception { conversionService.addConverter(new EnumToStringConverter(conversionService)); assertEquals("FIRST", conversionService.convert(EnumWithSubclass.FIRST, String.class)); }
@Test public void testStringToIntegerArray() { conversionService.addConverter(new MyStringToIntegerArrayConverter()); Integer[] converted = conversionService.convert("x1,z3", Integer[].class); assertArrayEquals(new Integer[] { 1, 3 }, converted); }
@Test(expected = ConverterNotFoundException.class) public void genericConverterDelegatingBackToConversionServiceConverterNotFound() { conversionService.addConverter(new ObjectToArrayConverter(conversionService)); assertFalse(conversionService.canConvert(String.class, Integer[].class)); conversionService.convert("3,4,5", Integer[].class); }
@Test public void convertObjectToPrimitive() { assertFalse(conversionService.canConvert(String.class, boolean.class)); conversionService.addConverter(new StringToBooleanConverter()); assertTrue(conversionService.canConvert(String.class, boolean.class)); Boolean b = conversionService.convert("true", boolean.class); assertTrue(b); assertTrue(conversionService.canConvert(TypeDescriptor.valueOf(String.class), TypeDescriptor.valueOf(boolean.class))); b = (Boolean) conversionService.convert("true", TypeDescriptor.valueOf(String.class), TypeDescriptor.valueOf(boolean.class)); assertTrue(b); }