root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

more generic converters

This commit is contained in:
Keith Donald 2009-09-22 20:28:23 +00:00
parent ed611be838
commit e6c3227d2d
7 changed files with 457 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
org.springframework.core/src/main/java/org/springframework/core/convert/support/ArrayToStringGenericConverter.java Normal file
View File

@ -0,0 +1,69 @@
/*
* Copyright 2002-2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.core.convert.support;
import static org.springframework.core.convert.support.ConversionUtils.invokeConverter;
import java.lang.reflect.Array;
import org.springframework.core.convert.ConverterNotFoundException;
import org.springframework.core.convert.TypeDescriptor;
final class ArrayToStringGenericConverter implements GenericConverter {
private static final String DELIMITER = ",";
private final GenericConversionService conversionService;
public ArrayToStringGenericConverter(GenericConversionService conversionService) {
this.conversionService = conversionService;
}
public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
int length = Array.getLength(source);
if (length == 0) {
return "";
} else {
TypeDescriptor sourceElementType = sourceType.getElementTypeDescriptor();
if (sourceElementType.isAssignableTo(targetType)) {
StringBuilder string = new StringBuilder();
for (int i = 0; i < length; i++) {
if (i > 0) {
string.append(DELIMITER);
}
string.append(Array.get(source, i));
}
return string.toString();
} else {
GenericConverter converter = this.conversionService.getConverter(sourceElementType, targetType);
if (converter == null) {
throw new ConverterNotFoundException(sourceElementType, targetType);
}
StringBuilder string = new StringBuilder();
for (int i = 0; i < length; i++) {
if (i > 0) {
string.append(DELIMITER);
}
Object sourceElement = Array.get(source, i);
Object targetElement = invokeConverter(converter, sourceElement, sourceElementType, targetType);
string.append(targetElement);
}
return string.toString();
}
}
}
}

75
org.springframework.core/src/main/java/org/springframework/core/convert/support/CollectionToStringGenericConverter.java Normal file
View File

@ -0,0 +1,75 @@
/*
* Copyright 2002-2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.core.convert.support;
import static org.springframework.core.convert.support.ConversionUtils.getElementType;
import static org.springframework.core.convert.support.ConversionUtils.invokeConverter;
import java.util.Collection;
import org.springframework.core.convert.ConverterNotFoundException;
import org.springframework.core.convert.TypeDescriptor;
final class CollectionToStringGenericConverter implements GenericConverter {
private static final String DELIMITER = ",";
private final GenericConversionService conversionService;
public CollectionToStringGenericConverter(GenericConversionService conversionService) {
this.conversionService = conversionService;
}
public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
Collection sourceCollection = (Collection) source;
if (sourceCollection.size() == 0) {
return "";
} else {
TypeDescriptor sourceElementType = sourceType.getElementTypeDescriptor();
if (sourceElementType == TypeDescriptor.NULL) {
sourceElementType = getElementType(sourceCollection);
}
if (sourceElementType == TypeDescriptor.NULL || sourceElementType.isAssignableTo(targetType)) {
StringBuilder string = new StringBuilder();
int i = 0;
for (Object element : sourceCollection) {
if (i > 0) {
string.append(DELIMITER);
}
string.append(element);
i++;
}
return string.toString();
} else {
GenericConverter converter = this.conversionService.getConverter(sourceElementType, targetType);
if (converter == null) {
throw new ConverterNotFoundException(sourceElementType, targetType);
}
StringBuilder string = new StringBuilder();
int i = 0;
for (Object sourceElement : sourceCollection) {
if (i > 0) {
string.append(DELIMITER);
}
Object targetElement = invokeConverter(converter, sourceElement, sourceElementType, targetType);
string.append(targetElement);
i++;
}
return string.toString();
}
}
}
}

19
org.springframework.core/src/main/java/org/springframework/core/convert/support/ConversionUtils.java
View File

@ -1,3 +1,18 @@
/*
* Copyright 2002-2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.core.convert.support;
import java.util.Collection;
@ -6,12 +21,12 @@ import org.springframework.core.convert.ConversionFailedException;
import org.springframework.core.convert.TypeDescriptor;
final class ConversionUtils {
public static Object invokeConverter(GenericConverter converter, Object source, TypeDescriptor sourceType,
TypeDescriptor targetType) {
try {
return converter.convert(source, sourceType, targetType);
}
catch (Exception ex) {
} catch (Exception ex) {
throw new ConversionFailedException(sourceType, targetType, source, ex);
}
}

5
org.springframework.core/src/main/java/org/springframework/core/convert/support/GenericConversionService.java
View File

@ -184,14 +184,17 @@ public class GenericConversionService implements ConversionService, ConverterReg
protected void initGenericConverters() {
addGenericConverter(Object[].class, Object[].class, new ArrayToArrayGenericConverter(this));
addGenericConverter(Object[].class, Collection.class, new ArrayToCollectionGenericConverter(this));
addGenericConverter(Object[].class, String.class, new ArrayToStringGenericConverter(this));
addGenericConverter(Object[].class, Object.class, new ArrayToObjectGenericConverter(this));
addGenericConverter(Collection.class, Collection.class, new CollectionToCollectionGenericConverter(this));
addGenericConverter(Collection.class, Object[].class, new CollectionToArrayGenericConverter(this));
addGenericConverter(Collection.class, String.class, new CollectionToStringGenericConverter(this));
addGenericConverter(Collection.class, Object.class, new CollectionToObjectGenericConverter(this));
addGenericConverter(Map.class, Map.class, new MapToMapGenericConverter(this));
addGenericConverter(String.class, Object[].class, new StringToArrayGenericConverter(this));
addGenericConverter(String.class, Collection.class, new StringToCollectionGenericConverter(this));
addGenericConverter(Object.class, Object[].class, new ObjectToArrayGenericConverter(this));
addGenericConverter(Object.class, Collection.class, new ObjectToCollectionGenericConverter(this));
addGenericConverter(String.class, Object[].class, new StringToArrayGenericConverter(this));
}
/**

53
org.springframework.core/src/main/java/org/springframework/core/convert/support/StringToArrayGenericConverter.java Normal file
View File

@ -0,0 +1,53 @@
/*
* Copyright 2002-2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.core.convert.support;
import static org.springframework.core.convert.support.ConversionUtils.invokeConverter;
import java.lang.reflect.Array;
import org.springframework.core.convert.ConverterNotFoundException;
import org.springframework.core.convert.TypeDescriptor;
import org.springframework.util.StringUtils;
final class StringToArrayGenericConverter implements GenericConverter {
private final GenericConversionService conversionService;
public StringToArrayGenericConverter(GenericConversionService conversionService) {
this.conversionService = conversionService;
}
public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
String string = (String) source;
String[] fields = StringUtils.commaDelimitedListToStringArray(string);
TypeDescriptor targetElementType = targetType.getElementTypeDescriptor();
if (sourceType.isAssignableTo(targetElementType)) {
return fields;
} else {
Object target = Array.newInstance(targetElementType.getType(), fields.length);
GenericConverter converter = this.conversionService.getConverter(sourceType, targetElementType);
if (converter == null) {
throw new ConverterNotFoundException(sourceType, targetElementType);
}
for (int i = 0; i < fields.length; i++) {
Array.set(target, i, invokeConverter(converter, fields[i], sourceType, targetElementType));
}
return target;
}
}
}

58
org.springframework.core/src/main/java/org/springframework/core/convert/support/StringToCollectionGenericConverter.java Normal file
View File

@ -0,0 +1,58 @@
/*
* Copyright 2002-2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.core.convert.support;
import static org.springframework.core.convert.support.ConversionUtils.invokeConverter;
import java.util.Collection;
import org.springframework.core.CollectionFactory;
import org.springframework.core.convert.ConverterNotFoundException;
import org.springframework.core.convert.TypeDescriptor;
import org.springframework.util.StringUtils;
final class StringToCollectionGenericConverter implements GenericConverter {
private final GenericConversionService conversionService;
public StringToCollectionGenericConverter(GenericConversionService conversionService) {
this.conversionService = conversionService;
}
public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
String string = (String) source;
String[] fields = StringUtils.commaDelimitedListToStringArray(string);
Collection target = CollectionFactory.createCollection(targetType.getType(), 1);
TypeDescriptor targetElementType = targetType.getElementTypeDescriptor();
if (targetElementType == TypeDescriptor.NULL || sourceType.isAssignableTo(targetElementType)) {
for (int i = 0; i < fields.length; i++) {
target.add(fields[i]);
}
} else {
GenericConverter converter = this.conversionService.getConverter(sourceType, targetElementType);
if (converter == null) {
throw new ConverterNotFoundException(sourceType, targetElementType);
}
for (int i = 0; i < fields.length; i++) {
String sourceElement = fields[i];
Object targetElement = invokeConverter(converter, sourceElement, sourceType, targetElementType);
target.add(targetElement);
}
}
return target;
}
}

282
org.springframework.core/src/test/java/org/springframework/core/convert/support/GenericConversionServiceTests.java
View File

@ -24,6 +24,7 @@ import static org.junit.Assert.assertTrue;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashSet;
@ -32,7 +33,6 @@ import java.util.List;
import java.util.Map;
import java.util.Set;
import org.junit.Ignore;
import org.junit.Test;
import org.springframework.core.convert.ConversionFailedException;
import org.springframework.core.convert.ConverterNotFoundException;
@ -44,28 +44,28 @@ import org.springframework.core.convert.converter.Converter;
*/
public class GenericConversionServiceTests {
private GenericConversionService converter = new GenericConversionService();
private GenericConversionService conversionService = new GenericConversionService();
@Test
public void executeConversion() {
converter.addConverterFactory(new StringToNumberConverterFactory());
assertEquals(new Integer(3), converter.convert("3", Integer.class));
conversionService.addConverterFactory(new StringToNumberConverterFactory());
assertEquals(new Integer(3), conversionService.convert("3", Integer.class));
}
@Test
public void executeConversionNullSource() {
assertEquals(null, converter.convert(null, Integer.class));
assertEquals(null, conversionService.convert(null, Integer.class));
}
@Test
public void executeCompatibleSource() {
assertEquals(Boolean.FALSE, converter.convert(false, boolean.class));
assertEquals(Boolean.FALSE, conversionService.convert(false, boolean.class));
}
@Test
public void converterNotFound() {
try {
converter.convert("3", Integer.class);
conversionService.convert("3", Integer.class);
fail("Should have thrown an exception");
} catch (ConverterNotFoundException e) {
}
@ -74,7 +74,7 @@ public class GenericConversionServiceTests {
@Test
public void addConverterNoSourceTargetClassInfoAvailable() {
try {
converter.addConverter(new Converter() {
conversionService.addConverter(new Converter() {
public Object convert(Object source) {
return source;
}
@ -87,24 +87,24 @@ public class GenericConversionServiceTests {
@Test
public void convertNull() {
assertNull(converter.convert(null, Integer.class));
assertNull(conversionService.convert(null, Integer.class));
}
@Test(expected = IllegalArgumentException.class)
public void convertNullTargetClass() {
assertEquals("3", converter.convert("3", (Class<?>) null));
assertEquals("3", conversionService.convert("3", (Class<?>) null));
}
@Test
public void convertNullTypeDescriptor() {
assertEquals(null, converter.convert(3, TypeDescriptor.valueOf(String.class), TypeDescriptor.NULL));
assertEquals(null, conversionService.convert(3, TypeDescriptor.valueOf(String.class), TypeDescriptor.NULL));
}
@Test
public void convertWrongTypeArgument() {
converter.addConverterFactory(new StringToNumberConverterFactory());
conversionService.addConverterFactory(new StringToNumberConverterFactory());
try {
converter.convert("BOGUS", Integer.class);
conversionService.convert("BOGUS", Integer.class);
fail("Should have failed");
} catch (ConversionFailedException e) {
@ -113,26 +113,26 @@ public class GenericConversionServiceTests {
@Test
public void convertSuperSourceType() {
converter.addConverter(new Converter<CharSequence, Integer>() {
conversionService.addConverter(new Converter<CharSequence, Integer>() {
public Integer convert(CharSequence source) {
return Integer.valueOf(source.toString());
}
});
Integer result = converter.convert("3", Integer.class);
Integer result = conversionService.convert("3", Integer.class);
assertEquals(new Integer(3), result);
}
@Test
public void convertObjectToPrimitive() {
converter.addConverterFactory(new StringToNumberConverterFactory());
Integer three = converter.convert("3", int.class);
conversionService.addConverterFactory(new StringToNumberConverterFactory());
Integer three = conversionService.convert("3", int.class);
assertEquals(3, three.intValue());
}
@Test
public void convertArrayToArray() {
converter.addConverterFactory(new StringToNumberConverterFactory());
Integer[] result = converter.convert(new String[] { "1", "2", "3" }, Integer[].class);
conversionService.addConverterFactory(new StringToNumberConverterFactory());
Integer[] result = conversionService.convert(new String[] { "1", "2", "3" }, Integer[].class);
assertEquals(new Integer(1), result[0]);
assertEquals(new Integer(2), result[1]);
assertEquals(new Integer(3), result[2]);
@ -140,8 +140,8 @@ public class GenericConversionServiceTests {
@Test
public void convertArrayToPrimitiveArray() {
converter.addConverterFactory(new StringToNumberConverterFactory());
int[] result = converter.convert(new String[] { "1", "2", "3" }, int[].class);
conversionService.addConverterFactory(new StringToNumberConverterFactory());
int[] result = conversionService.convert(new String[] { "1", "2", "3" }, int[].class);
assertEquals(1, result[0]);
assertEquals(2, result[1]);
assertEquals(3, result[2]);
@ -149,7 +149,7 @@ public class GenericConversionServiceTests {
@Test
public void convertArrayToArrayAssignable() {
int[] result = converter.convert(new int[] { 1, 2, 3 }, int[].class);
int[] result = conversionService.convert(new int[] { 1, 2, 3 }, int[].class);
assertEquals(1, result[0]);
assertEquals(2, result[1]);
assertEquals(3, result[2]);
@ -157,7 +157,7 @@ public class GenericConversionServiceTests {
@Test
public void convertArrayToListInterface() {
List<?> result = converter.convert(new String[] { "1", "2", "3" }, List.class);
List<?> result = conversionService.convert(new String[] { "1", "2", "3" }, List.class);
assertEquals("1", result.get(0));
assertEquals("2", result.get(1));
assertEquals("3", result.get(2));
@ -167,8 +167,8 @@ public class GenericConversionServiceTests {
@Test
public void convertArrayToListGenericTypeConversion() throws Exception {
converter.addConverterFactory(new StringToNumberConverterFactory());
List<Integer> result = (List<Integer>) converter.convert(new String[] { "1", "2", "3" }, TypeDescriptor
conversionService.addConverterFactory(new StringToNumberConverterFactory());
List<Integer> result = (List<Integer>) conversionService.convert(new String[] { "1", "2", "3" }, TypeDescriptor
.valueOf(String[].class), new TypeDescriptor(getClass().getDeclaredField("genericList")));
assertEquals(new Integer("1"), result.get(0));
assertEquals(new Integer("2"), result.get(1));
@ -177,7 +177,7 @@ public class GenericConversionServiceTests {
@Test
public void convertArrayToListImpl() {
LinkedList<?> result = converter.convert(new String[] { "1", "2", "3" }, LinkedList.class);
LinkedList<?> result = conversionService.convert(new String[] { "1", "2", "3" }, LinkedList.class);
assertEquals("1", result.get(0));
assertEquals("2", result.get(1));
assertEquals("3", result.get(2));
@ -185,29 +185,63 @@ public class GenericConversionServiceTests {
@Test(expected = ConversionFailedException.class)
public void convertArrayToAbstractList() {
converter.convert(new String[] { "1", "2", "3" }, AbstractList.class);
conversionService.convert(new String[] { "1", "2", "3" }, AbstractList.class);
}
@Test
public void convertListToArray() {
public void convertArrayToString() {
String result = conversionService.convert(new String[] { "1", "2", "3" }, String.class);
assertEquals("1,2,3", result);
}
@Test
public void convertArrayToStringWithElementConversion() {
conversionService.addConverter(new ObjectToStringConverter());
String result = conversionService.convert(new Integer[] { 1, 2, 3 }, String.class);
assertEquals("1,2,3", result);
}
@Test
public void convertEmptyArrayToString() {
String result = conversionService.convert(new String[0], String.class);
assertEquals("", result);
}
@Test
public void convertArrayToObject() {
Object[] array = new Object[] { 3L };
Object result = conversionService.convert(array, Object.class);
assertEquals(3L, result);
}
@Test
public void convertArrayToObjectWithElementConversion() {
conversionService.addConverterFactory(new StringToNumberConverterFactory());
String[] array = new String[] { "3" };
Integer result = conversionService.convert(array, Integer.class);
assertEquals(new Integer(3), result);
}
@Test
public void convertCollectionToArray() {
List<String> list = new ArrayList<String>();
list.add("1");
list.add("2");
list.add("3");
String[] result = converter.convert(list, String[].class);
String[] result = conversionService.convert(list, String[].class);
assertEquals("1", result[0]);
assertEquals("2", result[1]);
assertEquals("3", result[2]);
}
@Test
public void convertListToArrayWithComponentConversion() {
converter.addConverterFactory(new StringToNumberConverterFactory());
public void convertCollectionToArrayWithElementConversion() {
conversionService.addConverterFactory(new StringToNumberConverterFactory());
List<String> list = new ArrayList<String>();
list.add("1");
list.add("2");
list.add("3");
Integer[] result = converter.convert(list, Integer[].class);
Integer[] result = conversionService.convert(list, Integer[].class);
assertEquals(new Integer(1), result[0]);
assertEquals(new Integer(2), result[1]);
assertEquals(new Integer(3), result[2]);
@ -215,18 +249,48 @@ public class GenericConversionServiceTests {
@Test
public void convertCollectionToCollection() throws Exception {
converter.addConverterFactory(new StringToNumberConverterFactory());
conversionService.addConverterFactory(new StringToNumberConverterFactory());
Set<String> foo = new LinkedHashSet<String>();
foo.add("1");
foo.add("2");
foo.add("3");
List<Integer> bar = (List<Integer>) converter.convert(foo, TypeDescriptor.valueOf(List.class),
List<Integer> bar = (List<Integer>) conversionService.convert(foo, TypeDescriptor.valueOf(List.class),
new TypeDescriptor(getClass().getField("genericList")));
assertEquals(new Integer(1), bar.get(0));
assertEquals(new Integer(2), bar.get(1));
assertEquals(new Integer(3), bar.get(2));
}
@Test
public void convertCollectionToString() {
List<String> list = Arrays.asList(new String[] { "foo", "bar" });
String result = conversionService.convert(list, String.class);
assertEquals("foo,bar", result);
}
@Test
public void convertCollectionToStringWithElementConversion() throws Exception {
conversionService.addConverter(new ObjectToStringConverter());
List<Integer> list = Arrays.asList(new Integer[] { 3, 5 });
String result = (String) conversionService.convert(list, new TypeDescriptor(getClass().getField("genericList")), TypeDescriptor.valueOf(String.class));
assertEquals("3,5", result);
}
@Test
public void convertCollectionToObject() {
List<Long> list = Collections.singletonList(3L);
Long result = conversionService.convert(list, Long.class);
assertEquals(new Long(3), result);
}
@Test
public void convertCollectionToObjectWithElementConversion() {
conversionService.addConverterFactory(new StringToNumberConverterFactory());
List<String> list = Collections.singletonList("3");
Integer result = conversionService.convert(list, Integer.class);
assertEquals(new Integer(3), result);
}
public Map<Integer, FooEnum> genericMap = new HashMap<Integer, FooEnum>();
@Test
@ -234,89 +298,103 @@ public class GenericConversionServiceTests {
Map<String, String> foo = new HashMap<String, String>();
foo.put("1", "BAR");
foo.put("2", "BAZ");
converter.addConverterFactory(new StringToNumberConverterFactory());
converter.addConverterFactory(new StringToEnumConverterFactory());
Map<String, FooEnum> map = (Map<String, FooEnum>) converter.convert(foo, TypeDescriptor.valueOf(Map.class),
new TypeDescriptor(getClass().getField("genericMap")));
conversionService.addConverterFactory(new StringToNumberConverterFactory());
conversionService.addConverterFactory(new StringToEnumConverterFactory());
Map<String, FooEnum> map = (Map<String, FooEnum>) conversionService.convert(foo, TypeDescriptor
.valueOf(Map.class), new TypeDescriptor(getClass().getField("genericMap")));
assertEquals(map.get(1), FooEnum.BAR);
assertEquals(map.get(2), FooEnum.BAZ);
}
@Test
public void convertObjectToCollection() {
List<String> result = (List<String>) converter.convert("test", List.class);
assertEquals(1, result.size());
assertEquals("test", result.get(0));
}
@Test
public void convertObjectToCollectionWithElementConversion() throws Exception {
converter.addConverterFactory(new StringToNumberConverterFactory());
List<Integer> result = (List<Integer>) converter.convert("3", TypeDescriptor.valueOf(String.class),
new TypeDescriptor(getClass().getField("genericList")));
assertEquals(1, result.size());
assertEquals(new Integer(3), result.get(0));
}
@Test
public void convertCollectionToObject() {
List<String> list = Collections.singletonList("test");
String result = converter.convert(list, String.class);
assertEquals("test", result);
}
@Test
public void convertCollectionToObjectWithElementConversion() {
converter.addConverterFactory(new StringToNumberConverterFactory());
List<String> list = Collections.singletonList("3");
Integer result = converter.convert(list, Integer.class);
assertEquals(new Integer(3), result);
}
@Test
public void convertObjectToArray() {
String[] result = converter.convert("test", String[].class);
assertEquals(1, result.length);
assertEquals("test", result[0]);
}
@Test
public void convertObjectToArrayWithElementConversion() {
converter.addConverterFactory(new StringToNumberConverterFactory());
Integer[] result = converter.convert("1", Integer[].class);
assertEquals(1, result.length);
assertEquals(new Integer(1), result[0]);
}
@Test
public void convertArrayToObject() {
String[] array = new String[] { "test" };
String result = converter.convert(array, String.class);
assertEquals("test", result);
}
@Test
public void convertArrayToObjectWithElementConversion() {
converter.addConverterFactory(new StringToNumberConverterFactory());
String[] array = new String[] { "3" };
Integer result = converter.convert(array, Integer.class);
assertEquals(new Integer(3), result);
public void convertStringToArray() {
conversionService.addConverterFactory(new StringToNumberConverterFactory());
String[] result = conversionService.convert("1,2,3", String[].class);
assertEquals(3, result.length);
assertEquals("1", result[0]);
assertEquals("2", result[1]);
assertEquals("3", result[2]);
}
@Test
public void convertStringToArrayWithElementConversion() {
converter.addConverterFactory(new StringToNumberConverterFactory());
Integer[] result = converter.convert("1,2,3", Integer[].class);
conversionService.addConverterFactory(new StringToNumberConverterFactory());
Integer[] result = conversionService.convert("1,2,3", Integer[].class);
assertEquals(3, result.length);
assertEquals(new Integer(1), result[0]);
assertEquals(new Integer(2), result[1]);
assertEquals(new Integer(3), result[2]);
}
@Test
public void convertEmptyStringToArray() {
conversionService.addConverterFactory(new StringToNumberConverterFactory());
String[] result = conversionService.convert("", String[].class);
assertEquals(0, result.length);
}
@Test
public void convertStringToCollection() {
conversionService.addConverterFactory(new StringToNumberConverterFactory());
List result = conversionService.convert("1,2,3", List.class);
assertEquals(3, result.size());
assertEquals("1", result.get(0));
assertEquals("2", result.get(1));
assertEquals("3", result.get(2));
}
@Test
public void convertStringToCollectionWithElementConversion() throws Exception {
conversionService.addConverterFactory(new StringToNumberConverterFactory());
List result = (List) conversionService.convert("1,2,3", TypeDescriptor.valueOf(String.class), new TypeDescriptor(getClass().getField("genericList")));
assertEquals(3, result.size());
assertEquals(new Integer(1), result.get(0));
assertEquals(new Integer(2), result.get(1));
assertEquals(new Integer(3), result.get(2));
}
@Test
public void convertEmptyStringToCollection() {
conversionService.addConverterFactory(new StringToNumberConverterFactory());
String[] result = conversionService.convert("", String[].class);
assertEquals(0, result.length);
}
@Test
public void convertObjectToCollection() {
List<String> result = (List<String>) conversionService.convert(3L, List.class);
assertEquals(1, result.size());
assertEquals(3L, result.get(0));
}
@Test
public void convertObjectToCollectionWithElementConversion() throws Exception {
conversionService.addConverterFactory(new NumberToNumberConverterFactory());
List<Integer> result = (List<Integer>) conversionService.convert(3L, TypeDescriptor.valueOf(Long.class),
new TypeDescriptor(getClass().getField("genericList")));
assertEquals(1, result.size());
assertEquals(new Integer(3), result.get(0));
}
@Test
public void convertObjectToArray() {
Object[] result = conversionService.convert(3L, Object[].class);
assertEquals(1, result.length);
assertEquals(3L, result[0]);
}
@Test
public void convertObjectToArrayWithElementConversion() {
conversionService.addConverterFactory(new NumberToNumberConverterFactory());
Integer[] result = conversionService.convert(3L, Integer[].class);
assertEquals(1, result.length);
assertEquals(new Integer(3), result[0]);
}
@Test
public void genericConverterDelegatingBackToConversionServiceConverterNotFound() {
try {
converter.convert("1", Integer[].class);
conversionService.convert("1", Integer[].class);
} catch (ConversionFailedException e) {
assertTrue(e.getCause() instanceof ConverterNotFoundException);
}
@ -325,10 +403,10 @@ public class GenericConversionServiceTests {
@Test
public void parent() {
GenericConversionService parent = new GenericConversionService();
converter.setParent(parent);
assertFalse(converter.canConvert(String.class, Integer.class));
conversionService.setParent(parent);
assertFalse(conversionService.canConvert(String.class, Integer.class));
try {
converter.convert("3", Integer.class);
conversionService.convert("3", Integer.class);
} catch (ConverterNotFoundException e) {
}