moving unit tests from .testsuite -> .beans

org.springframework.beans/src/test/java/org/springframework/beans/factory/HasMap.java

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2002-2005 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.factory;
+
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+
+/**
+ * Bean exposing a map. Used for bean factory tests.
+ *
+ * @author Rod Johnson
+ * @since 05.06.2003
+ */
+public class HasMap {
+	
+	private Map map;
+
+	private Set set;
+
+	private Properties props;
+	
+	private Object[] objectArray;
+	
+	private Class[] classArray;
+	
+	private Integer[] intArray;
+
+	private HasMap() {
+	}
+
+	public Map getMap() {
+		return map;
+	}
+
+	public void setMap(Map map) {
+		this.map = map;
+	}
+
+	public Set getSet() {
+		return set;
+	}
+
+	public void setSet(Set set) {
+		this.set = set;
+	}
+
+	public Properties getProps() {
+		return props;
+	}
+
+	public void setProps(Properties props) {
+		this.props = props;
+	}
+
+	public Object[] getObjectArray() {
+		return objectArray;
+	}
+
+	public void setObjectArray(Object[] objectArray) {
+		this.objectArray = objectArray;
+	}
+
+	public Class[] getClassArray() {
+		return classArray;
+	}
+
+	public void setClassArray(Class[] classArray) {
+		this.classArray = classArray;
+	}
+
+	public Integer[] getIntegerArray() {
+		return intArray;
+	}
+
+	public void setIntegerArray(Integer[] is) {
+		intArray = is;
+	}
+
+}

org.springframework.beans/src/test/java/org/springframework/beans/factory/xml/MixedCollectionBean.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2002-2006 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.factory.xml;
+
+import java.util.Collection;
+
+/**
+ * Bean that exposes a simple property that can be set
+ * to a mix of references and individual values.
+ *
+ * @author Rod Johnson
+ * @since 27.05.2003
+ */
+public class MixedCollectionBean {
+
+	private Collection jumble;
+
+
+	public void setJumble(Collection jumble) {
+		this.jumble = jumble;
+	}
+
+	public Collection getJumble() {
+		return jumble;
+	}
+
+}

org.springframework.beans/src/test/java/org/springframework/beans/factory/xml/XmlBeanCollectionTests.java

