diff --git a/org.springframework.beans/src/test/java/org/springframework/beans/BeanWrapperEnumTests.java b/org.springframework.beans/src/test/java/org/springframework/beans/BeanWrapperEnumTests.java new file mode 100644 index 00000000000..edbb0198a83 --- /dev/null +++ b/org.springframework.beans/src/test/java/org/springframework/beans/BeanWrapperEnumTests.java @@ -0,0 +1,48 @@ +/* + * Copyright 2002-2007 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.beans; + +import junit.framework.Assert; +import junit.framework.TestCase; + +/** + * @author Juergen Hoeller + */ +public class BeanWrapperEnumTests extends TestCase { + + public void testCustomEnum() { + GenericBean gb = new GenericBean(); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("customEnum", "VALUE_1"); + Assert.assertEquals(CustomEnum.VALUE_1, gb.getCustomEnum()); + } + + public void testCustomEnumWithNull() { + GenericBean gb = new GenericBean(); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("customEnum", null); + Assert.assertEquals(null, gb.getCustomEnum()); + } + + public void testCustomEnumWithEmptyString() { + GenericBean gb = new GenericBean(); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("customEnum", ""); + Assert.assertEquals(null, gb.getCustomEnum()); + } + +} diff --git a/org.springframework.beans/src/test/java/org/springframework/beans/BeanWrapperGenericsTests.java b/org.springframework.beans/src/test/java/org/springframework/beans/BeanWrapperGenericsTests.java new file mode 100644 index 00000000000..62ebba78225 --- /dev/null +++ b/org.springframework.beans/src/test/java/org/springframework/beans/BeanWrapperGenericsTests.java @@ -0,0 +1,515 @@ +/* + * Copyright 2002-2008 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.beans; + +import java.net.MalformedURLException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import junit.framework.Assert; +import junit.framework.TestCase; + +import org.springframework.beans.propertyeditors.CustomNumberEditor; +import org.springframework.beans.propertyeditors.StringTrimmerEditor; +import org.springframework.core.io.Resource; +import org.springframework.core.io.UrlResource; + +/** + * @author Juergen Hoeller + * @since 18.01.2006 + */ +public class BeanWrapperGenericsTests extends TestCase { + + public void testGenericSet() { + GenericBean gb = new GenericBean(); + BeanWrapper bw = new BeanWrapperImpl(gb); + Set input = new HashSet(); + input.add("4"); + input.add("5"); + bw.setPropertyValue("integerSet", input); + assertTrue(gb.getIntegerSet().contains(new Integer(4))); + assertTrue(gb.getIntegerSet().contains(new Integer(5))); + } + + public void testGenericSetWithConversionFailure() { + GenericBean gb = new GenericBean(); + BeanWrapper bw = new BeanWrapperImpl(gb); + Set input = new HashSet(); + input.add(new TestBean()); + try { + bw.setPropertyValue("integerSet", input); + fail("Should have thrown TypeMismatchException"); + } + catch (TypeMismatchException ex) { + assertTrue(ex.getMessage().indexOf("java.lang.Integer") != -1); + } + } + + public void testGenericList() throws MalformedURLException { + GenericBean gb = new GenericBean(); + BeanWrapper bw = new BeanWrapperImpl(gb); + List input = new ArrayList(); + input.add("http://localhost:8080"); + input.add("http://localhost:9090"); + bw.setPropertyValue("resourceList", input); + assertEquals(new UrlResource("http://localhost:8080"), gb.getResourceList().get(0)); + assertEquals(new UrlResource("http://localhost:9090"), gb.getResourceList().get(1)); + } + + public void testGenericListElement() throws MalformedURLException { + GenericBean gb = new GenericBean(); + gb.setResourceList(new ArrayList()); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("resourceList[0]", "http://localhost:8080"); + assertEquals(new UrlResource("http://localhost:8080"), gb.getResourceList().get(0)); + } + + public void testGenericMap() { + GenericBean gb = new GenericBean(); + BeanWrapper bw = new BeanWrapperImpl(gb); + Map input = new HashMap(); + input.put("4", "5"); + input.put("6", "7"); + bw.setPropertyValue("shortMap", input); + assertEquals(new Integer(5), gb.getShortMap().get(new Short("4"))); + assertEquals(new Integer(7), gb.getShortMap().get(new Short("6"))); + } + + public void testGenericMapElement() { + GenericBean gb = new GenericBean(); + gb.setShortMap(new HashMap()); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("shortMap[4]", "5"); + assertEquals(new Integer(5), bw.getPropertyValue("shortMap[4]")); + assertEquals(new Integer(5), gb.getShortMap().get(new Short("4"))); + } + + public void testGenericMapWithKeyType() { + GenericBean gb = new GenericBean(); + BeanWrapper bw = new BeanWrapperImpl(gb); + Map input = new HashMap(); + input.put("4", "5"); + input.put("6", "7"); + bw.setPropertyValue("longMap", input); + assertEquals("5", gb.getLongMap().get(new Long("4"))); + assertEquals("7", gb.getLongMap().get(new Long("6"))); + } + + public void testGenericMapElementWithKeyType() { + GenericBean gb = new GenericBean(); + gb.setLongMap(new HashMap()); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("longMap[4]", "5"); + assertEquals("5", gb.getLongMap().get(new Long("4"))); + assertEquals("5", bw.getPropertyValue("longMap[4]")); + } + + public void testGenericMapWithCollectionValue() { + GenericBean gb = new GenericBean(); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.registerCustomEditor(Number.class, new CustomNumberEditor(Integer.class, false)); + Map input = new HashMap(); + HashSet value1 = new HashSet(); + value1.add(new Integer(1)); + input.put("1", value1); + ArrayList value2 = new ArrayList(); + value2.add(Boolean.TRUE); + input.put("2", value2); + bw.setPropertyValue("collectionMap", input); + assertTrue(gb.getCollectionMap().get(new Integer(1)) instanceof HashSet); + assertTrue(gb.getCollectionMap().get(new Integer(2)) instanceof ArrayList); + } + + public void testGenericMapElementWithCollectionValue() { + GenericBean gb = new GenericBean(); + gb.setCollectionMap(new HashMap>()); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.registerCustomEditor(Number.class, new CustomNumberEditor(Integer.class, false)); + HashSet value1 = new HashSet(); + value1.add(new Integer(1)); + bw.setPropertyValue("collectionMap[1]", value1); + assertTrue(gb.getCollectionMap().get(new Integer(1)) instanceof HashSet); + } + + public void testGenericListOfLists() throws MalformedURLException { + GenericBean gb = new GenericBean(); + List> list = new LinkedList>(); + list.add(new LinkedList()); + gb.setListOfLists(list); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("listOfLists[0][0]", new Integer(5)); + assertEquals(new Integer(5), bw.getPropertyValue("listOfLists[0][0]")); + assertEquals(new Integer(5), gb.getListOfLists().get(0).get(0)); + } + + public void testGenericListOfListsWithElementConversion() throws MalformedURLException { + GenericBean gb = new GenericBean(); + List> list = new LinkedList>(); + list.add(new LinkedList()); + gb.setListOfLists(list); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("listOfLists[0][0]", "5"); + assertEquals(new Integer(5), bw.getPropertyValue("listOfLists[0][0]")); + assertEquals(new Integer(5), gb.getListOfLists().get(0).get(0)); + } + + public void testGenericListOfArrays() throws MalformedURLException { + GenericBean gb = new GenericBean(); + ArrayList list = new ArrayList(); + list.add(new String[] {"str1", "str2"}); + gb.setListOfArrays(list); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("listOfArrays[0][1]", "str3 "); + assertEquals("str3 ", bw.getPropertyValue("listOfArrays[0][1]")); + assertEquals("str3 ", gb.getListOfArrays().get(0)[1]); + } + + public void testGenericListOfArraysWithElementConversion() throws MalformedURLException { + GenericBean gb = new GenericBean(); + ArrayList list = new ArrayList(); + list.add(new String[] {"str1", "str2"}); + gb.setListOfArrays(list); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.registerCustomEditor(String.class, new StringTrimmerEditor(false)); + bw.setPropertyValue("listOfArrays[0][1]", "str3 "); + assertEquals("str3", bw.getPropertyValue("listOfArrays[0][1]")); + assertEquals("str3", gb.getListOfArrays().get(0)[1]); + } + + public void testGenericListOfMaps() throws MalformedURLException { + GenericBean gb = new GenericBean(); + List> list = new LinkedList>(); + list.add(new HashMap()); + gb.setListOfMaps(list); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("listOfMaps[0][10]", new Long(5)); + assertEquals(new Long(5), bw.getPropertyValue("listOfMaps[0][10]")); + assertEquals(new Long(5), gb.getListOfMaps().get(0).get(10)); + } + + public void testGenericListOfMapsWithElementConversion() throws MalformedURLException { + GenericBean gb = new GenericBean(); + List> list = new LinkedList>(); + list.add(new HashMap()); + gb.setListOfMaps(list); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("listOfMaps[0][10]", "5"); + assertEquals(new Long(5), bw.getPropertyValue("listOfMaps[0][10]")); + assertEquals(new Long(5), gb.getListOfMaps().get(0).get(10)); + } + + public void testGenericMapOfMaps() throws MalformedURLException { + GenericBean gb = new GenericBean(); + Map> map = new HashMap>(); + map.put("mykey", new HashMap()); + gb.setMapOfMaps(map); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("mapOfMaps[mykey][10]", new Long(5)); + assertEquals(new Long(5), bw.getPropertyValue("mapOfMaps[mykey][10]")); + assertEquals(new Long(5), gb.getMapOfMaps().get("mykey").get(10)); + } + + public void testGenericMapOfMapsWithElementConversion() throws MalformedURLException { + GenericBean gb = new GenericBean(); + Map> map = new HashMap>(); + map.put("mykey", new HashMap()); + gb.setMapOfMaps(map); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("mapOfMaps[mykey][10]", "5"); + assertEquals(new Long(5), bw.getPropertyValue("mapOfMaps[mykey][10]")); + assertEquals(new Long(5), gb.getMapOfMaps().get("mykey").get(10)); + } + + public void testGenericMapOfLists() throws MalformedURLException { + GenericBean gb = new GenericBean(); + Map> map = new HashMap>(); + map.put(new Integer(1), new LinkedList()); + gb.setMapOfLists(map); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("mapOfLists[1][0]", new Integer(5)); + assertEquals(new Integer(5), bw.getPropertyValue("mapOfLists[1][0]")); + assertEquals(new Integer(5), gb.getMapOfLists().get(new Integer(1)).get(0)); + } + + public void testGenericMapOfListsWithElementConversion() throws MalformedURLException { + GenericBean gb = new GenericBean(); + Map> map = new HashMap>(); + map.put(new Integer(1), new LinkedList()); + gb.setMapOfLists(map); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("mapOfLists[1][0]", "5"); + assertEquals(new Integer(5), bw.getPropertyValue("mapOfLists[1][0]")); + assertEquals(new Integer(5), gb.getMapOfLists().get(new Integer(1)).get(0)); + } + + public void testGenericTypeNestingMapOfInteger() throws Exception { + Map map = new HashMap(); + map.put("testKey", "100"); + + NestedGenericCollectionBean gb = new NestedGenericCollectionBean(); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("mapOfInteger", map); + + Object obj = gb.getMapOfInteger().get("testKey"); + assertTrue(obj instanceof Integer); + } + + public void testGenericTypeNestingMapOfListOfInteger() throws Exception { + Map> map = new HashMap>(); + List list = Arrays.asList(new String[] {"1", "2", "3"}); + map.put("testKey", list); + + NestedGenericCollectionBean gb = new NestedGenericCollectionBean(); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("mapOfListOfInteger", map); + + Object obj = gb.getMapOfListOfInteger().get("testKey").get(0); + assertTrue(obj instanceof Integer); + assertEquals(1, ((Integer) obj).intValue()); + } + + public void testGenericTypeNestingListOfMapOfInteger() throws Exception { + List> list = new LinkedList>(); + Map map = new HashMap(); + map.put("testKey", "5"); + list.add(map); + + NestedGenericCollectionBean gb = new NestedGenericCollectionBean(); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("listOfMapOfInteger", list); + + Object obj = gb.getListOfMapOfInteger().get(0).get("testKey"); + assertTrue(obj instanceof Integer); + assertEquals(5, ((Integer) obj).intValue()); + } + + public void testGenericTypeNestingMapOfListOfListOfInteger() throws Exception { + Map>> map = new HashMap>>(); + List list = Arrays.asList(new String[] {"1", "2", "3"}); + map.put("testKey", Collections.singletonList(list)); + + NestedGenericCollectionBean gb = new NestedGenericCollectionBean(); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("mapOfListOfListOfInteger", map); + + Object obj = gb.getMapOfListOfListOfInteger().get("testKey").get(0).get(0); + assertTrue(obj instanceof Integer); + assertEquals(1, ((Integer) obj).intValue()); + } + + public void testComplexGenericMap() { + Map inputMap = new HashMap(); + List inputKey = new LinkedList(); + inputKey.add("1"); + List inputValue = new LinkedList(); + inputValue.add("10"); + inputMap.put(inputKey, inputValue); + + ComplexMapHolder holder = new ComplexMapHolder(); + BeanWrapper bw = new BeanWrapperImpl(holder); + bw.setPropertyValue("genericMap", inputMap); + + assertEquals(new Integer(1), holder.getGenericMap().keySet().iterator().next().get(0)); + assertEquals(new Long(10), holder.getGenericMap().values().iterator().next().get(0)); + } + + public void testComplexGenericMapWithCollectionConversion() { + Map inputMap = new HashMap(); + Set inputKey = new HashSet(); + inputKey.add("1"); + Set inputValue = new HashSet(); + inputValue.add("10"); + inputMap.put(inputKey, inputValue); + + ComplexMapHolder holder = new ComplexMapHolder(); + BeanWrapper bw = new BeanWrapperImpl(holder); + bw.setPropertyValue("genericMap", inputMap); + + assertEquals(new Integer(1), holder.getGenericMap().keySet().iterator().next().get(0)); + assertEquals(new Long(10), holder.getGenericMap().values().iterator().next().get(0)); + } + + public void testComplexGenericIndexedMapEntry() { + List inputValue = new LinkedList(); + inputValue.add("10"); + + ComplexMapHolder holder = new ComplexMapHolder(); + BeanWrapper bw = new BeanWrapperImpl(holder); + bw.setPropertyValue("genericIndexedMap[1]", inputValue); + + assertEquals(new Integer(1), holder.getGenericIndexedMap().keySet().iterator().next()); + assertEquals(new Long(10), holder.getGenericIndexedMap().values().iterator().next().get(0)); + } + + public void testComplexGenericIndexedMapEntryWithCollectionConversion() { + Set inputValue = new HashSet(); + inputValue.add("10"); + + ComplexMapHolder holder = new ComplexMapHolder(); + BeanWrapper bw = new BeanWrapperImpl(holder); + bw.setPropertyValue("genericIndexedMap[1]", inputValue); + + assertEquals(new Integer(1), holder.getGenericIndexedMap().keySet().iterator().next()); + assertEquals(new Long(10), holder.getGenericIndexedMap().values().iterator().next().get(0)); + } + + public void testComplexDerivedIndexedMapEntry() { + List inputValue = new LinkedList(); + inputValue.add("10"); + + ComplexMapHolder holder = new ComplexMapHolder(); + BeanWrapper bw = new BeanWrapperImpl(holder); + bw.setPropertyValue("derivedIndexedMap[1]", inputValue); + + assertEquals(new Integer(1), holder.getDerivedIndexedMap().keySet().iterator().next()); + assertEquals(new Long(10), holder.getDerivedIndexedMap().values().iterator().next().get(0)); + } + + public void testComplexDerivedIndexedMapEntryWithCollectionConversion() { + Set inputValue = new HashSet(); + inputValue.add("10"); + + ComplexMapHolder holder = new ComplexMapHolder(); + BeanWrapper bw = new BeanWrapperImpl(holder); + bw.setPropertyValue("derivedIndexedMap[1]", inputValue); + + assertEquals(new Integer(1), holder.getDerivedIndexedMap().keySet().iterator().next()); + assertEquals(new Long(10), holder.getDerivedIndexedMap().values().iterator().next().get(0)); + } + + public void testGenericallyTypedIntegerBean() throws Exception { + GenericIntegerBean gb = new GenericIntegerBean(); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("genericProperty", "10"); + bw.setPropertyValue("genericListProperty", new String[] {"20", "30"}); + Assert.assertEquals(new Integer(10), gb.getGenericProperty()); + Assert.assertEquals(new Integer(20), gb.getGenericListProperty().get(0)); + Assert.assertEquals(new Integer(30), gb.getGenericListProperty().get(1)); + } + + public void testGenericallyTypedSetOfIntegerBean() throws Exception { + GenericSetOfIntegerBean gb = new GenericSetOfIntegerBean(); + BeanWrapper bw = new BeanWrapperImpl(gb); + bw.setPropertyValue("genericProperty", "10"); + bw.setPropertyValue("genericListProperty", new String[] {"20", "30"}); + Assert.assertEquals(new Integer(10), gb.getGenericProperty().iterator().next()); + Assert.assertEquals(new Integer(20), gb.getGenericListProperty().get(0).iterator().next()); + Assert.assertEquals(new Integer(30), gb.getGenericListProperty().get(1).iterator().next()); + } + + + private static abstract class BaseGenericCollectionBean { + + public abstract Object getMapOfInteger(); + + public abstract Map getMapOfListOfInteger(); + + public abstract void setMapOfListOfInteger(Map> mapOfListOfInteger); + } + + + private static class NestedGenericCollectionBean extends BaseGenericCollectionBean { + + private Map mapOfInteger; + + private Map> mapOfListOfInteger; + + private List> listOfMapOfInteger; + + private Map>> mapOfListOfListOfInteger; + + public Map getMapOfInteger() { + return mapOfInteger; + } + + public void setMapOfInteger(Map mapOfInteger) { + this.mapOfInteger = mapOfInteger; + } + + public Map> getMapOfListOfInteger() { + return mapOfListOfInteger; + } + + public void setMapOfListOfInteger(Map> mapOfListOfInteger) { + this.mapOfListOfInteger = mapOfListOfInteger; + } + + public List> getListOfMapOfInteger() { + return listOfMapOfInteger; + } + + public void setListOfMapOfInteger(List> listOfMapOfInteger) { + this.listOfMapOfInteger = listOfMapOfInteger; + } + + public Map>> getMapOfListOfListOfInteger() { + return mapOfListOfListOfInteger; + } + + public void setMapOfListOfListOfInteger(Map>> mapOfListOfListOfInteger) { + this.mapOfListOfListOfInteger = mapOfListOfListOfInteger; + } + } + + + private static class ComplexMapHolder { + + private Map, List> genericMap; + + private Map> genericIndexedMap = new HashMap>(); + + private DerivedMap derivedIndexedMap = new DerivedMap(); + + public void setGenericMap(Map, List> genericMap) { + this.genericMap = genericMap; + } + + public Map, List> getGenericMap() { + return genericMap; + } + + public void setGenericIndexedMap(Map> genericIndexedMap) { + this.genericIndexedMap = genericIndexedMap; + } + + public Map> getGenericIndexedMap() { + return genericIndexedMap; + } + + public void setDerivedIndexedMap(DerivedMap derivedIndexedMap) { + this.derivedIndexedMap = derivedIndexedMap; + } + + public DerivedMap getDerivedIndexedMap() { + return derivedIndexedMap; + } + } + + + private static class DerivedMap extends HashMap> { + + } + +} diff --git a/org.springframework.beans/src/test/java/org/springframework/beans/CustomEnum.java b/org.springframework.beans/src/test/java/org/springframework/beans/CustomEnum.java new file mode 100644 index 00000000000..1e43492191b --- /dev/null +++ b/org.springframework.beans/src/test/java/org/springframework/beans/CustomEnum.java @@ -0,0 +1,30 @@ +/* + * Copyright 2002-2007 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.beans; + +/** + * @author Juergen Hoeller + */ +public enum CustomEnum { + + VALUE_1, VALUE_2; + + public String toString() { + return "CustomEnum: " + name(); + } + +} \ No newline at end of file diff --git a/org.springframework.beans/src/test/java/org/springframework/beans/GenericBean.java b/org.springframework.beans/src/test/java/org/springframework/beans/GenericBean.java new file mode 100644 index 00000000000..c4b85fa1f61 --- /dev/null +++ b/org.springframework.beans/src/test/java/org/springframework/beans/GenericBean.java @@ -0,0 +1,237 @@ +/* + * Copyright 2002-2008 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.beans; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.springframework.core.io.Resource; + +/** + * @author Juergen Hoeller + */ +public class GenericBean { + + private Set integerSet; + + private List resourceList; + + private List> listOfLists; + + private ArrayList listOfArrays; + + private List> listOfMaps; + + private Map plainMap; + + private Map shortMap; + + private HashMap longMap; + + private Map> collectionMap; + + private Map> mapOfMaps; + + private Map> mapOfLists; + + private CustomEnum customEnum; + + private T genericProperty; + + private List genericListProperty; + + + public GenericBean() { + } + + public GenericBean(Set integerSet) { + this.integerSet = integerSet; + } + + public GenericBean(Set integerSet, List resourceList) { + this.integerSet = integerSet; + this.resourceList = resourceList; + } + + public GenericBean(HashSet integerSet, Map shortMap) { + this.integerSet = integerSet; + this.shortMap = shortMap; + } + + public GenericBean(Map shortMap, Resource resource) { + this.shortMap = shortMap; + this.resourceList = Collections.singletonList(resource); + } + + public GenericBean(Map plainMap, Map shortMap) { + this.plainMap = plainMap; + this.shortMap = shortMap; + } + + public GenericBean(HashMap longMap) { + this.longMap = longMap; + } + + public GenericBean(boolean someFlag, Map> collectionMap) { + this.collectionMap = collectionMap; + } + + + public Set getIntegerSet() { + return integerSet; + } + + public void setIntegerSet(Set integerSet) { + this.integerSet = integerSet; + } + + public List getResourceList() { + return resourceList; + } + + public void setResourceList(List resourceList) { + this.resourceList = resourceList; + } + + public List> getListOfLists() { + return listOfLists; + } + + public ArrayList getListOfArrays() { + return listOfArrays; + } + + public void setListOfArrays(ArrayList listOfArrays) { + this.listOfArrays = listOfArrays; + } + + public void setListOfLists(List> listOfLists) { + this.listOfLists = listOfLists; + } + + public List> getListOfMaps() { + return listOfMaps; + } + + public void setListOfMaps(List> listOfMaps) { + this.listOfMaps = listOfMaps; + } + + public Map getPlainMap() { + return plainMap; + } + + public Map getShortMap() { + return shortMap; + } + + public void setShortMap(Map shortMap) { + this.shortMap = shortMap; + } + + public HashMap getLongMap() { + return longMap; + } + + public void setLongMap(HashMap longMap) { + this.longMap = longMap; + } + + public Map> getCollectionMap() { + return collectionMap; + } + + public void setCollectionMap(Map> collectionMap) { + this.collectionMap = collectionMap; + } + + public Map> getMapOfMaps() { + return mapOfMaps; + } + + public void setMapOfMaps(Map> mapOfMaps) { + this.mapOfMaps = mapOfMaps; + } + + public Map> getMapOfLists() { + return mapOfLists; + } + + public void setMapOfLists(Map> mapOfLists) { + this.mapOfLists = mapOfLists; + } + + public T getGenericProperty() { + return genericProperty; + } + + public void setGenericProperty(T genericProperty) { + this.genericProperty = genericProperty; + } + + public List getGenericListProperty() { + return genericListProperty; + } + + public void setGenericListProperty(List genericListProperty) { + this.genericListProperty = genericListProperty; + } + + public CustomEnum getCustomEnum() { + return customEnum; + } + + public void setCustomEnum(CustomEnum customEnum) { + this.customEnum = customEnum; + } + + + public static GenericBean createInstance(Set integerSet) { + return new GenericBean(integerSet); + } + + public static GenericBean createInstance(Set integerSet, List resourceList) { + return new GenericBean(integerSet, resourceList); + } + + public static GenericBean createInstance(HashSet integerSet, Map shortMap) { + return new GenericBean(integerSet, shortMap); + } + + public static GenericBean createInstance(Map shortMap, Resource resource) { + return new GenericBean(shortMap, resource); + } + + public static GenericBean createInstance(Map map, Map shortMap) { + return new GenericBean(map, shortMap); + } + + public static GenericBean createInstance(HashMap longMap) { + return new GenericBean(longMap); + } + + public static GenericBean createInstance(boolean someFlag, Map> collectionMap) { + return new GenericBean(someFlag, collectionMap); + } + +} \ No newline at end of file diff --git a/org.springframework.beans/src/test/java/org/springframework/beans/GenericIntegerBean.java b/org.springframework.beans/src/test/java/org/springframework/beans/GenericIntegerBean.java new file mode 100644 index 00000000000..5970af0fc55 --- /dev/null +++ b/org.springframework.beans/src/test/java/org/springframework/beans/GenericIntegerBean.java @@ -0,0 +1,24 @@ +/* + * Copyright 2002-2008 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.beans; + +/** + * @author Juergen Hoeller + */ +public class GenericIntegerBean extends GenericBean { + +} \ No newline at end of file diff --git a/org.springframework.beans/src/test/java/org/springframework/beans/GenericSetOfIntegerBean.java b/org.springframework.beans/src/test/java/org/springframework/beans/GenericSetOfIntegerBean.java new file mode 100644 index 00000000000..54e18c3a179 --- /dev/null +++ b/org.springframework.beans/src/test/java/org/springframework/beans/GenericSetOfIntegerBean.java @@ -0,0 +1,26 @@ +/* + * Copyright 2002-2008 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.beans; + +import java.util.Set; + +/** + * @author Juergen Hoeller + */ +public class GenericSetOfIntegerBean extends GenericBean> { + +} \ No newline at end of file diff --git a/org.springframework.testsuite/ivy.xml b/org.springframework.testsuite/ivy.xml index 0428624b0a8..4103c94d6dd 100644 --- a/org.springframework.testsuite/ivy.xml +++ b/org.springframework.testsuite/ivy.xml @@ -11,9 +11,6 @@ - - - @@ -22,10 +19,13 @@ + + + @@ -46,6 +46,8 @@ + + @@ -55,8 +57,10 @@ + + @@ -77,6 +81,7 @@ +