moving unit tests from .testsuite -> .test, .web.servlet

org.springframework.web.servlet/src/test/java/org/springframework/mock/web/MockFilterConfig.java

@@ -0,0 +1,106 @@
+/*
+ * 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.mock.web;
+
+import java.util.Enumeration;
+import java.util.Properties;
+import java.util.Collections;
+import java.util.Map;
+import java.util.LinkedHashMap;
+
+import javax.servlet.FilterConfig;
+import javax.servlet.ServletContext;
+
+import org.springframework.util.Assert;
+
+/**
+ * Mock implementation of the {@link javax.servlet.FilterConfig} interface.
+ *
+ * <p>Used for testing the web framework; also usefol for testing
+ * custom {@link javax.servlet.Filter} implementations.
+ *
+ * @author Juergen Hoeller
+ * @since 1.0.2
+ * @see MockFilterChain
+ * @see PassThroughFilterChain
+ */
+public class MockFilterConfig implements FilterConfig {
+
+	private final ServletContext servletContext;
+
+	private final String filterName;
+
+	private final Map<String, String> initParameters = new LinkedHashMap<String, String>();
+
+
+	/**
+	 * Create a new MockFilterConfig with a default {@link MockServletContext}.
+	 */
+	public MockFilterConfig() {
+		this(null, "");
+	}
+
+	/**
+	 * Create a new MockFilterConfig with a default {@link MockServletContext}.
+	 * @param filterName the name of the filter
+	 */
+	public MockFilterConfig(String filterName) {
+		this(null, filterName);
+	}
+
+	/**
+	 * Create a new MockFilterConfig.
+	 * @param servletContext the ServletContext that the servlet runs in
+	 */
+	public MockFilterConfig(ServletContext servletContext) {
+		this(servletContext, "");
+	}
+
+	/**
+	 * Create a new MockFilterConfig.
+	 * @param servletContext the ServletContext that the servlet runs in
+	 * @param filterName the name of the filter
+	 */
+	public MockFilterConfig(ServletContext servletContext, String filterName) {
+		this.servletContext = (servletContext != null ? servletContext : new MockServletContext());
+		this.filterName = filterName;
+	}
+
+
+	public String getFilterName() {
+		return filterName;
+	}
+
+	public ServletContext getServletContext() {
+		return servletContext;
+	}
+
+	public void addInitParameter(String name, String value) {
+		Assert.notNull(name, "Parameter name must not be null");
+		this.initParameters.put(name, value);
+	}
+
+	public String getInitParameter(String name) {
+		Assert.notNull(name, "Parameter name must not be null");
+		return this.initParameters.get(name);
+	}
+
+	public Enumeration<String> getInitParameterNames() {
+		return Collections.enumeration(this.initParameters.keySet());
+	}
+
+}

org.springframework.web.servlet/src/test/java/org/springframework/mock/web/PassThroughFilterChain.java

@@ -0,0 +1,86 @@
+/*
+ * 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.mock.web;
+
+import java.io.IOException;
+
+import javax.servlet.Filter;
+import javax.servlet.FilterChain;
+import javax.servlet.Servlet;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+
+import org.springframework.util.Assert;
+
+/**
+ * Implementation of the {@link javax.servlet.FilterConfig} interface which
+ * simply passes the call through to a given Filter/FilterChain combo
+ * (indicating the next Filter in the chain along with the FilterChain that it is
+ * supposed to work on) or to a given Servlet (indicating the end of the chain).
+ *
+ * @author Juergen Hoeller
+ * @since 2.0.3
+ * @see javax.servlet.Filter
+ * @see javax.servlet.Servlet
+ * @see MockFilterChain
+ */
+public class PassThroughFilterChain implements FilterChain {
+
+	private Filter filter;
+
+	private FilterChain nextFilterChain;
+
+	private Servlet servlet;
+
+
+	/**
+	 * Create a new PassThroughFilterChain that delegates to the given Filter,
+	 * calling it with the given FilterChain.
+	 * @param filter the Filter to delegate to
+	 * @param nextFilterChain the FilterChain to use for that next Filter
+	 */
+	public PassThroughFilterChain(Filter filter, FilterChain nextFilterChain) {
+		Assert.notNull(filter, "Filter must not be null");
+		Assert.notNull(nextFilterChain, "'FilterChain must not be null");
+		this.filter = filter;
+		this.nextFilterChain = nextFilterChain;
+	}
+
+	/**
+	 * Create a new PassThroughFilterChain that delegates to the given Servlet.
+	 * @param servlet the Servlet to delegate to
+	 */
+	public PassThroughFilterChain(Servlet servlet) {
+		Assert.notNull(servlet, "Servlet must not be null");
+		this.servlet = servlet;
+	}
+
+
+	/**
+	 * Pass the call on to the Filter/Servlet.
+	 */
+	public void doFilter(ServletRequest request, ServletResponse response) throws ServletException, IOException {
+		if (this.filter != null) {
+			this.filter.doFilter(request, response, this.nextFilterChain);
+		}
+		else {
+			this.servlet.service(request, response);
+		}
+	}
+
+}

org.springframework.web.servlet/src/test/java/org/springframework/web/bind/ServletRequestDataBinderTests.java