@@ -0,0 +1,444 @@
+/*
+ * 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.factory.xml;
+
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+import org.junit.Test;
+import org.springframework.beans.TestBean;
+import org.springframework.beans.factory.BeanCreationException;
+import org.springframework.beans.factory.BeanDefinitionStoreException;
+import org.springframework.beans.factory.HasMap;
+import org.springframework.beans.factory.config.ListFactoryBean;
+import org.springframework.beans.factory.config.MapFactoryBean;
+import org.springframework.beans.factory.config.SetFactoryBean;
+import org.springframework.core.io.ClassPathResource;
+
+/**
+ * Tests for collections in XML bean definitions.
+ *
+ * @author Juergen Hoeller
+ * @author Chris Beams
+ * @since 19.12.2004
+ */
+public class XmlBeanCollectionTests {
+
+	@Test
+	public void testCollectionFactoryDefaults() throws Exception {
+		ListFactoryBean listFactory = new ListFactoryBean();
+		listFactory.setSourceList(new LinkedList());
+		listFactory.afterPropertiesSet();
+		assertTrue(listFactory.getObject() instanceof ArrayList);
+
+		SetFactoryBean setFactory = new SetFactoryBean();
+		setFactory.setSourceSet(new TreeSet());
+		setFactory.afterPropertiesSet();
+		assertTrue(setFactory.getObject() instanceof LinkedHashSet);
+
+		MapFactoryBean mapFactory = new MapFactoryBean();
+		mapFactory.setSourceMap(new TreeMap());
+		mapFactory.afterPropertiesSet();
+		assertTrue(mapFactory.getObject() instanceof LinkedHashMap);
+	}
+
+	@Test
+	public void testRefSubelement() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		//assertTrue("5 beans in reftypes, not " + xbf.getBeanDefinitionCount(), xbf.getBeanDefinitionCount() == 5);
+		TestBean jen = (TestBean) xbf.getBean("jenny");
+		TestBean dave = (TestBean) xbf.getBean("david");
+		assertTrue(jen.getSpouse() == dave);
+	}
+
+	@Test
+	public void testPropertyWithLiteralValueSubelement() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		TestBean verbose = (TestBean) xbf.getBean("verbose");
+		assertTrue(verbose.getName().equals("verbose"));
+	}
+
+	@Test
+	public void testPropertyWithIdRefLocalAttrSubelement() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		TestBean verbose = (TestBean) xbf.getBean("verbose2");
+		assertTrue(verbose.getName().equals("verbose"));
+	}
+
+	@Test
+	public void testPropertyWithIdRefBeanAttrSubelement() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		TestBean verbose = (TestBean) xbf.getBean("verbose3");
+		assertTrue(verbose.getName().equals("verbose"));
+	}
+
+	@Test
+	public void testRefSubelementsBuildCollection() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		TestBean jen = (TestBean) xbf.getBean("jenny");
+		TestBean dave = (TestBean) xbf.getBean("david");
+		TestBean rod = (TestBean) xbf.getBean("rod");
+
+		// Must be a list to support ordering
+		// Our bean doesn't modify the collection:
+		// of course it could be a different copy in a real object.
+		Object[] friends = rod.getFriends().toArray();
+		assertTrue(friends.length == 2);
+
+		assertTrue("First friend must be jen, not " + friends[0], friends[0] == jen);
+		assertTrue(friends[1] == dave);
+		// Should be ordered
+	}
+
+	@Test
+	public void testRefSubelementsBuildCollectionWithPrototypes() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+
+		TestBean jen = (TestBean) xbf.getBean("pJenny");
+		TestBean dave = (TestBean) xbf.getBean("pDavid");
+		TestBean rod = (TestBean) xbf.getBean("pRod");
+		Object[] friends = rod.getFriends().toArray();
+		assertTrue(friends.length == 2);
+		assertTrue("First friend must be jen, not " + friends[0],
+				friends[0].toString().equals(jen.toString()));
+		assertTrue("Jen not same instance", friends[0] != jen);
+		assertTrue(friends[1].toString().equals(dave.toString()));
+		assertTrue("Dave not same instance", friends[1] != dave);
+
+		TestBean rod2 = (TestBean) xbf.getBean("pRod");
+		Object[] friends2 = rod2.getFriends().toArray();
+		assertTrue(friends2.length == 2);
+		assertTrue("First friend must be jen, not " + friends2[0],
+				friends2[0].toString().equals(jen.toString()));
+		assertTrue("Jen not same instance", friends2[0] != friends[0]);
+		assertTrue(friends2[1].toString().equals(dave.toString()));
+		assertTrue("Dave not same instance", friends2[1] != friends[1]);
+	}
+
+	@Test
+	public void testRefSubelementsBuildCollectionFromSingleElement() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		TestBean loner = (TestBean) xbf.getBean("loner");
+		TestBean dave = (TestBean) xbf.getBean("david");
+		assertTrue(loner.getFriends().size() == 1);
+		assertTrue(loner.getFriends().contains(dave));
+	}
+
+	@Test
+	public void testBuildCollectionFromMixtureOfReferencesAndValues() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		MixedCollectionBean jumble = (MixedCollectionBean) xbf.getBean("jumble");
+		assertTrue("Expected 4 elements, not " + jumble.getJumble().size(),
+				jumble.getJumble().size() == 4);
+		List l = (List) jumble.getJumble();
+		assertTrue(l.get(0).equals(xbf.getBean("david")));
+		assertTrue(l.get(1).equals("literal"));
+		assertTrue(l.get(2).equals(xbf.getBean("jenny")));
+		assertTrue(l.get(3).equals("rod"));
+	}
+
+	@Test
+	public void testInvalidBeanNameReference() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		try {
+			xbf.getBean("jumble2");
+			fail("Should have thrown BeanCreationException");
+		}
+		catch (BeanCreationException ex) {
+			assertTrue(ex.getCause() instanceof BeanDefinitionStoreException);
+			assertTrue(ex.getCause().getMessage().indexOf("rod2") != -1);
+		}
+	}
+
+	@Test
+	public void testEmptyMap() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		HasMap hasMap = (HasMap) xbf.getBean("emptyMap");
+		assertTrue(hasMap.getMap().size() == 0);
+	}
+
+	@Test
+	public void testMapWithLiteralsOnly() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		HasMap hasMap = (HasMap) xbf.getBean("literalMap");
+		assertTrue(hasMap.getMap().size() == 3);
+		assertTrue(hasMap.getMap().get("foo").equals("bar"));
+		assertTrue(hasMap.getMap().get("fi").equals("fum"));
+		assertTrue(hasMap.getMap().get("fa") == null);
+	}
+
+	@Test
+	public void testMapWithLiteralsAndReferences() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		HasMap hasMap = (HasMap) xbf.getBean("mixedMap");
+		assertTrue(hasMap.getMap().size() == 3);
+		assertTrue(hasMap.getMap().get("foo").equals(new Integer(10)));
+		TestBean jenny = (TestBean) xbf.getBean("jenny");
+		assertTrue(hasMap.getMap().get("jenny") == jenny);
+		assertTrue(hasMap.getMap().get(new Integer(5)).equals("david"));
+	}
+
+	@Test
+	public void testMapWithLiteralsAndPrototypeReferences() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+
+		TestBean jenny = (TestBean) xbf.getBean("pJenny");
+		HasMap hasMap = (HasMap) xbf.getBean("pMixedMap");
+		assertTrue(hasMap.getMap().size() == 2);
+		assertTrue(hasMap.getMap().get("foo").equals("bar"));
+		assertTrue(hasMap.getMap().get("jenny").toString().equals(jenny.toString()));
+		assertTrue("Not same instance", hasMap.getMap().get("jenny") != jenny);
+
+		HasMap hasMap2 = (HasMap) xbf.getBean("pMixedMap");
+		assertTrue(hasMap2.getMap().size() == 2);
+		assertTrue(hasMap2.getMap().get("foo").equals("bar"));
+		assertTrue(hasMap2.getMap().get("jenny").toString().equals(jenny.toString()));
+		assertTrue("Not same instance", hasMap2.getMap().get("jenny") != hasMap.getMap().get("jenny"));
+	}
+
+	@Test
+	public void testMapWithLiteralsReferencesAndList() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		HasMap hasMap = (HasMap) xbf.getBean("mixedMapWithList");
+		assertTrue(hasMap.getMap().size() == 4);
+		assertTrue(hasMap.getMap().get(null).equals("bar"));
+		TestBean jenny = (TestBean) xbf.getBean("jenny");
+		assertTrue(hasMap.getMap().get("jenny").equals(jenny));
+
+		// Check list
+		List l = (List) hasMap.getMap().get("list");
+		assertNotNull(l);
+		assertTrue(l.size() == 4);
+		assertTrue(l.get(0).equals("zero"));
+		assertTrue(l.get(3) == null);
+
+		// Check nested map in list
+		Map m = (Map) l.get(1);
+		assertNotNull(m);
+		assertTrue(m.size() == 2);
+		assertTrue(m.get("fo").equals("bar"));
+		assertTrue("Map element 'jenny' should be equal to jenny bean, not " + m.get("jen"),
+				m.get("jen").equals(jenny));
+
+		// Check nested list in list
+		l = (List) l.get(2);
+		assertNotNull(l);
+		assertTrue(l.size() == 2);
+		assertTrue(l.get(0).equals(jenny));
+		assertTrue(l.get(1).equals("ba"));
+
+		// Check nested map
+		m = (Map) hasMap.getMap().get("map");
+		assertNotNull(m);
+		assertTrue(m.size() == 2);
+		assertTrue(m.get("foo").equals("bar"));
+		assertTrue("Map element 'jenny' should be equal to jenny bean, not " + m.get("jenny"),
+				m.get("jenny").equals(jenny));
+	}
+
+	@Test
+	public void testEmptySet() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		HasMap hasMap = (HasMap) xbf.getBean("emptySet");
+		assertTrue(hasMap.getSet().size() == 0);
+	}
+
+	@Test
+	public void testPopulatedSet() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		HasMap hasMap = (HasMap) xbf.getBean("set");
+		assertTrue(hasMap.getSet().size() == 3);
+		assertTrue(hasMap.getSet().contains("bar"));
+		TestBean jenny = (TestBean) xbf.getBean("jenny");
+		assertTrue(hasMap.getSet().contains(jenny));
+		assertTrue(hasMap.getSet().contains(null));
+		Iterator it = hasMap.getSet().iterator();
+		assertEquals("bar", it.next());
+		assertEquals(jenny, it.next());
+		assertEquals(null, it.next());
+	}
+
+	@Test
+	public void testEmptyProps() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		HasMap hasMap = (HasMap) xbf.getBean("emptyProps");
+		assertTrue(hasMap.getProps().size() == 0);
+		assertEquals(hasMap.getProps().getClass(), Properties.class);
+	}
+
+	@Test
+	public void testPopulatedProps() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		HasMap hasMap = (HasMap) xbf.getBean("props");
+		assertTrue(hasMap.getProps().size() == 2);
+		assertTrue(hasMap.getProps().get("foo").equals("bar"));
+		assertTrue(hasMap.getProps().get("2").equals("TWO"));
+	}
+
+	@Test
+	public void testObjectArray() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		HasMap hasMap = (HasMap) xbf.getBean("objectArray");
+		assertTrue(hasMap.getObjectArray().length == 2);
+		assertTrue(hasMap.getObjectArray()[0].equals("one"));
+		assertTrue(hasMap.getObjectArray()[1].equals(xbf.getBean("jenny")));
+	}
+
+	@Test
+	public void testClassArray() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		HasMap hasMap = (HasMap) xbf.getBean("classArray");
+		assertTrue(hasMap.getClassArray().length == 2);
+		assertTrue(hasMap.getClassArray()[0].equals(String.class));
+		assertTrue(hasMap.getClassArray()[1].equals(Exception.class));
+	}
+
+	@Test
+	public void testIntegerArray() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		HasMap hasMap = (HasMap) xbf.getBean("integerArray");
+		assertTrue(hasMap.getIntegerArray().length == 3);
+		assertTrue(hasMap.getIntegerArray()[0].intValue() == 0);
+		assertTrue(hasMap.getIntegerArray()[1].intValue() == 1);
+		assertTrue(hasMap.getIntegerArray()[2].intValue() == 2);
+	}
+
+	@Test
+	public void testProps() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+
+		HasMap hasMap = (HasMap) xbf.getBean("props");
+		assertEquals(2, hasMap.getProps().size());
+		assertEquals("bar", hasMap.getProps().getProperty("foo"));
+		assertEquals("TWO", hasMap.getProps().getProperty("2"));
+
+		HasMap hasMap2 = (HasMap) xbf.getBean("propsViaMap");
+		assertEquals(2, hasMap2.getProps().size());
+		assertEquals("bar", hasMap2.getProps().getProperty("foo"));
+		assertEquals("TWO", hasMap2.getProps().getProperty("2"));
+	}
+
+	@Test
+	public void testListFactory() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		List list = (List) xbf.getBean("listFactory");
+		assertTrue(list instanceof LinkedList);
+		assertTrue(list.size() == 2);
+		assertEquals("bar", list.get(0));
+		assertEquals("jenny", list.get(1));
+	}
+
+	@Test
+	public void testPrototypeListFactory() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		List list = (List) xbf.getBean("pListFactory");
+		assertTrue(list instanceof LinkedList);
+		assertTrue(list.size() == 2);
+		assertEquals("bar", list.get(0));
+		assertEquals("jenny", list.get(1));
+	}
+
+	@Test
+	public void testSetFactory() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		Set set = (Set) xbf.getBean("setFactory");
+		assertTrue(set instanceof TreeSet);
+		assertTrue(set.size() == 2);
+		assertTrue(set.contains("bar"));
+		assertTrue(set.contains("jenny"));
+	}
+
+	@Test
+	public void testPrototypeSetFactory() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		Set set = (Set) xbf.getBean("pSetFactory");
+		assertTrue(set instanceof TreeSet);
+		assertTrue(set.size() == 2);
+		assertTrue(set.contains("bar"));
+		assertTrue(set.contains("jenny"));
+	}
+
+	@Test
+	public void testMapFactory() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		Map map = (Map) xbf.getBean("mapFactory");
+		assertTrue(map instanceof TreeMap);
+		assertTrue(map.size() == 2);
+		assertEquals("bar", map.get("foo"));
+		assertEquals("jenny", map.get("jen"));
+	}
+
+	@Test
+	public void testPrototypeMapFactory() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		Map map = (Map) xbf.getBean("pMapFactory");
+		assertTrue(map instanceof TreeMap);
+		assertTrue(map.size() == 2);
+		assertEquals("bar", map.get("foo"));
+		assertEquals("jenny", map.get("jen"));
+	}
+
+	@Test
+	public void testChoiceBetweenSetAndMap() {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		MapAndSet sam = (MapAndSet) xbf.getBean("setAndMap");
+		assertTrue("Didn't choose constructor with Map argument", sam.getObject() instanceof Map);
+		Map map = (Map) sam.getObject();
+		assertEquals(3, map.size());
+		assertEquals("val1", map.get("key1"));
+		assertEquals("val2", map.get("key2"));
+		assertEquals("val3", map.get("key3"));
+	}
+
+	@Test
+	public void testEnumSetFactory() throws Exception {
+		XmlBeanFactory xbf = new XmlBeanFactory(new ClassPathResource("collections.xml", getClass()));
+		Set set = (Set) xbf.getBean("enumSetFactory");
+		assertTrue(set.size() == 2);
+		assertTrue(set.contains("ONE"));
+		assertTrue(set.contains("TWO"));
+	}
+
+	public static class MapAndSet {
+
+		private Object obj;
+
+		public MapAndSet(Map map) {
+			this.obj = map;
+		}
+
+		public MapAndSet(Set set) {
+			this.obj = set;
+		}
+
+		public Object getObject() {
+			return obj;
+		}
+	}
+
+}

