GitHub-Spring
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

CollectionCollection/MapToMapConverter preserve original Collection/Map if no converted elements (SPR-8714)

3.0.x
Juergen Hoeller 14 years ago
parent
7c108c1e77
commit
c9607fdaf2
7 changed files with 560 additions and 33 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      org.springframework.core/src/main/java/org/springframework/core/convert/TypeDescriptor.java
  2. 24
      org.springframework.core/src/main/java/org/springframework/core/convert/support/ArrayToCollectionConverter.java
  3. 27
      org.springframework.core/src/main/java/org/springframework/core/convert/support/CollectionToCollectionConverter.java
  4. 3
      org.springframework.core/src/main/java/org/springframework/core/convert/support/GenericConversionService.java
  5. 56
      org.springframework.core/src/main/java/org/springframework/core/convert/support/MapToMapConverter.java
  6. 295
      org.springframework.core/src/test/java/org/springframework/core/convert/support/CollectionToCollectionConverterTests.java
  7. 186
      org.springframework.core/src/test/java/org/springframework/core/convert/support/MapToMapConverterTests.java

2
org.springframework.core/src/main/java/org/springframework/core/convert/TypeDescriptor.java
Unescape View File

@ -281,7 +281,7 @@ public class TypeDescriptor {
*/ */
public TypeDescriptor getElementTypeDescriptor(Object element) { public TypeDescriptor getElementTypeDescriptor(Object element) {
TypeDescriptor elementType = getElementTypeDescriptor(); TypeDescriptor elementType = getElementTypeDescriptor();
return (elementType != TypeDescriptor.UNKNOWN ? elementType : forObject(element)); return (!TypeDescriptor.UNKNOWN.equals(elementType) ? elementType : forObject(element));
} }
/** /**

24
org.springframework.core/src/main/java/org/springframework/core/convert/support/ArrayToCollectionConverter.java
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2009 the original author or authors. * Copyright 2002-2011 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -49,7 +49,8 @@ final class ArrayToCollectionConverter implements ConditionalGenericConverter {
} }
public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) { public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
return ConversionUtils.canConvertElements(sourceType.getElementTypeDescriptor(), targetType.getElementTypeDescriptor(), this.conversionService); return ConversionUtils.canConvertElements(
sourceType.getElementTypeDescriptor(), targetType.getElementTypeDescriptor(), this.conversionService);
} }
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
@ -58,12 +59,21 @@ final class ArrayToCollectionConverter implements ConditionalGenericConverter {
return null; return null;
} }
int length = Array.getLength(source); int length = Array.getLength(source);
Collection target = CollectionFactory.createCollection(targetType.getType(), length); Collection<Object> target = CollectionFactory.createCollection(targetType.getType(), length);
for (int i = 0; i < length; i++) { if (targetType.getElementTypeDescriptor() == null) {
Object sourceElement = Array.get(source, i); for (int i = 0; i < length; i++) {
Object targetElement = this.conversionService.convert(sourceElement, sourceType.getElementTypeDescriptor(), targetType.getElementTypeDescriptor(sourceElement)); Object sourceElement = Array.get(source, i);
target.add(targetElement); target.add(sourceElement);
}
} }
else {
for (int i = 0; i < length; i++) {
Object sourceElement = Array.get(source, i);
Object targetElement = this.conversionService.convert(sourceElement,
sourceType.getElementTypeDescriptor(sourceElement), targetType.getElementTypeDescriptor());
target.add(targetElement);
}
}
return target; return target;
} }

27
org.springframework.core/src/main/java/org/springframework/core/convert/support/CollectionToCollectionConverter.java
Unescape View File

@ -49,7 +49,8 @@ final class CollectionToCollectionConverter implements ConditionalGenericConvert
} }
public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) { public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
return ConversionUtils.canConvertElements(sourceType.getElementTypeDescriptor(), targetType.getElementTypeDescriptor(), conversionService); return ConversionUtils.canConvertElements(
sourceType.getElementTypeDescriptor(), targetType.getElementTypeDescriptor(), this.conversionService);
} }
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
@ -57,15 +58,25 @@ final class CollectionToCollectionConverter implements ConditionalGenericConvert
if (source == null) { if (source == null) {
return null; return null;
} }
boolean copyRequired = !targetType.getType().isInstance(source);
Collection<?> sourceCollection = (Collection<?>) source; Collection<?> sourceCollection = (Collection<?>) source;
Collection target = CollectionFactory.createCollection(targetType.getType(), sourceCollection.size()); Collection<Object> target = CollectionFactory.createCollection(targetType.getType(), sourceCollection.size());
for (Object sourceElement : sourceCollection) { if (targetType.getElementTypeDescriptor() == null) {
Object targetElement = this.conversionService.convert(sourceElement, for (Object element : sourceCollection) {
sourceType.getElementTypeDescriptor(sourceElement), target.add(element);
targetType.getElementTypeDescriptor(sourceElement)); }
target.add(targetElement);
} }
return target; else {
for (Object sourceElement : sourceCollection) {
Object targetElement = this.conversionService.convert(sourceElement,
sourceType.getElementTypeDescriptor(sourceElement), targetType.getElementTypeDescriptor());
target.add(targetElement);
if (sourceElement != targetElement) {
copyRequired = true;
}
}
}
return (copyRequired ? target : source);
} }
} }

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

@ -148,7 +148,8 @@ public class GenericConversionService implements ConversionService, ConverterReg
Assert.isTrue(source == null || sourceType.getObjectType().isInstance(source)); Assert.isTrue(source == null || sourceType.getObjectType().isInstance(source));
GenericConverter converter = getConverter(sourceType, targetType); GenericConverter converter = getConverter(sourceType, targetType);
if (converter == null) { if (converter == null) {
if (source == null || targetType.getObjectType().isInstance(source)) { if (source == null ||
(sourceType.isAssignableTo(targetType) && targetType.getObjectType().isInstance(source))) {
return source; return source;
} }
else { else {

56
org.springframework.core/src/main/java/org/springframework/core/convert/support/MapToMapConverter.java
Unescape View File

@ -49,8 +49,7 @@ final class MapToMapConverter implements ConditionalGenericConverter {
} }
public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) { public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
return this.conversionService.canConvert(sourceType.getMapKeyTypeDescriptor(), targetType.getMapKeyTypeDescriptor()) && return canConvertKey(sourceType, targetType) && canConvertValue(sourceType, targetType);
this.conversionService.canConvert(sourceType.getMapValueTypeDescriptor(), targetType.getMapValueTypeDescriptor());
} }
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
@ -58,21 +57,46 @@ final class MapToMapConverter implements ConditionalGenericConverter {
if (source == null) { if (source == null) {
return null; return null;
} }
Map<?, ?> sourceMap = (Map<?, ?>) source; boolean copyRequired = !targetType.getType().isInstance(source);
Map targetMap = CollectionFactory.createMap(targetType.getType(), sourceMap.size()); Map<Object, Object> sourceMap = (Map<Object, Object>) source;
for (Object entry : sourceMap.entrySet()) { Map<Object, Object> targetMap = CollectionFactory.createMap(targetType.getType(), sourceMap.size());
Map.Entry sourceMapEntry = (Map.Entry) entry; for (Map.Entry<Object, Object> entry : sourceMap.entrySet()) {
Object sourceKey = sourceMapEntry.getKey(); Object sourceKey = entry.getKey();
Object sourceValue = sourceMapEntry.getValue(); Object sourceValue = entry.getValue();
Object targetKey = this.conversionService.convert(sourceKey, Object targetKey = convertKey(sourceKey, sourceType, targetType.getMapKeyTypeDescriptor());
sourceType.getMapKeyTypeDescriptor(sourceKey), Object targetValue = convertValue(sourceValue, sourceType, targetType.getMapValueTypeDescriptor());
targetType.getMapKeyTypeDescriptor(sourceKey));
Object targetValue = this.conversionService.convert(sourceValue,
sourceType.getMapValueTypeDescriptor(sourceValue),
targetType.getMapValueTypeDescriptor(sourceValue));
targetMap.put(targetKey, targetValue); targetMap.put(targetKey, targetValue);
if (sourceKey != targetKey || sourceValue != targetValue) {
copyRequired = true;
}
} }
return targetMap; return (copyRequired ? targetMap : sourceMap);
} }
// internal helpers
private boolean canConvertKey(TypeDescriptor sourceType, TypeDescriptor targetType) {
return ConversionUtils.canConvertElements(sourceType.getMapKeyTypeDescriptor(),
targetType.getMapKeyTypeDescriptor(), this.conversionService);
}
private boolean canConvertValue(TypeDescriptor sourceType, TypeDescriptor targetType) {
return ConversionUtils.canConvertElements(sourceType.getMapValueTypeDescriptor(),
targetType.getMapValueTypeDescriptor(), this.conversionService);
}
private Object convertKey(Object sourceKey, TypeDescriptor sourceType, TypeDescriptor targetType) {
if (targetType == null) {
return sourceKey;
}
return this.conversionService.convert(sourceKey, sourceType.getMapKeyTypeDescriptor(sourceKey), targetType);
}
private Object convertValue(Object sourceValue, TypeDescriptor sourceType, TypeDescriptor targetType) {
if (targetType == null) {
return sourceValue;
}
return this.conversionService.convert(sourceValue, sourceType.getMapValueTypeDescriptor(sourceValue), targetType);
}
} }

295
org.springframework.core/src/test/java/org/springframework/core/convert/support/CollectionToCollectionConverterTests.java
Unescape View File

@ -0,0 +1,295 @@
/*
* Copyright 2002-2011 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.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;
import org.junit.Before;
import org.junit.Test;
import org.springframework.core.convert.ConversionFailedException;
import org.springframework.core.convert.ConverterNotFoundException;
import org.springframework.core.convert.TypeDescriptor;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;
import static org.junit.Assert.*;
/**
* @author Keith Donald
*/
public class CollectionToCollectionConverterTests {
private GenericConversionService conversionService = new GenericConversionService();
@Before
public void setUp() {
conversionService.addConverter(new CollectionToCollectionConverter(conversionService));
}
@Test
public void scalarList() throws Exception {
List<String> list = new ArrayList<String>();
list.add("9");
list.add("37");
TypeDescriptor sourceType = TypeDescriptor.forObject(list);
TypeDescriptor targetType = new TypeDescriptor(getClass().getField("scalarListTarget"));
assertFalse(conversionService.canConvert(sourceType, targetType));
conversionService.addConverterFactory(new StringToNumberConverterFactory());
assertTrue(conversionService.canConvert(sourceType, targetType));
@SuppressWarnings("unchecked")
List<String> result = (List<String>) conversionService.convert(list, sourceType, targetType);
assertFalse(list.equals(result));
assertEquals((Integer) 9, result.get(0));
assertEquals((Integer) 37, result.get(1));
}
public ArrayList<Integer> scalarListTarget;
@Test
public void emptyListToList() throws Exception {
conversionService.addConverter(new CollectionToCollectionConverter(conversionService));
conversionService.addConverterFactory(new StringToNumberConverterFactory());
List<String> list = new ArrayList<String>();
TypeDescriptor sourceType = TypeDescriptor.forObject(list);
TypeDescriptor targetType = new TypeDescriptor(getClass().getField("emptyListTarget"));
assertTrue(conversionService.canConvert(sourceType, targetType));
assertEquals(list, conversionService.convert(list, sourceType, targetType));
}
public List<Integer> emptyListTarget;
@Test
public void emptyListToListDifferentTargetType() throws Exception {
conversionService.addConverter(new CollectionToCollectionConverter(conversionService));
conversionService.addConverterFactory(new StringToNumberConverterFactory());
List<String> list = new ArrayList<String>();
TypeDescriptor sourceType = TypeDescriptor.forObject(list);
TypeDescriptor targetType = new TypeDescriptor(getClass().getField("emptyListDifferentTarget"));
assertTrue(conversionService.canConvert(sourceType, targetType));
@SuppressWarnings("unchecked")
LinkedList<Integer> result = (LinkedList<Integer>) conversionService.convert(list, sourceType, targetType);
assertEquals(LinkedList.class, result.getClass());
assertTrue(result.isEmpty());
}
public LinkedList<Integer> emptyListDifferentTarget;
@Test
public void collectionToObjectInteraction() throws Exception {
List<List<String>> list = new ArrayList<List<String>>();
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
@SuppressWarnings("unchecked")
public void arrayCollectionToObjectInteraction() throws Exception {
List<String>[] array = new List[2];
array[0] = Arrays.asList("9", "12");
array[1] = Arrays.asList("37", "23");
conversionService.addConverter(new ArrayToCollectionConverter(conversionService));
conversionService.addConverter(new CollectionToObjectConverter(conversionService));
assertTrue(conversionService.canConvert(String[].class, List.class));
assertEquals(Arrays.asList(array), conversionService.convert(array, List.class));
}
@Test
@SuppressWarnings("unchecked")
public void objectToCollection() throws Exception {
List<List<String>> list = new ArrayList<List<String>>();
list.add(Arrays.asList("9", "12"));
list.add(Arrays.asList("37", "23"));
conversionService.addConverterFactory(new StringToNumberConverterFactory());
conversionService.addConverter(new ObjectToCollectionConverter(conversionService));
conversionService.addConverter(new CollectionToObjectConverter(conversionService));
TypeDescriptor sourceType = TypeDescriptor.forObject(list);
TypeDescriptor targetType = new TypeDescriptor(getClass().getField("objectToCollection"));
assertTrue(conversionService.canConvert(sourceType, targetType));
List<List<List<Integer>>> result = (List<List<List<Integer>>>) conversionService.convert(list, sourceType, targetType);
assertEquals((Integer)9, result.get(0).get(0).get(0));
assertEquals((Integer)12, result.get(0).get(1).get(0));
assertEquals((Integer)37, result.get(1).get(0).get(0));
assertEquals((Integer)23, result.get(1).get(1).get(0));
}
public List<List<List<Integer>>> objectToCollection;
@Test
@SuppressWarnings("unchecked")
public void stringToCollection() throws Exception {
List<List<String>> list = new ArrayList<List<String>>();
list.add(Arrays.asList("9,12"));
list.add(Arrays.asList("37,23"));
conversionService.addConverterFactory(new StringToNumberConverterFactory());
conversionService.addConverter(new StringToCollectionConverter(conversionService));
conversionService.addConverter(new ObjectToCollectionConverter(conversionService));
conversionService.addConverter(new CollectionToObjectConverter(conversionService));
TypeDescriptor sourceType = TypeDescriptor.forObject(list);
TypeDescriptor targetType = new TypeDescriptor(getClass().getField("objectToCollection"));
assertTrue(conversionService.canConvert(sourceType, targetType));
List<List<List<Integer>>> result = (List<List<List<Integer>>>) conversionService.convert(list, sourceType, targetType);
assertEquals((Integer)9, result.get(0).get(0).get(0));
assertEquals((Integer)12, result.get(0).get(0).get(1));
assertEquals((Integer)37, result.get(1).get(0).get(0));
assertEquals((Integer)23, result.get(1).get(0).get(1));
}
@Test
public void differentImpls() throws Exception {
List<Resource> resources = new ArrayList<Resource>();
resources.add(new ClassPathResource("test"));
resources.add(new FileSystemResource("test"));
resources.add(new TestResource());
TypeDescriptor sourceType = TypeDescriptor.forObject(resources);
assertSame(resources, conversionService.convert(resources, sourceType, new TypeDescriptor(getClass().getField("resources"))));
}
@Test
public void mixedInNulls() throws Exception {
List<Resource> resources = new ArrayList<Resource>();
resources.add(new ClassPathResource("test"));
resources.add(null);
resources.add(new FileSystemResource("test"));
resources.add(new TestResource());
TypeDescriptor sourceType = TypeDescriptor.forObject(resources);
assertSame(resources, conversionService.convert(resources, sourceType, new TypeDescriptor(getClass().getField("resources"))));
}
@Test
public void allNulls() throws Exception {
List<Resource> resources = new ArrayList<Resource>();
resources.add(null);
resources.add(null);
TypeDescriptor sourceType = TypeDescriptor.forObject(resources);
assertSame(resources, conversionService.convert(resources, sourceType, new TypeDescriptor(getClass().getField("resources"))));
}
@Test(expected=ConverterNotFoundException.class)
public void elementTypesNotConvertible() throws Exception {
List<String> resources = new ArrayList<String>();
resources.add(null);
resources.add(null);
TypeDescriptor sourceType = new TypeDescriptor(getClass().getField("strings"));
assertEquals(resources, conversionService.convert(resources, sourceType, new TypeDescriptor(getClass().getField("resources"))));
}
public List<String> strings;
@Test(expected=ConversionFailedException.class)
public void nothingInCommon() throws Exception {
List<Object> resources = new ArrayList<Object>();
resources.add(new ClassPathResource("test"));
resources.add(3);
TypeDescriptor sourceType = TypeDescriptor.forObject(resources);
assertEquals(resources, conversionService.convert(resources, sourceType, new TypeDescriptor(getClass().getField("resources"))));
}
public List<Resource> resources;
public static abstract class BaseResource implements Resource {
public InputStream getInputStream() throws IOException {
return null;
}
public boolean exists() {
return false;
}
public boolean isReadable() {
return false;
}
public boolean isOpen() {
return false;
}
public URL getURL() throws IOException {
return null;
}
public URI getURI() throws IOException {
return null;
}
public File getFile() throws IOException {
return null;
}
public long contentLength() throws IOException {
return 0;
}
public long lastModified() throws IOException {
return 0;
}
public Resource createRelative(String relativePath) throws IOException {
return null;
}
public String getFilename() {
return null;
}
public String getDescription() {
return null;
}
}
public static class TestResource extends BaseResource {
}
@Test
public void convertEmptyVector_shouldReturnEmptyArrayList() {
Vector<String> vector = new Vector<String>();
vector.add("Element");
testCollectionConversionToArrayList(vector);
}
@Test
public void convertNonEmptyVector_shouldReturnNonEmptyArrayList() {
Vector<String> vector = new Vector<String>();
vector.add("Element");
testCollectionConversionToArrayList(vector);
}
@SuppressWarnings("rawtypes")
private void testCollectionConversionToArrayList(Collection<String> aSource) {
Object myConverted = (new CollectionToCollectionConverter(new GenericConversionService())).convert(
aSource, TypeDescriptor.forObject(aSource), TypeDescriptor.forObject(new ArrayList()));
assertTrue(myConverted instanceof ArrayList<?>);
assertEquals(aSource.size(), ((ArrayList<?>) myConverted).size());
}
}

186
org.springframework.core/src/test/java/org/springframework/core/convert/support/MapToMapConverterTests.java
Unescape View File

@ -0,0 +1,186 @@
/*
* Copyright 2002-2011 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.Arrays;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.junit.Before;
import org.junit.Test;
import org.springframework.core.convert.ConversionFailedException;
import org.springframework.core.convert.ConverterNotFoundException;
import org.springframework.core.convert.TypeDescriptor;
import static org.junit.Assert.*;
public class MapToMapConverterTests {
private GenericConversionService conversionService = new GenericConversionService();
@Before
public void setUp() {
conversionService.addConverter(new MapToMapConverter(conversionService));
}
@Test
public void scalarMap() throws Exception {
Map<String, String> map = new HashMap<String, String>();
map.put("1", "9");
map.put("2", "37");
TypeDescriptor sourceType = TypeDescriptor.forObject(map);
TypeDescriptor targetType = new TypeDescriptor(getClass().getField("scalarMapTarget"));
assertFalse(conversionService.canConvert(sourceType, targetType));
conversionService.addConverterFactory(new StringToNumberConverterFactory());
assertTrue(conversionService.canConvert(sourceType, targetType));
@SuppressWarnings("unchecked")
Map<Integer, Integer> result = (Map<Integer, Integer>) conversionService.convert(map, sourceType, targetType);
assertFalse(map.equals(result));
assertEquals((Integer) 9, result.get(1));
assertEquals((Integer) 37, result.get(2));
}
public Map<Integer, Integer> scalarMapTarget;
@Test
public void scalarMapNotGenericTarget() throws Exception {
Map<String, String> map = new HashMap<String, String>();
map.put("1", "9");
map.put("2", "37");
assertTrue(conversionService.canConvert(Map.class, Map.class));
assertSame(map, conversionService.convert(map, Map.class));
}
@Test
public void scalarMapNotGenericSourceField() throws Exception {
Map<String, String> map = new HashMap<String, String>();
map.put("1", "9");
map.put("2", "37");
TypeDescriptor sourceType = new TypeDescriptor(getClass().getField("notGenericMapSource"));
TypeDescriptor targetType = new TypeDescriptor(getClass().getField("scalarMapTarget"));
assertTrue(conversionService.canConvert(sourceType, targetType));
try {
conversionService.convert(map, sourceType, targetType);
} catch (ConversionFailedException e) {
assertTrue(e.getCause() instanceof ConverterNotFoundException);
}
conversionService.addConverterFactory(new StringToNumberConverterFactory());
assertTrue(conversionService.canConvert(sourceType, targetType));
@SuppressWarnings("unchecked")
Map<Integer, Integer> result = (Map<Integer, Integer>) conversionService.convert(map, sourceType, targetType);
assertFalse(map.equals(result));
assertEquals((Integer) 9, result.get(1));
assertEquals((Integer) 37, result.get(2));
}
public Map notGenericMapSource;
@Test
public void collectionMap() throws Exception {
Map<String, List<String>> map = new HashMap<String, List<String>>();
map.put("1", Arrays.asList("9", "12"));
map.put("2", Arrays.asList("37", "23"));
TypeDescriptor sourceType = TypeDescriptor.forObject(map);
TypeDescriptor targetType = new TypeDescriptor(getClass().getField("collectionMapTarget"));
assertFalse(conversionService.canConvert(sourceType, targetType));
conversionService.addConverter(new CollectionToCollectionConverter(conversionService));
conversionService.addConverterFactory(new StringToNumberConverterFactory());
assertTrue(conversionService.canConvert(sourceType, targetType));
@SuppressWarnings("unchecked")
Map<Integer, List<Integer>> result = (Map<Integer, List<Integer>>) conversionService.convert(map, sourceType, targetType);
assertFalse(map.equals(result));
assertEquals(Arrays.asList(9, 12), result.get(1));
assertEquals(Arrays.asList(37, 23), result.get(2));
}
public Map<Integer, List<Integer>> collectionMapTarget;
@Test
public void collectionMapSourceTarget() throws Exception {
Map<String, List<String>> map = new HashMap<String, List<String>>();
map.put("1", Arrays.asList("9", "12"));
map.put("2", Arrays.asList("37", "23"));
TypeDescriptor sourceType = new TypeDescriptor(getClass().getField("sourceCollectionMapTarget"));
TypeDescriptor targetType = new TypeDescriptor(getClass().getField("collectionMapTarget"));
conversionService.addConverter(new CollectionToCollectionConverter(conversionService));
conversionService.addConverterFactory(new StringToNumberConverterFactory());
assertTrue(conversionService.canConvert(sourceType, targetType));
@SuppressWarnings("unchecked")
Map<Integer, List<Integer>> result = (Map<Integer, List<Integer>>) conversionService.convert(map, sourceType, targetType);
assertFalse(map.equals(result));
assertEquals(Arrays.asList(9, 12), result.get(1));
assertEquals(Arrays.asList(37, 23), result.get(2));
}
public Map<String, List<String>> sourceCollectionMapTarget;
@Test
public void collectionMapNotGenericTarget() throws Exception {
Map<String, List<String>> map = new HashMap<String, List<String>>();
map.put("1", Arrays.asList("9", "12"));
map.put("2", Arrays.asList("37", "23"));
assertTrue(conversionService.canConvert(Map.class, Map.class));
assertSame(map, conversionService.convert(map, Map.class));
}
@Test
public void collectionMapNotGenericTargetCollectionToObjectInteraction() throws Exception {
Map<String, List<String>> map = new HashMap<String, List<String>>();
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 emptyMap() throws Exception {
Map<String, String> map = new HashMap<String, String>();
TypeDescriptor sourceType = TypeDescriptor.forObject(map);
TypeDescriptor targetType = new TypeDescriptor(getClass().getField("emptyMapTarget"));
assertTrue(conversionService.canConvert(sourceType, targetType));
assertSame(map, conversionService.convert(map, sourceType, targetType));
}
public Map<String, String> emptyMapTarget;
@Test
public void emptyMapNoTargetGenericInfo() throws Exception {
Map<String, String> map = new HashMap<String, String>();
assertTrue(conversionService.canConvert(Map.class, Map.class));
assertSame(map, conversionService.convert(map, Map.class));
}
@Test
public void emptyMapDifferentTargetImplType() throws Exception {
Map<String, String> map = new HashMap<String, String>();
TypeDescriptor sourceType = TypeDescriptor.forObject(map);
TypeDescriptor targetType = new TypeDescriptor(getClass().getField("emptyMapDifferentTarget"));
assertTrue(conversionService.canConvert(sourceType, targetType));
@SuppressWarnings("unchecked")
LinkedHashMap<String, String> result = (LinkedHashMap<String, String>) conversionService.convert(map, sourceType, targetType);
assertEquals(map, result);
assertEquals(LinkedHashMap.class, result.getClass());
}
public LinkedHashMap<String, String> emptyMapDifferentTarget;
}
Write Preview
Loading…
Cancel
Save