@@ -0,0 +1,202 @@
+/*
+ * 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.web.bind;
+
+import static org.junit.Assert.*;
+
+import java.beans.PropertyEditorSupport;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Test;
+import org.springframework.beans.ITestBean;
+import org.springframework.beans.PropertyValue;
+import org.springframework.beans.PropertyValues;
+import org.springframework.beans.TestBean;
+import org.springframework.mock.web.MockHttpServletRequest;
+
+/**
+ * @author Rod Johnson
+ * @author Juergen Hoeller
+ * @author Chris Beams
+ */
+public class ServletRequestDataBinderTests {
+
+	@Test
+	public void testBindingWithNestedObjectCreation() throws Exception {
+		TestBean tb = new TestBean();
+
+		ServletRequestDataBinder binder = new ServletRequestDataBinder(tb, "person");
+		binder.registerCustomEditor(ITestBean.class, new PropertyEditorSupport() {
+			public void setAsText(String text) throws IllegalArgumentException {
+				setValue(new TestBean());
+			}
+		});
+
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.addParameter("spouse", "someValue");
+		request.addParameter("spouse.name", "test");
+		binder.bind(request);
+
+		assertNotNull(tb.getSpouse());
+		assertEquals("test", tb.getSpouse().getName());
+	}
+
+	@Test
+	public void testFieldPrefixCausesFieldReset() throws Exception {
+		TestBean target = new TestBean();
+		ServletRequestDataBinder binder = new ServletRequestDataBinder(target);
+
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.addParameter("_postProcessed", "visible");
+		request.addParameter("postProcessed", "on");
+		binder.bind(request);
+		assertTrue(target.isPostProcessed());
+
+		request.removeParameter("postProcessed");
+		binder.bind(request);
+		assertFalse(target.isPostProcessed());
+	}
+
+	@Test
+	public void testFieldPrefixCausesFieldResetWithIgnoreUnknownFields() throws Exception {
+		TestBean target = new TestBean();
+		ServletRequestDataBinder binder = new ServletRequestDataBinder(target);
+		binder.setIgnoreUnknownFields(false);
+
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.addParameter("_postProcessed", "visible");
+		request.addParameter("postProcessed", "on");
+		binder.bind(request);
+		assertTrue(target.isPostProcessed());
+
+		request.removeParameter("postProcessed");
+		binder.bind(request);
+		assertFalse(target.isPostProcessed());
+	}
+
+	@Test
+	public void testWithCommaSeparatedStringArray() throws Exception {
+		TestBean target = new TestBean();
+		ServletRequestDataBinder binder = new ServletRequestDataBinder(target);
+
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.addParameter("stringArray", "bar");
+		request.addParameter("stringArray", "abc");
+		request.addParameter("stringArray", "123,def");
+		binder.bind(request);
+		assertEquals("Expected all three items to be bound", 3, target.getStringArray().length);
+
+		request.removeParameter("stringArray");
+		request.addParameter("stringArray", "123,def");
+		binder.bind(request);
+		assertEquals("Expected only 1 item to be bound", 1, target.getStringArray().length);
+	}
+
+	@Test
+	public void testBindingWithNestedObjectCreationAndWrongOrder() throws Exception {
+		TestBean tb = new TestBean();
+
+		ServletRequestDataBinder binder = new ServletRequestDataBinder(tb, "person");
+		binder.registerCustomEditor(ITestBean.class, new PropertyEditorSupport() {
+			public void setAsText(String text) throws IllegalArgumentException {
+				setValue(new TestBean());
+			}
+		});
+
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.addParameter("spouse.name", "test");
+		request.addParameter("spouse", "someValue");
+		binder.bind(request);
+
+		assertNotNull(tb.getSpouse());
+		assertEquals("test", tb.getSpouse().getName());
+	}
+
+	@Test
+	public void testNoPrefix() throws Exception {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.addParameter("forname", "Tony");
+		request.addParameter("surname", "Blair");
+		request.addParameter("age", "" + 50);
+
+		ServletRequestParameterPropertyValues pvs = new ServletRequestParameterPropertyValues(request);
+		doTestTony(pvs);
+	}
+
+	@Test
+	public void testPrefix() throws Exception {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.addParameter("test_forname", "Tony");
+		request.addParameter("test_surname", "Blair");
+		request.addParameter("test_age", "" + 50);
+
+		ServletRequestParameterPropertyValues pvs = new ServletRequestParameterPropertyValues(request);
+		assertTrue("Didn't fidn normal when given prefix", !pvs.contains("forname"));
+		assertTrue("Did treat prefix as normal when not given prefix", pvs.contains("test_forname"));
+
+		pvs = new ServletRequestParameterPropertyValues(request, "test");
+		doTestTony(pvs);
+	}
+
+	@Test
+	public void testNoParameters() throws Exception {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		ServletRequestParameterPropertyValues pvs = new ServletRequestParameterPropertyValues(request);
+		assertTrue("Found no parameters", pvs.getPropertyValues().length == 0);
+	}
+
+	@Test
+	public void testMultipleValuesForParameter() throws Exception {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		String[] original = new String[] {"Tony", "Rod"};
+		request.addParameter("forname", original);
+
+		ServletRequestParameterPropertyValues pvs = new ServletRequestParameterPropertyValues(request);
+		assertTrue("Found 1 parameter", pvs.getPropertyValues().length == 1);
+		assertTrue("Found array value", pvs.getPropertyValue("forname").getValue() instanceof String[]);
+		String[] values = (String[]) pvs.getPropertyValue("forname").getValue();
+		assertEquals("Correct values", Arrays.asList(values), Arrays.asList(original));
+	}
+
+	/**
+	 * Must contain: forname=Tony surname=Blair age=50
+	 */
+	protected void doTestTony(PropertyValues pvs) throws Exception {
+		assertTrue("Contains 3", pvs.getPropertyValues().length == 3);
+		assertTrue("Contains forname", pvs.contains("forname"));
+		assertTrue("Contains surname", pvs.contains("surname"));
+		assertTrue("Contains age", pvs.contains("age"));
+		assertTrue("Doesn't contain tory", !pvs.contains("tory"));
+
+		PropertyValue[] ps = pvs.getPropertyValues();
+		Map<String, String> m = new HashMap<String, String>();
+		m.put("forname", "Tony");
+		m.put("surname", "Blair");
+		m.put("age", "50");
+		for (int i = 0; i < ps.length; i++) {
+			Object val = m.get(ps[i].getName());
+			assertTrue("Can't have unexpected value", val != null);
+			assertTrue("Val i string", val instanceof String);
+			assertTrue("val matches expected", val.equals(ps[i].getValue()));
+			m.remove(ps[i].getName());
+		}
+		assertTrue("Map size is 0", m.size() == 0);
+	}
+
+}

org.springframework.web.servlet/src/test/java/org/springframework/web/bind/ServletRequestUtilsTests.java