org.springframework.beans/src/test/java/org/springframework/beans/factory/xml/collections.xml

@@ -0,0 +1,376 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
+
+	<bean id="jenny" class="org.springframework.beans.TestBean">	
+		<property name="name"><value>Jenny</value></property>
+		<property name="age"><value>30</value></property>
+		<property name="spouse">
+		<!-- Could use id and href -->
+			<ref local="david"/>
+		</property>
+	</bean>
+	
+	<bean id="david" class="org.springframework.beans.TestBean">	
+		<description>
+			Simple bean, without any collections.
+		</description>
+		<property name="name">
+			<description>The name of the user</description>
+			<value>David</value>
+		</property>
+		<property name="age"><value>27</value></property>
+	</bean>
+	
+	<bean id="rod" class="org.springframework.beans.TestBean">	
+		<property name="name"><value>Rod</value></property>
+		<property name="age"><value>32</value></property>
+		<property name="friends">
+			<description>List of Rod's friends</description>
+			<list>
+				<ref local="jenny"/>
+				<ref local="david"/>
+			</list>
+		</property>
+	</bean>
+	
+	<bean id="pJenny" class="org.springframework.beans.TestBean" scope="prototype">
+		<property name="name"><value>Jenny</value></property>
+		<property name="age"><value>30</value></property>
+		<property name="spouse">
+		<!-- Could use id and href -->
+			<ref local="david"/>
+		</property>
+	</bean>
+
+	<bean id="pDavid" class="org.springframework.beans.TestBean" scope="prototype">
+		<property name="name"><value>David</value></property>
+		<property name="age"><value>27</value></property>
+	</bean>
+
+	<bean id="pRod" class="org.springframework.beans.TestBean" scope="prototype">
+		<property name="name"><value>Rod</value></property>
+		<property name="age"><value>32</value></property>
+		<property name="friends">
+			<list>
+				<ref local="pJenny"/>
+				<ref local="pDavid"/>
+			</list>
+		</property>
+	</bean>
+
+	<!--
+		Try setting a collection property to a single value
+	-->
+	<bean id="loner" class="org.springframework.beans.TestBean">	
+		<property name="name"><value>loner</value></property>
+		<property name="age"><value>26</value></property>
+		<property name="friends">
+			<list>
+				<description>My List</description>
+				<ref local="david"/>
+			</list>
+		</property>
+	</bean>
+	
+	<bean id="jumble" class="org.springframework.beans.factory.xml.MixedCollectionBean">	
+		<property name="jumble">
+			<list>
+				<ref local="david"/>
+				<value>literal</value>
+				<ref local="jenny"/>
+				<idref local="rod"/>
+			</list>
+		</property>
+	</bean>
+	
+	<bean id="jumble2" class="org.springframework.beans.factory.xml.MixedCollectionBean" lazy-init="true">
+		<property name="jumble">
+			<list>
+				<ref local="david"/>
+				<value>literal</value>
+				<ref local="jenny"/>
+				<idref bean="rod"/>
+				<idref bean="rod2"/>
+			</list>
+		</property>
+	</bean>
+
+	<bean id="verbose" class="org.springframework.beans.TestBean">
+		<property name="name"><value>verbose</value></property>
+	</bean>
+	
+	<bean id="verbose2" class="org.springframework.beans.TestBean">	
+		<property name="name"><idref local="verbose"/></property>
+	</bean>
+
+	<bean id="verbose3" class="org.springframework.beans.TestBean">	
+		<property name="name"><idref bean="verbose"/></property>
+	</bean>
+
+	<bean id="emptyMap" class="org.springframework.beans.factory.HasMap">
+		<property name="map">
+			<map>
+			</map>
+		</property>
+	</bean>
+	
+	<bean id="literalMap" class="org.springframework.beans.factory.HasMap">	
+		<property name="map">
+			<map>
+				<entry key="foo" value="bar"/>
+				<entry key="fi" value="fum"/>
+				<entry key="fa"><null/></entry>
+			</map>
+		</property>
+	</bean>
+
+	<bean id="mixedMap" class="org.springframework.beans.factory.HasMap">
+		<property name="map">
+			<map>
+				<entry key-ref="fooKey">
+					<value type="java.lang.Integer">10</value>
+				</entry>
+				<entry>
+ 					<key>
+						<ref bean="jennyKey"/>
+					</key>
+					<ref local="jenny"/>
+				</entry>
+				<entry>
+ 					<key>
+ 						<bean class="java.lang.Integer">
+ 							<constructor-arg value="5"/>
+						</bean>
+					</key>
+					<idref bean="david"/>
+				</entry>
+			</map>
+		</property>
+	</bean>
+
+	<bean id="fooKey" class="java.lang.String">
+		<constructor-arg value="foo"/>
+	</bean>
+
+	<bean id="jennyKey" class="java.lang.String">
+		<constructor-arg value="jenny"/>
+	</bean>
+
+	<bean id="pMixedMap" class="org.springframework.beans.factory.HasMap" scope="prototype">
+		<property name="map">
+			<map>
+				<entry key="foo" value="bar"/>
+				<entry key="jenny" value-ref="pJenny"/>
+			</map>
+		</property>
+	</bean>
+
+	<bean id="mixedMapWithList" class="org.springframework.beans.factory.HasMap">
+		<property name="map">
+			<map>
+				<entry>
+					<key><null/></key>
+					<value>bar</value>
+				</entry>
+				<entry key="jenny"><ref local="jenny"/></entry>
+				<entry key="list">
+					<list>
+						<value>zero</value>
+						<map>
+							<entry key="fo"><value>bar</value></entry>
+							<entry key="jen"><ref local="jenny"/></entry>
+						</map>
+						<list>
+							<ref local="jenny"/>
+							<value>ba</value>
+						</list>
+						<null/>
+					</list>
+				</entry>
+				<entry key="map">
+					<map>
+						<entry key="foo"><value>bar</value></entry>
+						<entry key="jenny"><ref local="jenny"/></entry>
+					</map>
+				</entry>
+			</map>
+		</property>
+	</bean>
+	
+	<bean id="emptySet" class="org.springframework.beans.factory.HasMap">
+		<property name="set">
+			<set>
+			</set>
+		</property>
+	</bean>
+
+
+	<bean id="set" class="org.springframework.beans.factory.HasMap">
+		<property name="set">
+			<set>
+				<value>bar</value>
+				<ref local="jenny"/>
+				<null/>
+			</set>
+		</property>
+	</bean>
+
+	<bean id="emptyProps" class="org.springframework.beans.factory.HasMap">
+		<property name="props">
+			<props>
+			</props>
+		</property>
+	</bean>
+	
+	
+	<bean id="props" class="org.springframework.beans.factory.HasMap">	
+		<property name="props">
+			<props>
+				<prop key="foo">bar</prop>
+				<prop key="2">TWO</prop>
+			</props>
+		</property>
+	</bean>
+	
+	<bean id="propsViaMap" class="org.springframework.beans.factory.HasMap">
+		<property name="props">
+			<map>
+				<entry key="foo" value="bar"/>
+				<entry key="2" value="TWO"/>
+			</map>
+		</property>
+	</bean>
+
+	<bean id="objectArray" class="org.springframework.beans.factory.HasMap">
+		<property name="objectArray">
+			<list>
+				<value>one</value>
+				<ref local="jenny"/>
+			</list>
+		</property>
+	</bean>
+	
+	<bean id="classArray" class="org.springframework.beans.factory.HasMap">	
+		<property name="classArray">
+			<list>
+				<value>java.lang.String</value>
+				<value>java.lang.Exception</value>
+			</list>
+		</property>
+	</bean>
+	
+	<bean id="integerArray" class="org.springframework.beans.factory.HasMap">
+		<property name="integerArray">
+			<list>
+				<value>0</value>
+				<value>1</value>
+				<value>2</value>
+			</list>
+		</property>
+	</bean>
+
+	<bean id="listFactory" class="org.springframework.beans.factory.config.ListFactoryBean">
+		<property name="sourceList">
+			<list>
+				<value>bar</value>
+				<value>jenny</value>
+			</list>
+		</property>
+		<property name="targetListClass">
+			<value>java.util.LinkedList</value>
+		</property>
+	</bean>
+
+	<bean id="pListFactory" class="org.springframework.beans.factory.config.ListFactoryBean">
+		<property name="sourceList">
+			<list>
+				<value>bar</value>
+				<value>jenny</value>
+			</list>
+		</property>
+		<property name="targetListClass">
+			<value>java.util.LinkedList</value>
+		</property>
+		<property name="singleton">
+			<value>true</value>
+		</property>
+	</bean>
+
+	<bean id="setFactory" class="org.springframework.beans.factory.config.SetFactoryBean">
+		<property name="sourceSet">
+			<set>
+				<value>bar</value>
+				<value>jenny</value>
+			</set>
+		</property>
+		<property name="targetSetClass">
+			<value>java.util.TreeSet</value>
+		</property>
+	</bean>
+
+	<bean id="pSetFactory" class="org.springframework.beans.factory.config.SetFactoryBean">
+		<property name="sourceSet">
+			<set>
+				<value>bar</value>
+				<value>jenny</value>
+			</set>
+		</property>
+		<property name="targetSetClass">
+			<value>java.util.TreeSet</value>
+		</property>
+		<property name="singleton">
+			<value>true</value>
+		</property>
+	</bean>
+
+	<bean id="mapFactory" class="org.springframework.beans.factory.config.MapFactoryBean">
+		<property name="sourceMap">
+			<map>
+				<entry key="foo"><value>bar</value></entry>
+				<entry key="jen"><value>jenny</value></entry>
+			</map>
+		</property>
+		<property name="targetMapClass">
+			<value>java.util.TreeMap</value>
+		</property>
+	</bean>
+
+	<bean id="pMapFactory" class="org.springframework.beans.factory.config.MapFactoryBean">
+		<property name="sourceMap">
+			<map>
+				<entry key="foo"><value>bar</value></entry>
+				<entry key="jen"><value>jenny</value></entry>
+			</map>
+		</property>
+		<property name="targetMapClass">
+			<value>java.util.TreeMap</value>
+		</property>
+		<property name="singleton">
+			<value>true</value>
+		</property>
+	</bean>
+
+	<bean id="setAndMap" class="org.springframework.beans.factory.xml.XmlBeanCollectionTests$MapAndSet">
+		<constructor-arg>
+			<map>
+				<description>My Map</description>
+				<entry key="key1" value="val1"/>
+				<entry key="key2" value="val2"/>
+				<entry key="key3" value="val3"/>
+			</map>
+		</constructor-arg>
+	</bean>
+
+	<bean id="enumSetFactory" class="org.springframework.beans.factory.config.SetFactoryBean">
+		<property name="sourceSet">
+			<set>
+				<description>My Set</description>
+				<value type="java.lang.String">ONE</value>
+				<value type="java.lang.String">TWO</value>
+			</set>
+		</property>
+	</bean>
+
+</beans>