@@ -0,0 +1,465 @@
+/*
+ * 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.web.bind;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+import org.springframework.mock.web.MockHttpServletRequest;
+import org.springframework.util.StopWatch;
+
+/**
+ * @author Juergen Hoeller
+ * @author Chris Beams
+ * @since 06.08.2003
+ */
+public class ServletRequestUtilsTests {
+
+	@Test
+	public void testIntParameter() throws ServletRequestBindingException {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.addParameter("param1", "5");
+		request.addParameter("param2", "e");
+		request.addParameter("paramEmpty", "");
+
+		assertEquals(ServletRequestUtils.getIntParameter(request, "param1"), new Integer(5));
+		assertEquals(ServletRequestUtils.getIntParameter(request, "param1", 6), 5);
+		assertEquals(ServletRequestUtils.getRequiredIntParameter(request, "param1"), 5);
+
+		assertEquals(ServletRequestUtils.getIntParameter(request, "param2", 6), 6);
+		try {
+			ServletRequestUtils.getRequiredIntParameter(request, "param2");
+			fail("Should have thrown ServletRequestBindingException");
+		}
+		catch (ServletRequestBindingException ex) {
+			// expected
+		}
+
+		assertEquals(ServletRequestUtils.getIntParameter(request, "param3"), null);
+		assertEquals(ServletRequestUtils.getIntParameter(request, "param3", 6), 6);
+		try {
+			ServletRequestUtils.getRequiredIntParameter(request, "param3");
+			fail("Should have thrown ServletRequestBindingException");
+		}
+		catch (ServletRequestBindingException ex) {
+			// expected
+		}
+
+		try {
+			ServletRequestUtils.getRequiredIntParameter(request, "paramEmpty");
+			fail("Should have thrown ServletRequestBindingException");
+		}
+		catch (ServletRequestBindingException ex) {
+			// expected
+		}
+	}
+
+	@Test
+	public void testIntParameters() throws ServletRequestBindingException {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.addParameter("param", new String[] {"1", "2", "3"});
+
+		request.addParameter("param2", "1");
+		request.addParameter("param2", "2");
+		request.addParameter("param2", "bogus");
+
+		int[] array = new int[] {1, 2, 3};
+		int[] values = ServletRequestUtils.getRequiredIntParameters(request, "param");
+		assertEquals(3, values.length);
+		for (int i = 0; i < array.length; i++) {
+			assertEquals(array[i], values[i]);
+		}
+
+		try {
+			ServletRequestUtils.getRequiredIntParameters(request, "param2");
+			fail("Should have thrown ServletRequestBindingException");
+		}
+		catch (ServletRequestBindingException ex) {
+			// expected
+		}
+	}
+
+	@Test
+	public void testLongParameter() throws ServletRequestBindingException {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.addParameter("param1", "5");
+		request.addParameter("param2", "e");
+		request.addParameter("paramEmpty", "");
+
+		assertEquals(ServletRequestUtils.getLongParameter(request, "param1"), new Long(5L));
+		assertEquals(ServletRequestUtils.getLongParameter(request, "param1", 6L), 5L);
+		assertEquals(ServletRequestUtils.getRequiredIntParameter(request, "param1"), 5L);
+
+		assertEquals(ServletRequestUtils.getLongParameter(request, "param2", 6L), 6L);
+		try {
+			ServletRequestUtils.getRequiredLongParameter(request, "param2");
+			fail("Should have thrown ServletRequestBindingException");
+		}
+		catch (ServletRequestBindingException ex) {
+			// expected
+		}
+
+		assertEquals(ServletRequestUtils.getLongParameter(request, "param3"), null);
+		assertEquals(ServletRequestUtils.getLongParameter(request, "param3", 6L), 6L);
+		try {
+			ServletRequestUtils.getRequiredLongParameter(request, "param3");
+			fail("Should have thrown ServletRequestBindingException");
+		}
+		catch (ServletRequestBindingException ex) {
+			// expected
+		}
+
+		try {
+			ServletRequestUtils.getRequiredLongParameter(request, "paramEmpty");
+			fail("Should have thrown ServletRequestBindingException");
+		}
+		catch (ServletRequestBindingException ex) {
+			// expected
+		}
+	}
+
+	@Test
+	public void testLongParameters() throws ServletRequestBindingException {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.setParameter("param", new String[] {"1", "2", "3"});
+
+		request.setParameter("param2", "0");
+		request.setParameter("param2", "1");
+		request.addParameter("param2", "2");
+		request.addParameter("param2", "bogus");
+
+		long[] array = new long[] {1L, 2L, 3L};
+		long[] values = ServletRequestUtils.getRequiredLongParameters(request, "param");
+		assertEquals(3, values.length);
+		for (int i = 0; i < array.length; i++) {
+			assertEquals(array[i], values[i]);
+		}
+
+		try {
+			ServletRequestUtils.getRequiredLongParameters(request, "param2");
+			fail("Should have thrown ServletRequestBindingException");
+		}
+		catch (ServletRequestBindingException ex) {
+			// expected
+		}
+
+		request.setParameter("param2", new String[] {"1", "2"});
+		values = ServletRequestUtils.getRequiredLongParameters(request, "param2");
+		assertEquals(2, values.length);
+		assertEquals(1, values[0]);
+		assertEquals(2, values[1]);
+
+		request.removeParameter("param2");
+		try {
+			ServletRequestUtils.getRequiredLongParameters(request, "param2");
+			fail("Should have thrown ServletRequestBindingException");
+		}
+		catch (ServletRequestBindingException ex) {
+			// expected
+		}
+	}
+
+	@Test
+	public void testFloatParameter() throws ServletRequestBindingException {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.addParameter("param1", "5.5");
+		request.addParameter("param2", "e");
+		request.addParameter("paramEmpty", "");
+
+		assertTrue(ServletRequestUtils.getFloatParameter(request, "param1").equals(new Float(5.5f)));
+		assertTrue(ServletRequestUtils.getFloatParameter(request, "param1", 6.5f) == 5.5f);
+		assertTrue(ServletRequestUtils.getRequiredFloatParameter(request, "param1") == 5.5f);
+
+		assertTrue(ServletRequestUtils.getFloatParameter(request, "param2", 6.5f) == 6.5f);
+		try {
+			ServletRequestUtils.getRequiredFloatParameter(request, "param2");
+			fail("Should have thrown ServletRequestBindingException");
+		}
+		catch (ServletRequestBindingException ex) {
+			// expected
+		}
+
+		assertTrue(ServletRequestUtils.getFloatParameter(request, "param3") == null);
+		assertTrue(ServletRequestUtils.getFloatParameter(request, "param3", 6.5f) == 6.5f);
+		try {
+			ServletRequestUtils.getRequiredFloatParameter(request, "param3");
+			fail("Should have thrown ServletRequestBindingException");
+		}
+		catch (ServletRequestBindingException ex) {
+			// expected
+		}
+
+		try {
+			ServletRequestUtils.getRequiredFloatParameter(request, "paramEmpty");
+			fail("Should have thrown ServletRequestBindingException");
+		}
+		catch (ServletRequestBindingException ex) {
+			// expected
+		}
+	}
+
+	@Test
+	public void testFloatParameters() throws ServletRequestBindingException {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.addParameter("param", new String[] {"1.5", "2.5", "3"});
+
+		request.addParameter("param2", "1.5");
+		request.addParameter("param2", "2");
+		request.addParameter("param2", "bogus");
+
+		float[] array = new float[] {1.5F, 2.5F, 3};
+		float[] values = ServletRequestUtils.getRequiredFloatParameters(request, "param");
+		assertEquals(3, values.length);
+		for (int i = 0; i < array.length; i++) {
+			assertEquals(array[i], values[i], 0);
+		}
+
+		try {
+			ServletRequestUtils.getRequiredFloatParameters(request, "param2");
+			fail("Should have thrown ServletRequestBindingException");
+		}
+		catch (ServletRequestBindingException ex) {
+			// expected
+		}
+	}
+
+	@Test
+	public void testDoubleParameter() throws ServletRequestBindingException {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.addParameter("param1", "5.5");
+		request.addParameter("param2", "e");
+		request.addParameter("paramEmpty", "");
+
+		assertTrue(ServletRequestUtils.getDoubleParameter(request, "param1").equals(new Double(5.5)));
+		assertTrue(ServletRequestUtils.getDoubleParameter(request, "param1", 6.5) == 5.5);
+		assertTrue(ServletRequestUtils.getRequiredDoubleParameter(request, "param1") == 5.5);
+
+		assertTrue(ServletRequestUtils.getDoubleParameter(request, "param2", 6.5) == 6.5);
+		try {
+			ServletRequestUtils.getRequiredDoubleParameter(request, "param2");
+			fail("Should have thrown ServletRequestBindingException");
+		}
+		catch (ServletRequestBindingException ex) {
+			// expected
+		}
+
+		assertTrue(ServletRequestUtils.getDoubleParameter(request, "param3") == null);
+		assertTrue(ServletRequestUtils.getDoubleParameter(request, "param3", 6.5) == 6.5);
+		try {
+			ServletRequestUtils.getRequiredDoubleParameter(request, "param3");
+			fail("Should have thrown ServletRequestBindingException");
+		}
+		catch (ServletRequestBindingException ex) {
+			// expected
+		}
+
+		try {
+			ServletRequestUtils.getRequiredDoubleParameter(request, "paramEmpty");
+			fail("Should have thrown ServletRequestBindingException");
+		}
+		catch (ServletRequestBindingException ex) {
+			// expected
+		}
+	}
+
+	@Test
+	public void testDoubleParameters() throws ServletRequestBindingException {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.addParameter("param", new String[] {"1.5", "2.5", "3"});
+
+		request.addParameter("param2", "1.5");
+		request.addParameter("param2", "2");
+		request.addParameter("param2", "bogus");
+
+		double[] array = new double[] {1.5, 2.5, 3};
+		double[] values = ServletRequestUtils.getRequiredDoubleParameters(request, "param");
+		assertEquals(3, values.length);
+		for (int i = 0; i < array.length; i++) {
+			assertEquals(array[i], values[i], 0);
+		}
+
+		try {
+			ServletRequestUtils.getRequiredDoubleParameters(request, "param2");
+			fail("Should have thrown ServletRequestBindingException");
+		}
+		catch (ServletRequestBindingException ex) {
+			// expected
+		}
+	}
+
+	@Test
+	public void testBooleanParameter() throws ServletRequestBindingException {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.addParameter("param1", "true");
+		request.addParameter("param2", "e");
+		request.addParameter("param4", "yes");
+		request.addParameter("param5", "1");
+		request.addParameter("paramEmpty", "");
+
+		assertTrue(ServletRequestUtils.getBooleanParameter(request, "param1").equals(Boolean.TRUE));
+		assertTrue(ServletRequestUtils.getBooleanParameter(request, "param1", false));
+		assertTrue(ServletRequestUtils.getRequiredBooleanParameter(request, "param1"));
+
+		assertFalse(ServletRequestUtils.getBooleanParameter(request, "param2", true));
+		assertFalse(ServletRequestUtils.getRequiredBooleanParameter(request, "param2"));
+
+		assertTrue(ServletRequestUtils.getBooleanParameter(request, "param3") == null);
+		assertTrue(ServletRequestUtils.getBooleanParameter(request, "param3", true));
+		try {
+			ServletRequestUtils.getRequiredBooleanParameter(request, "param3");
+			fail("Should have thrown ServletRequestBindingException");
+		}
+		catch (ServletRequestBindingException ex) {
+			// expected
+		}
+
+		assertTrue(ServletRequestUtils.getBooleanParameter(request, "param4", false));
+		assertTrue(ServletRequestUtils.getRequiredBooleanParameter(request, "param4"));
+
+		assertTrue(ServletRequestUtils.getBooleanParameter(request, "param5", false));
+		assertTrue(ServletRequestUtils.getRequiredBooleanParameter(request, "param5"));
+		assertFalse(ServletRequestUtils.getRequiredBooleanParameter(request, "paramEmpty"));
+	}
+
+	@Test
+	public void testBooleanParameters() throws ServletRequestBindingException {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.addParameter("param", new String[] {"true", "yes", "off", "1", "bogus"});
+
+		request.addParameter("param2", "false");
+		request.addParameter("param2", "true");
+		request.addParameter("param2", "");
+
+		boolean[] array = new boolean[] {true, true, false, true, false};
+		boolean[] values = ServletRequestUtils.getRequiredBooleanParameters(request, "param");
+		assertEquals(array.length, values.length);
+		for (int i = 0; i < array.length; i++) {
+			assertEquals(array[i], values[i]);
+		}
+
+		array = new boolean[] {false, true, false};
+		values = ServletRequestUtils.getRequiredBooleanParameters(request, "param2");
+		assertEquals(array.length, values.length);
+		for (int i = 0; i < array.length; i++) {
+			assertEquals(array[i], values[i]);
+		}
+	}
+
+	@Test
+	public void testStringParameter() throws ServletRequestBindingException {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		request.addParameter("param1", "str");
+		request.addParameter("paramEmpty", "");
+
+		assertEquals("str", ServletRequestUtils.getStringParameter(request, "param1"));
+		assertEquals("str", ServletRequestUtils.getStringParameter(request, "param1", "string"));
+		assertEquals("str", ServletRequestUtils.getRequiredStringParameter(request, "param1"));
+
+		assertEquals(null, ServletRequestUtils.getStringParameter(request, "param3"));
+		assertEquals("string", ServletRequestUtils.getStringParameter(request, "param3", "string"));
+		assertNull(ServletRequestUtils.getStringParameter(request, "param3", null));
+		try {
+			ServletRequestUtils.getRequiredStringParameter(request, "param3");
+			fail("Should have thrown ServletRequestBindingException");
+		}
+		catch (ServletRequestBindingException ex) {
+			// expected
+		}
+
+		assertEquals("", ServletRequestUtils.getStringParameter(request, "paramEmpty"));
+		assertEquals("", ServletRequestUtils.getRequiredStringParameter(request, "paramEmpty"));
+	}
+
+	@Test
+	public void testGetIntParameterWithDefaultValueHandlingIsFastEnough() {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		StopWatch sw = new StopWatch();
+		sw.start();
+		for (int i = 0; i < 1000000; i++) {
+			ServletRequestUtils.getIntParameter(request, "nonExistingParam", 0);
+		}
+		sw.stop();
+		System.out.println(sw.getTotalTimeMillis());
+		assertTrue("getStringParameter took too long: " + sw.getTotalTimeMillis(), sw.getTotalTimeMillis() < 250);
+	}
+
+	@Test
+	public void testGetLongParameterWithDefaultValueHandlingIsFastEnough() {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		StopWatch sw = new StopWatch();
+		sw.start();
+		for (int i = 0; i < 1000000; i++) {
+			ServletRequestUtils.getLongParameter(request, "nonExistingParam", 0);
+		}
+		sw.stop();
+		System.out.println(sw.getTotalTimeMillis());
+		assertTrue("getStringParameter took too long: " + sw.getTotalTimeMillis(), sw.getTotalTimeMillis() < 250);
+	}
+
+	@Test
+	public void testGetFloatParameterWithDefaultValueHandlingIsFastEnough() {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		StopWatch sw = new StopWatch();
+		sw.start();
+		for (int i = 0; i < 1000000; i++) {
+			ServletRequestUtils.getFloatParameter(request, "nonExistingParam", 0f);
+		}
+		sw.stop();
+		System.out.println(sw.getTotalTimeMillis());
+		assertTrue("getStringParameter took too long: " + sw.getTotalTimeMillis(), sw.getTotalTimeMillis() < 250);
+	}
+
+	@Test
+	public void testGetDoubleParameterWithDefaultValueHandlingIsFastEnough() {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		StopWatch sw = new StopWatch();
+		sw.start();
+		for (int i = 0; i < 1000000; i++) {
+			ServletRequestUtils.getDoubleParameter(request, "nonExistingParam", 0d);
+		}
+		sw.stop();
+		System.out.println(sw.getTotalTimeMillis());
+		assertTrue("getStringParameter took too long: " + sw.getTotalTimeMillis(), sw.getTotalTimeMillis() < 250);
+	}
+
+	@Test
+	public void testGetBooleanParameterWithDefaultValueHandlingIsFastEnough() {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		StopWatch sw = new StopWatch();
+		sw.start();
+		for (int i = 0; i < 1000000; i++) {
+			ServletRequestUtils.getBooleanParameter(request, "nonExistingParam", false);
+		}
+		sw.stop();
+		System.out.println(sw.getTotalTimeMillis());
+		assertTrue("getStringParameter took too long: " + sw.getTotalTimeMillis(), sw.getTotalTimeMillis() < 250);
+	}
+
+	@Test
+	public void testGetStringParameterWithDefaultValueHandlingIsFastEnough() {
+		MockHttpServletRequest request = new MockHttpServletRequest();
+		StopWatch sw = new StopWatch();
+		sw.start();
+		for (int i = 0; i < 1000000; i++) {
+			ServletRequestUtils.getStringParameter(request, "nonExistingParam", "defaultValue");
+		}
+		sw.stop();
+		System.out.println(sw.getTotalTimeMillis());
+		assertTrue("getStringParameter took too long: " + sw.getTotalTimeMillis(), sw.getTotalTimeMillis() < 250);
+	}
+
+}