org.springframework.beans/src/test/java/org/springframework/beans/factory/xml/support/DefaultNamespaceHandlerResolverTests.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2002-2006 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.factory.xml.support;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+import org.springframework.beans.factory.xml.DefaultNamespaceHandlerResolver;
+import org.springframework.beans.factory.xml.NamespaceHandler;
+import org.springframework.beans.factory.xml.UtilNamespaceHandler;
+
+/**
+ * Unit and integration tests for the {@link DefaultNamespaceHandlerResolver} class.
+ * 
+ * @author Rob Harrop
+ * @author Rick Evans
+ */
+public class DefaultNamespaceHandlerResolverTests {
+
+	@Test
+	public void testResolvedMappedHandler() {
+		DefaultNamespaceHandlerResolver resolver = new DefaultNamespaceHandlerResolver(getClass().getClassLoader());
+		NamespaceHandler handler = resolver.resolve("http://www.springframework.org/schema/util");
+		assertNotNull("Handler should not be null.", handler);
+		assertEquals("Incorrect handler loaded", UtilNamespaceHandler.class, handler.getClass());
+	}
+
+	@Test
+	public void testResolvedMappedHandlerWithNoArgCtor() {
+		DefaultNamespaceHandlerResolver resolver = new DefaultNamespaceHandlerResolver();
+		NamespaceHandler handler = resolver.resolve("http://www.springframework.org/schema/util");
+		assertNotNull("Handler should not be null.", handler);
+		assertEquals("Incorrect handler loaded", UtilNamespaceHandler.class, handler.getClass());
+	}
+
+	@Test
+	public void testNonExistentHandlerClass() throws Exception {
+		String mappingPath = "org/springframework/beans/factory/xml/support/nonExistent.properties";
+		try {
+			new DefaultNamespaceHandlerResolver(getClass().getClassLoader(), mappingPath);
+			// pass
+		}
+		catch (Throwable ex) {
+			fail("Non-existent handler classes must be ignored: " + ex);
+		}
+	}
+
+	@Test
+	public void testResolveInvalidHandler() throws Exception {
+		String mappingPath = "org/springframework/beans/factory/xml/support/invalid.properties";
+		try {
+			new DefaultNamespaceHandlerResolver(getClass().getClassLoader(), mappingPath);
+			fail("Should not be able to map a class that doesn't implement NamespaceHandler");
+		}
+		catch (Throwable expected) {
+		}
+	}
+
+	@Test
+	public void testCtorWithNullClassLoaderArgument() throws Exception {
+		// simply must not bail...
+		new DefaultNamespaceHandlerResolver(null);
+	}
+
+	@Test(expected=IllegalArgumentException.class)
+	public void testCtorWithNullClassLoaderArgumentAndNullMappingLocationArgument() throws Exception {
+		new DefaultNamespaceHandlerResolver(null, null);
+	}
+
+	@Test
+	public void testCtorWithNonExistentMappingLocationArgument() throws Exception {
+		// simply must not bail; we don't want non-existent resources to result in an Exception
+		new DefaultNamespaceHandlerResolver(null, "738trbc bobabloobop871");
+	}
+
+}