org.springframework.web.servlet/src/test/java/org/springframework/web/multipart/commons/CommonsMultipartResolverTests.java

@@ -0,0 +1,485 @@
+/*
+ * 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.web.multipart.commons;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.servlet.FilterChain;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import junit.framework.TestCase;
+import org.apache.commons.fileupload.FileItem;
+import org.apache.commons.fileupload.FileItemFactory;
+import org.apache.commons.fileupload.FileUpload;
+import org.apache.commons.fileupload.servlet.ServletFileUpload;
+
+import org.springframework.beans.MutablePropertyValues;
+import org.springframework.mock.web.MockFilterConfig;
+import org.springframework.mock.web.MockHttpServletRequest;
+import org.springframework.mock.web.MockHttpServletResponse;
+import org.springframework.mock.web.MockServletContext;
+import org.springframework.mock.web.PassThroughFilterChain;
+import org.springframework.web.bind.ServletRequestDataBinder;
+import org.springframework.web.context.WebApplicationContext;
+import org.springframework.web.context.support.StaticWebApplicationContext;
+import org.springframework.web.multipart.MultipartFile;
+import org.springframework.web.multipart.MultipartHttpServletRequest;
+import org.springframework.web.multipart.support.ByteArrayMultipartFileEditor;
+import org.springframework.web.multipart.support.MultipartFilter;
+import org.springframework.web.multipart.support.StringMultipartFileEditor;
+import org.springframework.web.util.WebUtils;
+
+/**
+ * @author Juergen Hoeller
+ * @since 08.10.2003
+ */
+public class CommonsMultipartResolverTests extends TestCase {
+
+	public void testWithApplicationContext() throws Exception {
+		doTestWithApplicationContext(false);
+	}
+
+	public void testWithApplicationContextAndLazyResolution() throws Exception {
+		doTestWithApplicationContext(true);
+	}
+
+	private void doTestWithApplicationContext(boolean lazy) throws Exception {
+		StaticWebApplicationContext wac = new StaticWebApplicationContext();
+		wac.setServletContext(new MockServletContext());
+		wac.getServletContext().setAttribute(WebUtils.TEMP_DIR_CONTEXT_ATTRIBUTE, new File("mytemp"));
+		wac.refresh();
+		MockCommonsMultipartResolver resolver = new MockCommonsMultipartResolver();
+		resolver.setMaxUploadSize(1000);
+		resolver.setMaxInMemorySize(100);
+		resolver.setDefaultEncoding("enc");
+		if (lazy) {
+			resolver.setResolveLazily(false);
+		}
+		resolver.setServletContext(wac.getServletContext());
+		assertEquals(1000, resolver.getFileUpload().getSizeMax());
+		assertEquals(100, resolver.getFileItemFactory().getSizeThreshold());
+		assertEquals("enc", resolver.getFileUpload().getHeaderEncoding());
+		assertTrue(resolver.getFileItemFactory().getRepository().getAbsolutePath().endsWith("mytemp"));
+
+		MockHttpServletRequest originalRequest = new MockHttpServletRequest();
+		originalRequest.setMethod("POST");
+		originalRequest.setContentType("multipart/form-data");
+		originalRequest.addHeader("Content-type", "multipart/form-data");
+		originalRequest.addParameter("getField", "getValue");
+		assertTrue(resolver.isMultipart(originalRequest));
+		MultipartHttpServletRequest request = resolver.resolveMultipart(originalRequest);
+
+		Set parameterNames = new HashSet();
+		Enumeration parameterEnum = request.getParameterNames();
+		while (parameterEnum.hasMoreElements()) {
+			parameterNames.add(parameterEnum.nextElement());
+		}
+		assertEquals(3, parameterNames.size());
+		assertTrue(parameterNames.contains("field3"));
+		assertTrue(parameterNames.contains("field4"));
+		assertTrue(parameterNames.contains("getField"));
+		assertEquals("value3", request.getParameter("field3"));
+		List parameterValues = Arrays.asList(request.getParameterValues("field3"));
+		assertEquals(1, parameterValues.size());
+		assertTrue(parameterValues.contains("value3"));
+		assertEquals("value4", request.getParameter("field4"));
+		parameterValues = Arrays.asList(request.getParameterValues("field4"));
+		assertEquals(2, parameterValues.size());
+		assertTrue(parameterValues.contains("value4"));
+		assertTrue(parameterValues.contains("value5"));
+		assertEquals("value4", request.getParameter("field4"));
+		assertEquals("getValue", request.getParameter("getField"));
+
+		List parameterMapKeys = new ArrayList();
+		List parameterMapValues = new ArrayList();
+		for (Iterator parameterMapIter = request.getParameterMap().keySet().iterator(); parameterMapIter.hasNext();) {
+			String key = (String) parameterMapIter.next();
+			parameterMapKeys.add(key);
+			parameterMapValues.add(request.getParameterMap().get(key));
+		}
+		assertEquals(3, parameterMapKeys.size());
+		assertEquals(3, parameterMapValues.size());
+		int field3Index = parameterMapKeys.indexOf("field3");
+		int field4Index = parameterMapKeys.indexOf("field4");
+		int getFieldIndex = parameterMapKeys.indexOf("getField");
+		assertTrue(field3Index != -1);
+		assertTrue(field4Index != -1);
+		assertTrue(getFieldIndex != -1);
+		parameterValues = Arrays.asList((String[]) parameterMapValues.get(field3Index));
+		assertEquals(1, parameterValues.size());
+		assertTrue(parameterValues.contains("value3"));
+		parameterValues = Arrays.asList((String[]) parameterMapValues.get(field4Index));
+		assertEquals(2, parameterValues.size());
+		assertTrue(parameterValues.contains("value4"));
+		assertTrue(parameterValues.contains("value5"));
+		parameterValues = Arrays.asList((String[]) parameterMapValues.get(getFieldIndex));
+		assertEquals(1, parameterValues.size());
+		assertTrue(parameterValues.contains("getValue"));
+
+		Set fileNames = new HashSet();
+		Iterator fileIter = request.getFileNames();
+		while (fileIter.hasNext()) {
+			fileNames.add(fileIter.next());
+		}
+		assertEquals(3, fileNames.size());
+		assertTrue(fileNames.contains("field1"));
+		assertTrue(fileNames.contains("field2"));
+		assertTrue(fileNames.contains("field2x"));
+		CommonsMultipartFile file1 = (CommonsMultipartFile) request.getFile("field1");
+		CommonsMultipartFile file2 = (CommonsMultipartFile) request.getFile("field2");
+		CommonsMultipartFile file2x = (CommonsMultipartFile) request.getFile("field2x");
+		Map fileMap = request.getFileMap();
+		assertEquals(3, fileMap.size());
+		assertTrue(fileMap.containsKey("field1"));
+		assertTrue(fileMap.containsKey("field2"));
+		assertTrue(fileMap.containsKey("field2x"));
+		assertEquals(file1, fileMap.get("field1"));
+		assertEquals(file2, fileMap.get("field2"));
+		assertEquals(file2x, fileMap.get("field2x"));
+
+		assertEquals("type1", file1.getContentType());
+		assertEquals("type2", file2.getContentType());
+		assertEquals("type2", file2x.getContentType());
+		assertEquals("field1.txt", file1.getOriginalFilename());
+		assertEquals("field2.txt", file2.getOriginalFilename());
+		assertEquals("field2x.txt", file2x.getOriginalFilename());
+		assertEquals("text1", new String(file1.getBytes()));
+		assertEquals("text2", new String(file2.getBytes()));
+		assertEquals(5, file1.getSize());
+		assertEquals(5, file2.getSize());
+		assertTrue(file1.getInputStream() instanceof ByteArrayInputStream);
+		assertTrue(file2.getInputStream() instanceof ByteArrayInputStream);
+		File transfer1 = new File("C:/transfer1");
+		File transfer2 = new File("C:/transfer2");
+		file1.transferTo(transfer1);
+		file2.transferTo(transfer2);
+		assertEquals(transfer1, ((MockFileItem) file1.getFileItem()).writtenFile);
+		assertEquals(transfer2, ((MockFileItem) file2.getFileItem()).writtenFile);
+
+		MultipartTestBean1 mtb1 = new MultipartTestBean1();
+		assertEquals(null, mtb1.getField1());
+		assertEquals(null, mtb1.getField2());
+		ServletRequestDataBinder binder = new ServletRequestDataBinder(mtb1, "mybean");
+		binder.registerCustomEditor(byte[].class, new ByteArrayMultipartFileEditor());
+		binder.bind(request);
+		assertEquals(file1, mtb1.getField1());
+		assertEquals(new String(file2.getBytes()), new String(mtb1.getField2()));
+
+		MultipartTestBean2 mtb2 = new MultipartTestBean2();
+		assertEquals(null, mtb2.getField1());
+		assertEquals(null, mtb2.getField2());
+		binder = new ServletRequestDataBinder(mtb2, "mybean");
+		binder.registerCustomEditor(String.class, "field1", new StringMultipartFileEditor());
+		binder.registerCustomEditor(String.class, "field2", new StringMultipartFileEditor("UTF-16"));
+		binder.bind(request);
+		assertEquals(new String(file1.getBytes()), mtb2.getField1());
+		assertEquals(new String(file2.getBytes(), "UTF-16"), mtb2.getField2());
+
+		resolver.cleanupMultipart(request);
+		assertTrue(((MockFileItem) file1.getFileItem()).deleted);
+		assertTrue(((MockFileItem) file2.getFileItem()).deleted);
+
+		resolver.setEmpty(true);
+		request = resolver.resolveMultipart(originalRequest);
+		binder.setBindEmptyMultipartFiles(false);
+		String firstBound = mtb2.getField1();
+		binder.bind(request);
+		assertTrue(mtb2.getField1().length() > 0);
+		assertEquals(firstBound, mtb2.getField1());
+
+		request = resolver.resolveMultipart(originalRequest);
+		binder.setBindEmptyMultipartFiles(true);
+		binder.bind(request);
+		assertTrue(mtb2.getField1().length() == 0);
+	}
+
+	public void testWithServletContextAndFilter() throws Exception {
+		StaticWebApplicationContext wac = new StaticWebApplicationContext();
+		wac.setServletContext(new MockServletContext());
+		wac.registerSingleton("filterMultipartResolver", MockCommonsMultipartResolver.class, new MutablePropertyValues());
+		wac.getServletContext().setAttribute(WebUtils.TEMP_DIR_CONTEXT_ATTRIBUTE, new File("mytemp"));
+		wac.refresh();
+		wac.getServletContext().setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, wac);
+		CommonsMultipartResolver resolver = new CommonsMultipartResolver(wac.getServletContext());
+		assertTrue(resolver.getFileItemFactory().getRepository().getAbsolutePath().endsWith("mytemp"));
+
+		MockFilterConfig filterConfig = new MockFilterConfig(wac.getServletContext(), "filter");
+		filterConfig.addInitParameter("class", "notWritable");
+		filterConfig.addInitParameter("unknownParam", "someValue");
+		final MultipartFilter filter = new MultipartFilter();
+		filter.init(filterConfig);
+
+		final List files = new ArrayList();
+		final FilterChain filterChain = new FilterChain() {
+			public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse) {
+				MultipartHttpServletRequest request = (MultipartHttpServletRequest) servletRequest;
+				files.addAll(request.getFileMap().values());
+			}
+		};
+
+		FilterChain filterChain2 = new PassThroughFilterChain(filter, filterChain);
+
+		MockHttpServletRequest originalRequest = new MockHttpServletRequest();
+		MockHttpServletResponse response = new MockHttpServletResponse();
+		originalRequest.setMethod("POST");
+		originalRequest.setContentType("multipart/form-data");
+		originalRequest.addHeader("Content-type", "multipart/form-data");
+		filter.doFilter(originalRequest, response, filterChain2);
+
+		CommonsMultipartFile file1 = (CommonsMultipartFile) files.get(0);
+		CommonsMultipartFile file2 = (CommonsMultipartFile) files.get(1);
+		assertTrue(((MockFileItem) file1.getFileItem()).deleted);
+		assertTrue(((MockFileItem) file2.getFileItem()).deleted);
+	}
+
+	public void testWithServletContextAndFilterWithCustomBeanName() throws Exception {
+		StaticWebApplicationContext wac = new StaticWebApplicationContext();
+		wac.setServletContext(new MockServletContext());
+		wac.refresh();
+		wac.registerSingleton("myMultipartResolver", MockCommonsMultipartResolver.class, new MutablePropertyValues());
+		wac.getServletContext().setAttribute(WebUtils.TEMP_DIR_CONTEXT_ATTRIBUTE, new File("mytemp"));
+		wac.getServletContext().setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, wac);
+		CommonsMultipartResolver resolver = new CommonsMultipartResolver(wac.getServletContext());
+		assertTrue(resolver.getFileItemFactory().getRepository().getAbsolutePath().endsWith("mytemp"));
+
+		MockFilterConfig filterConfig = new MockFilterConfig(wac.getServletContext(), "filter");
+		filterConfig.addInitParameter("multipartResolverBeanName", "myMultipartResolver");
+
+		final List files = new ArrayList();
+		FilterChain filterChain = new FilterChain() {
+			public void doFilter(ServletRequest originalRequest, ServletResponse response) {
+				if (originalRequest instanceof MultipartHttpServletRequest) {
+					MultipartHttpServletRequest request = (MultipartHttpServletRequest) originalRequest;
+					files.addAll(request.getFileMap().values());
+				}
+			}
+		};
+
+		MultipartFilter filter = new MultipartFilter() {
+			private boolean invoked = false;
+			protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
+					FilterChain filterChain) throws ServletException, IOException {
+				super.doFilterInternal(request, response, filterChain);
+				super.doFilterInternal(request, response, filterChain);
+				if (invoked) {
+					throw new ServletException("Should not have been invoked twice");
+				}
+				invoked = true;
+			}
+		};
+		filter.init(filterConfig);
+
+		MockHttpServletRequest originalRequest = new MockHttpServletRequest();
+		originalRequest.setMethod("POST");
+		originalRequest.setContentType("multipart/form-data");
+		originalRequest.addHeader("Content-type", "multipart/form-data");
+		HttpServletResponse response = new MockHttpServletResponse();
+		filter.doFilter(originalRequest, response, filterChain);
+		CommonsMultipartFile file1 = (CommonsMultipartFile) files.get(0);
+		CommonsMultipartFile file2 = (CommonsMultipartFile) files.get(1);
+		assertTrue(((MockFileItem) file1.getFileItem()).deleted);
+		assertTrue(((MockFileItem) file2.getFileItem()).deleted);
+	}
+
+
+	public static class MockCommonsMultipartResolver extends CommonsMultipartResolver {
+
+		private boolean empty;
+
+		protected void setEmpty(boolean empty) {
+			this.empty = empty;
+		}
+
+		protected FileUpload newFileUpload(FileItemFactory fileItemFactory) {
+			return new ServletFileUpload() {
+				public List parseRequest(HttpServletRequest request) {
+					if (request instanceof MultipartHttpServletRequest) {
+						throw new IllegalStateException("Already a multipart request");
+					}
+					List fileItems = new ArrayList();
+					MockFileItem fileItem1 = new MockFileItem(
+					    "field1", "type1", empty ? "" : "field1.txt", empty ? "" : "text1");
+					MockFileItem fileItem2 = new MockFileItem(
+					    "field2", "type2", empty ? "" : "C:/field2.txt", empty ? "" : "text2");
+					MockFileItem fileItem2x = new MockFileItem(
+					    "field2x", "type2", empty ? "" : "C:\\field2x.txt", empty ? "" : "text2");
+					MockFileItem fileItem3 = new MockFileItem("field3", null, null, "value3");
+					MockFileItem fileItem4 = new MockFileItem("field4", null, null, "value4");
+					MockFileItem fileItem5 = new MockFileItem("field4", null, null, "value5");
+					fileItems.add(fileItem1);
+					fileItems.add(fileItem2);
+					fileItems.add(fileItem2x);
+					fileItems.add(fileItem3);
+					fileItems.add(fileItem4);
+					fileItems.add(fileItem5);
+					return fileItems;
+				}
+			};
+		}
+	}
+
+
+	private static class MockFileItem implements FileItem {
+
+		private String fieldName;
+		private String contentType;
+		private String name;
+		private String value;
+
+		private File writtenFile;
+		private boolean deleted;
+
+		public MockFileItem(String fieldName, String contentType, String name, String value) {
+			this.fieldName = fieldName;
+			this.contentType = contentType;
+			this.name = name;
+			this.value = value;
+		}
+
+		public InputStream getInputStream() throws IOException {
+			return new ByteArrayInputStream(value.getBytes());
+		}
+
+		public String getContentType() {
+			return contentType;
+		}
+
+		public String getName() {
+			return name;
+		}
+
+		public boolean isInMemory() {
+			return true;
+		}
+
+		public long getSize() {
+			return value.length();
+		}
+
+		public byte[] get() {
+			return value.getBytes();
+		}
+
+		public String getString(String encoding) throws UnsupportedEncodingException {
+			return new String(get(), encoding);
+		}
+
+		public String getString() {
+			return value;
+		}
+
+		public void write(File file) throws Exception {
+			this.writtenFile = file;
+		}
+
+		public File getWrittenFile() {
+			return writtenFile;
+		}
+
+		public void delete() {
+			this.deleted = true;
+		}
+
+		public boolean isDeleted() {
+			return deleted;
+		}
+
+		public String getFieldName() {
+			return fieldName;
+		}
+
+		public void setFieldName(String s) {
+			this.fieldName = s;
+		}
+
+		public boolean isFormField() {
+			return (this.name == null);
+		}
+
+		public void setFormField(boolean b) {
+			throw new UnsupportedOperationException();
+		}
+
+		public OutputStream getOutputStream() throws IOException {
+			throw new UnsupportedOperationException();
+		}
+	}
+
+
+	public class MultipartTestBean1 {
+
+		private MultipartFile field1;
+		private byte[] field2;
+
+		public void setField1(MultipartFile field1) {
+			this.field1 = field1;
+		}
+
+		public MultipartFile getField1() {
+			return field1;
+		}
+
+		public void setField2(byte[] field2) {
+			this.field2 = field2;
+		}
+
+		public byte[] getField2() {
+			return field2;
+		}
+	}
+
+
+	public class MultipartTestBean2 {
+
+		private String field1;
+		private String field2;
+
+		public void setField1(String field1) {
+			this.field1 = field1;
+		}
+
+		public String getField1() {
+			return field1;
+		}
+
+		public void setField2(String field2) {
+			this.field2 = field2;
+		}
+
+		public String getField2() {
+			return field2;
+		}
+	}
+
+}