M1 cut of environment, profiles and property work (SPR-7508)

Decomposed Environment interface into PropertySources, PropertyResolver
objects

    Environment interface and implementations are still present, but
    simpler.

    PropertySources container aggregates PropertySource objects;
    PropertyResolver provides search, conversion, placeholder
    replacement. Single implementation for now is
    PropertySourcesPlaceholderResolver

Renamed EnvironmentAwarePropertyPlaceholderConfigurer to
PropertySourcesPlaceholderConfigurer

    <context:property-placeholder/> now registers PSPC by default, else
    PPC if systemPropertiesMode* settings are involved

Refined configuration and behavior of default profiles

    See Environment interface Javadoc for details

Added Portlet implementations of relevant interfaces:

    * DefaultPortletEnvironment
    * PortletConfigPropertySource, PortletContextPropertySource
    * Integrated each appropriately throughout Portlet app contexts

Added protected 'createEnvironment()' method to AbstractApplicationContext

    Subclasses can override at will to supply a custom Environment
    implementation.  In practice throughout the framework, this is how
    Web- and Portlet-related ApplicationContexts override use of the
    DefaultEnvironment and swap in DefaultWebEnvironment or
    DefaultPortletEnvironment as appropriate.

Introduced "stub-and-replace" behavior for Servlet- and Portlet-based
PropertySource implementations

    Allows for early registration and ordering of the stub, then
    replacement with actual backing object at refresh() time.

    Added AbstractApplicationContext.initPropertySources() method to
    support stub-and-replace behavior. Called from within existing
    prepareRefresh() method so as to avoid impact with
    ApplicationContext implementations that copy and modify AAC's
    refresh() method (e.g.: Spring DM).

    Added methods to WebApplicationContextUtils and
    PortletApplicationContextUtils to support stub-and-replace behavior

Added comprehensive Javadoc for all new or modified types and members

Added XSD documentation for all new or modified elements and attributes

    Including nested <beans>, <beans profile="..."/>, and changes for
    certain attributes type from xsd:IDREF to xsd:string

Improved fix for detecting non-file based Resources in
PropertiesLoaderSupport (SPR-7547, SPR-7552)

    Technically unrelated to environment work, but grouped in with
    this changeset for convenience.

Deprecated (removed) context:property-placeholder
'system-properties-mode' attribute from spring-context-3.1.xsd

    Functionality is preserved for those using schemas up to and including
    spring-context-3.0.  For 3.1, system-properties-mode is no longer
    supported as it conflicts with the idea of managing a set of property
    sources within the context's Environment object. See Javadoc in
    PropertyPlaceholderConfigurer, AbstractPropertyPlaceholderConfigurer
    and PropertySourcesPlaceholderConfigurer for details.

Introduced CollectionUtils.toArray(Enumeration<E>, A[])

Work items remaining for 3.1 M2:

    Consider repackaging PropertySource* types; eliminate internal use
    of SystemPropertyUtils and deprecate

    Further work on composition of Environment interface; consider
    repurposing existing PlaceholderResolver interface to obviate need
    for resolve[Required]Placeholder() methods currently in Environment.

    Ensure configurability of placeholder prefix, suffix, and value
    separator when working against an AbstractPropertyResolver

    Add JNDI-based Environment / PropertySource implementatinos

    Consider support for @Profile at the @Bean level

    Provide consistent logging for the entire property resolution
    lifecycle; consider issuing all such messages against a dedicated
    logger with a single category.

    Add reference documentation to cover the featureset.

org.springframework.core/src/test/java/org/springframework/core/env/DefaultEnvironmentTests.java

@@ -16,412 +16,22 @@
 
 package org.springframework.core.env;
 
-import java.lang.reflect.Field;
-import java.security.AccessControlException;
-import java.security.Permission;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.Map;
-import java.util.Properties;
-import java.util.Set;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.util.List;
 
-import org.hamcrest.Description;
-import org.hamcrest.Matcher;
-import org.junit.Before;
 import org.junit.Test;
-import org.junit.internal.matchers.TypeSafeMatcher;
 
-import static java.lang.String.format;
-import static org.hamcrest.CoreMatchers.*;
-import static org.junit.Assert.*;
-import static org.junit.matchers.JUnitMatchers.*;
-import static org.springframework.core.env.AbstractEnvironment.*;
-import static org.springframework.core.env.DefaultEnvironmentTests.CollectionMatchers.*;
-
-/**
- * Unit tests for {@link DefaultEnvironment}.
- *
- * @author Chris Beams
- */
 public class DefaultEnvironmentTests {
 
-	private static final String ALLOWED_PROPERTY_NAME = "theanswer";
-	private static final String ALLOWED_PROPERTY_VALUE = "42";
-
-	private static final String DISALLOWED_PROPERTY_NAME = "verboten";
-	private static final String DISALLOWED_PROPERTY_VALUE = "secret";
-
-	private static final String STRING_PROPERTY_NAME = "stringPropName";
-	private static final String STRING_PROPERTY_VALUE = "stringPropValue";
-	private static final Object NON_STRING_PROPERTY_NAME = new Object();
-	private static final Object NON_STRING_PROPERTY_VALUE = new Object();
-
-	private ConfigurableEnvironment environment;
-	private Properties testProperties;
-
-	@Before
-	public void setUp() {
-		environment = new DefaultEnvironment();
-		testProperties = new Properties();
-		environment.addPropertySource("testProperties", testProperties);
-	}
-
-	@Test @SuppressWarnings({ "unchecked", "rawtypes", "serial" })
-	public void getPropertySources_manipulatePropertySourceOrder() {
-		AbstractEnvironment env = new AbstractEnvironment() { };
-		env.addPropertySource("system", new HashMap() {{ put("foo", "systemValue"); }});
-		env.addPropertySource("local", new HashMap() {{ put("foo", "localValue"); }});
-
-		// 'local' was added (pushed) last so has precedence
-		assertThat(env.getProperty("foo"), equalTo("localValue"));
-
-		// put 'system' at the front of the list
-		LinkedList<PropertySource<?>> propertySources = env.getPropertySources();
-		propertySources.addFirst(propertySources.remove(propertySources.indexOf(PropertySource.named("system"))));
-
-		// 'system' now has precedence
-		assertThat(env.getProperty("foo"), equalTo("systemValue"));
-
-		assertThat(propertySources.size(), is(2));
-	}
-
-	@Test @SuppressWarnings({ "unchecked", "rawtypes", "serial" })
-	public void getPropertySources_replacePropertySource() {
-		AbstractEnvironment env = new AbstractEnvironment() { };
-		env.addPropertySource("system", new HashMap() {{ put("foo", "systemValue"); }});
-		env.addPropertySource("local", new HashMap() {{ put("foo", "localValue"); }});
-
-		// 'local' was added (pushed) last so has precedence
-		assertThat(env.getProperty("foo"), equalTo("localValue"));
-
-		// replace 'local' with new property source
-		LinkedList<PropertySource<?>> propertySources = env.getPropertySources();
-		int localIndex = propertySources.indexOf(PropertySource.named("local"));
-		MapPropertySource newSource = new MapPropertySource("new", new HashMap() {{ put("foo", "newValue"); }});
-		propertySources.set(localIndex, newSource);
-
-		// 'system' now has precedence
-		assertThat(env.getProperty("foo"), equalTo("newValue"));
-
-		assertThat(propertySources.size(), is(2));
-	}
-
 	@Test
-	public void getProperty() {
-		assertThat(environment.getProperty("foo"), nullValue());
-		testProperties.put("foo", "bar");
-		assertThat(environment.getProperty("foo"), is("bar"));
-	}
-
-	@Test
-	public void getProperty_withExplicitNullValue() {
-		// java.util.Properties does not allow null values (because Hashtable does not)
-		Map<String, String> nullableProperties = new HashMap<String, String>();
-		environment.addPropertySource("nullableProperties", nullableProperties);
-		nullableProperties.put("foo", null);
-		assertThat(environment.getProperty("foo"), nullValue());
-	}
-
-	@Test
-	public void getProperty_withStringArrayConversion() {
-		testProperties.put("foo", "bar,baz");
-		assertThat(environment.getProperty("foo", String[].class), equalTo(new String[] { "bar", "baz" }));
-	}
-
-	@Test
-	public void getProperty_withNonConvertibleTargetType() {
-		testProperties.put("foo", "bar");
-
-		class TestType { }
-
-		try {
-			environment.getProperty("foo", TestType.class);
-			fail("Expected IllegalArgumentException due to non-convertible types");
-		} catch (IllegalArgumentException ex) {
-			// expected
-		}
-	}
-
-	@Test
-	public void getRequiredProperty() {
-		testProperties.put("exists", "xyz");
-		assertThat(environment.getRequiredProperty("exists"), is("xyz"));
-
-		try {
-			environment.getRequiredProperty("bogus");
-			fail("expected IllegalArgumentException");
-		} catch (IllegalArgumentException ex) {
-			// expected
-		}
-	}
-
-	@Test
-	public void getRequiredProperty_withStringArrayConversion() {
-		testProperties.put("exists", "abc,123");
-		assertThat(environment.getRequiredProperty("exists", String[].class), equalTo(new String[] { "abc", "123" }));
-
-		try {
-			environment.getRequiredProperty("bogus", String[].class);
-			fail("expected IllegalArgumentException");
-		} catch (IllegalArgumentException ex) {
-			// expected
-		}
-	}
-
-	@Test @SuppressWarnings({ "rawtypes", "serial", "unchecked" })
-	public void asProperties() {
-		ConfigurableEnvironment env = new AbstractEnvironment() { };
-		assertThat(env.asProperties(), notNullValue());
-
-		env.addPropertySource("lowestPrecedence", new HashMap() {{ put("common", "lowCommon"); put("lowKey", "lowVal"); }});
-		env.addPropertySource("middlePrecedence", new HashMap() {{ put("common", "midCommon"); put("midKey", "midVal"); }});
-		env.addPropertySource("highestPrecedence", new HashMap() {{ put("common", "highCommon"); put("highKey", "highVal"); }});
-
-		Properties props = env.asProperties();
-		assertThat(props.getProperty("common"), is("highCommon"));
-		assertThat(props.getProperty("lowKey"), is("lowVal"));
-		assertThat(props.getProperty("midKey"), is("midVal"));
-		assertThat(props.getProperty("highKey"), is("highVal"));
-		assertThat(props.size(), is(4));
-	}
-
-	@Test
-	public void activeProfiles() {
-		assertThat(environment.getActiveProfiles(), isEmpty());
-		environment.setActiveProfiles("local", "embedded");
-		Set<String> activeProfiles = environment.getActiveProfiles();
-		assertThat(activeProfiles, hasItems("local", "embedded"));
-		assertThat(activeProfiles.size(), is(2));
-		try {
-			environment.getActiveProfiles().add("bogus");
-			fail("activeProfiles should be unmodifiable");
-		} catch (UnsupportedOperationException ex) {
-			// expected
-		}
-		environment.setActiveProfiles("foo");
-		assertThat(activeProfiles, hasItem("foo"));
-		assertThat(environment.getActiveProfiles().size(), is(1));
-	}
-
-	@Test
-	public void systemPropertiesEmpty() {
-		assertThat(environment.getActiveProfiles(), isEmpty());
-
-		System.setProperty(ACTIVE_PROFILES_PROPERTY_NAME, "");
-		assertThat(environment.getActiveProfiles(), isEmpty());
-
-		System.getProperties().remove(ACTIVE_PROFILES_PROPERTY_NAME);
-	}
-
-	@Test
-	public void systemPropertiesResoloutionOfProfiles() {
-		assertThat(environment.getActiveProfiles(), isEmpty());
-
-		System.setProperty(ACTIVE_PROFILES_PROPERTY_NAME, "foo");
-		assertThat(environment.getActiveProfiles(), hasItem("foo"));
-
-		// clean up
-		System.getProperties().remove(ACTIVE_PROFILES_PROPERTY_NAME);
-	}
-
-	@Test
-	public void systemPropertiesResoloutionOfMultipleProfiles() {
-		assertThat(environment.getActiveProfiles(), isEmpty());
-		System.setProperty(ACTIVE_PROFILES_PROPERTY_NAME, "foo,bar");
-		assertThat(environment.getActiveProfiles(), hasItems("foo", "bar"));
-		System.getProperties().remove(ACTIVE_PROFILES_PROPERTY_NAME);
-	}
-
-	@Test
-	public void systemPropertiesResolutionOfMulitpleProfiles_withWhitespace() {
-		assertThat(environment.getActiveProfiles(), isEmpty());
-		System.setProperty(ACTIVE_PROFILES_PROPERTY_NAME, " bar , baz "); // notice whitespace
-		assertThat(environment.getActiveProfiles(), hasItems("bar", "baz"));
-		System.getProperties().remove(ACTIVE_PROFILES_PROPERTY_NAME);
-	}
-
-	@Test
-	public void environmentResolutionOfDefaultSpringProfileProperty_noneSet() {
-		assertThat(environment.getDefaultProfiles(), isEmpty());
-	}
-
-	@Test
-	public void environmentResolutionOfDefaultSpringProfileProperty_isSet() {
-		testProperties.setProperty(DEFAULT_PROFILES_PROPERTY_NAME, "custom-default");
-		assertTrue(environment.getDefaultProfiles().contains("custom-default"));
-	}
-
-	@Test
-	public void systemPropertiesAccess() {
-		System.setProperty(ALLOWED_PROPERTY_NAME, ALLOWED_PROPERTY_VALUE);
-		System.setProperty(DISALLOWED_PROPERTY_NAME, DISALLOWED_PROPERTY_VALUE);
-		System.getProperties().put(STRING_PROPERTY_NAME, NON_STRING_PROPERTY_VALUE);
-		System.getProperties().put(NON_STRING_PROPERTY_NAME, STRING_PROPERTY_VALUE);
-
-		{
-			Map<?, ?> systemProperties = environment.getSystemProperties();
-			assertThat(systemProperties, notNullValue());
-			assertSame(systemProperties, System.getProperties());
-			assertThat(systemProperties.get(ALLOWED_PROPERTY_NAME), equalTo((Object)ALLOWED_PROPERTY_VALUE));
-			assertThat(systemProperties.get(DISALLOWED_PROPERTY_NAME), equalTo((Object)DISALLOWED_PROPERTY_VALUE));
-
-			// non-string keys and values work fine... until the security manager is introduced below
-			assertThat(systemProperties.get(STRING_PROPERTY_NAME), equalTo(NON_STRING_PROPERTY_VALUE));
-			assertThat(systemProperties.get(NON_STRING_PROPERTY_NAME), equalTo((Object)STRING_PROPERTY_VALUE));
-		}
-
-		SecurityManager oldSecurityManager = System.getSecurityManager();
-		SecurityManager securityManager = new SecurityManager() {
-			@Override
-			public void checkPropertiesAccess() {
-				// see http://download.oracle.com/javase/1.5.0/docs/api/java/lang/System.html#getProperties()
-				throw new AccessControlException("Accessing the system properties is disallowed");
-			}
-			@Override
-			public void checkPropertyAccess(String key) {
-				// see http://download.oracle.com/javase/1.5.0/docs/api/java/lang/System.html#getProperty(java.lang.String)
-				if (DISALLOWED_PROPERTY_NAME.equals(key)) {
-					throw new AccessControlException(
-							format("Accessing the system property [%s] is disallowed", DISALLOWED_PROPERTY_NAME));
-				}
-			}
-			@Override
-			public void checkPermission(Permission perm) {
-				// allow everything else
-			}
-		};
-		System.setSecurityManager(securityManager);
-
-		{
-			Map<?, ?> systemProperties = environment.getSystemProperties();
-			assertThat(systemProperties, notNullValue());
-			assertThat(systemProperties, instanceOf(ReadOnlySystemAttributesMap.class));
-			assertThat((String)systemProperties.get(ALLOWED_PROPERTY_NAME), equalTo(ALLOWED_PROPERTY_VALUE));
-			assertThat(systemProperties.get(DISALLOWED_PROPERTY_NAME), equalTo(null));
-
-			// nothing we can do here in terms of warning the user that there was
-			// actually a (non-string) value available. By this point, we only
-			// have access to calling System.getProperty(), which itself returns null
-			// if the value is non-string.  So we're stuck with returning a potentially
-			// misleading null.
-			assertThat(systemProperties.get(STRING_PROPERTY_NAME), nullValue());
-
-			// in the case of a non-string *key*, however, we can do better.  Alert
-			// the user that under these very special conditions (non-object key +
-			// SecurityManager that disallows access to system properties), they
-			// cannot do what they're attempting.
-			try {
-				systemProperties.get(NON_STRING_PROPERTY_NAME);
-				fail("Expected IllegalStateException when searching with non-string key against ReadOnlySystemAttributesMap");
-			} catch (IllegalStateException ex) {
-				// expected
-			}
-		}
-
-		System.setSecurityManager(oldSecurityManager);
-		System.clearProperty(ALLOWED_PROPERTY_NAME);
-		System.clearProperty(DISALLOWED_PROPERTY_NAME);
-		System.getProperties().remove(STRING_PROPERTY_NAME);
-		System.getProperties().remove(NON_STRING_PROPERTY_NAME);
-	}
-
-	@Test
-	public void systemEnvironmentAccess() throws Exception {
-		getModifiableSystemEnvironment().put(ALLOWED_PROPERTY_NAME, ALLOWED_PROPERTY_VALUE);
-		getModifiableSystemEnvironment().put(DISALLOWED_PROPERTY_NAME, DISALLOWED_PROPERTY_VALUE);
-
-		{
-			Map<String, String> systemEnvironment = environment.getSystemEnvironment();
-			assertThat(systemEnvironment, notNullValue());
-			assertSame(systemEnvironment, System.getenv());
-		}
-
-		SecurityManager oldSecurityManager = System.getSecurityManager();
-		SecurityManager securityManager = new SecurityManager() {
-			@Override
-			public void checkPermission(Permission perm) {
-				//see http://download.oracle.com/javase/1.5.0/docs/api/java/lang/System.html#getenv()
-				if ("getenv.*".equals(perm.getName())) {
-					throw new AccessControlException("Accessing the system environment is disallowed");
-				}
-				//see http://download.oracle.com/javase/1.5.0/docs/api/java/lang/System.html#getenv(java.lang.String)
-				if (("getenv."+DISALLOWED_PROPERTY_NAME).equals(perm.getName())) {
-					throw new AccessControlException(
-							format("Accessing the system environment variable [%s] is disallowed", DISALLOWED_PROPERTY_NAME));
-				}
-			}
-		};
-		System.setSecurityManager(securityManager);
-
-		{
-			Map<String, String> systemEnvironment = environment.getSystemEnvironment();
-			assertThat(systemEnvironment, notNullValue());
-			assertThat(systemEnvironment, instanceOf(ReadOnlySystemAttributesMap.class));
-			assertThat(systemEnvironment.get(ALLOWED_PROPERTY_NAME), equalTo(ALLOWED_PROPERTY_VALUE));
-			assertThat(systemEnvironment.get(DISALLOWED_PROPERTY_NAME), nullValue());
-		}
-
-		System.setSecurityManager(oldSecurityManager);
-		getModifiableSystemEnvironment().remove(ALLOWED_PROPERTY_NAME);
-		getModifiableSystemEnvironment().remove(DISALLOWED_PROPERTY_NAME);
-	}
-
-	@Test
-	public void resolvePlaceholders() {
-		AbstractEnvironment env = new AbstractEnvironment() { };
-		Properties testProperties = new Properties();
-		testProperties.setProperty("foo", "bar");
-		env.addPropertySource("testProperties", testProperties);
-		String resolved = env.resolvePlaceholders("pre-${foo}-${unresolvable}-post");
-		assertThat(resolved, is("pre-bar-${unresolvable}-post"));
-	}
-
-	@Test
-	public void resolveRequiredPlaceholders() {
-		AbstractEnvironment env = new AbstractEnvironment() { };
-		Properties testProperties = new Properties();
-		testProperties.setProperty("foo", "bar");
-		env.addPropertySource("testProperties", testProperties);
-		try {
-			env.resolveRequiredPlaceholders("pre-${foo}-${unresolvable}-post");
-			fail("expected exception");
-		} catch (IllegalArgumentException ex) {
-			assertThat(ex.getMessage(), is("Could not resolve placeholder 'unresolvable'"));
-		}
-	}
-
-	public static class CollectionMatchers {
-		public static Matcher<Collection<?>> isEmpty() {
-
-			return new TypeSafeMatcher<Collection<?>>() {
-
-				@Override
-				public boolean matchesSafely(Collection<?> collection) {
-					return collection.isEmpty();
-				}
-
-				public void describeTo(Description desc) {
-					desc.appendText("an empty collection");
-				}
-			};
-		}
-	}
-
-	// TODO SPR-7508: duplicated from EnvironmentPropertyResolutionSearchTests
-	@SuppressWarnings("unchecked")
-	private static Map<String, String> getModifiableSystemEnvironment() throws Exception {
-		Class<?>[] classes = Collections.class.getDeclaredClasses();
-		Map<String, String> systemEnv = System.getenv();
-		for (Class<?> cl : classes) {
-			if ("java.util.Collections$UnmodifiableMap".equals(cl.getName())) {
-				Field field = cl.getDeclaredField("m");
-				field.setAccessible(true);
-				Object obj = field.get(systemEnv);
-				return (Map<String, String>) obj;
-			}
-		}
-		throw new IllegalStateException();
+	public void propertySourceOrder() {
+		ConfigurableEnvironment env = new DefaultEnvironment();
+		List<PropertySource<?>> sources = env.getPropertySources().asList();
+		assertThat(sources.size(), is(2));
+		assertThat(sources.get(0).getName(), equalTo(DefaultEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME));
+		assertThat(sources.get(1).getName(), equalTo(DefaultEnvironment.SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME));
 	}
 }

org.springframework.core/src/test/java/org/springframework/core/env/EnvironmentPropertyResolutionLateBindingTests.java

@@ -1,56 +0,0 @@
-/*
- * Copyright 2002-2010 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.core.env;
-
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.junit.Assert.assertThat;
-
-import org.junit.Test;
-
-
-/**
- * Test that  {@link Environment#getValue} performs late-resolution of property
- * values i.e., does not eagerly resolve and cache only at construction time.
- *
- * @see EnvironmentPropertyResolutionSearchTests
- * @author Chris Beams
- * @since 3.1
- */
-public class EnvironmentPropertyResolutionLateBindingTests {
-	@Test
-	public void replaceExistingKeyPostConstruction() {
-		String key = "foo";
-		String value1 = "bar";
-		String value2 = "biz";
-
-		System.setProperty(key, value1); // before construction
-		DefaultEnvironment env = new DefaultEnvironment();
-		assertThat(env.getProperty(key), equalTo(value1));
-		System.setProperty(key, value2); // after construction and first resolution
-		assertThat(env.getProperty(key), equalTo(value2));
-		System.clearProperty(key); // clean up
-	}
-
-	@Test
-	public void addNewKeyPostConstruction() {
-		DefaultEnvironment env = new DefaultEnvironment();
-		assertThat(env.getProperty("foo"), equalTo(null));
-		System.setProperty("foo", "42");
-		assertThat(env.getProperty("foo"), equalTo("42"));
-		System.clearProperty("foo"); // clean up
-	}
-}

org.springframework.core/src/test/java/org/springframework/core/env/EnvironmentPropertyResolutionSearchTests.java

@@ -1,102 +0,0 @@
-/*
- * Copyright 2002-2010 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.core.env;
-
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertThat;
-
-import java.lang.reflect.Field;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Properties;
-
-import org.junit.Test;
-
-/**
- * Unit tests for {@link DefaultEnvironment} proving that it (a) searches
- * standard property sources (b) in the correct order.
- *
- * @see AbstractEnvironment#getProperty(String)
- * @author Chris Beams
- * @since 3.1
- */
-public class EnvironmentPropertyResolutionSearchTests {
-
-	@Test @SuppressWarnings({ "unchecked", "serial", "rawtypes" })
-	public void propertySourcesHaveLIFOSearchOrder() {
-		ConfigurableEnvironment env = new AbstractEnvironment() { };
-		env.addPropertySource("ps1", new HashMap() {{ put("pName", "ps1Value"); }});
-		assertThat(env.getProperty("pName"), equalTo("ps1Value"));
-		env.addPropertySource("ps2", new HashMap() {{ put("pName", "ps2Value"); }});
-		assertThat(env.getProperty("pName"), equalTo("ps2Value"));
-		env.addPropertySource("ps3", new HashMap() {{ put("pName", "ps3Value"); }});
-		assertThat(env.getProperty("pName"), equalTo("ps3Value"));
-	}
-
-	@Test
-	public void resolveFromDefaultPropertySources() throws Exception {
-		String key = "x";
-		String localPropsValue = "local";
-		String sysPropsValue = "sys";
-		String envVarsValue = "env";
-
-		Map<String, String> systemEnvironment = getModifiableSystemEnvironment();
-		Properties systemProperties = System.getProperties();
-		Properties localProperties = new Properties();
-
-		DefaultEnvironment env = new DefaultEnvironment();
-		env.addPropertySource("localProperties", localProperties);
-
-		// set all properties
-		systemEnvironment.put(key, envVarsValue);
-		systemProperties.setProperty(key, sysPropsValue);
-		localProperties.setProperty(key, localPropsValue);
-
-		// local properties should have highest resolution precedence
-		assertThat(env.getProperty(key), equalTo(localPropsValue));
-
-		// system properties should be next in line
-		localProperties.remove(key);
-		assertThat(env.getProperty(key), equalTo(sysPropsValue));
-
-		// system environment variables should be final fallback
-		systemProperties.remove(key);
-		assertThat(env.getProperty(key), equalTo(envVarsValue));
-
-		// with no propertysource containing the key in question, should return null
-		systemEnvironment.remove(key);
-		assertThat(env.getProperty(key), equalTo(null));
-	}
-
-	@SuppressWarnings("unchecked")
-	private static Map<String, String> getModifiableSystemEnvironment() throws Exception {
-		Class<?>[] classes = Collections.class.getDeclaredClasses();
-		Map<String, String> env = System.getenv();
-		for (Class<?> cl : classes) {
-			if ("java.util.Collections$UnmodifiableMap".equals(cl.getName())) {
-				Field field = cl.getDeclaredField("m");
-				field.setAccessible(true);
-				Object obj = field.get(env);
-				return (Map<String, String>) obj;
-			}
-		}
-		throw new IllegalStateException();
-	}
-
-}

org.springframework.core/src/test/java/org/springframework/core/env/EnvironmentTests.java

@@ -0,0 +1,288 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.core.env;
+
+import static java.lang.String.format;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.hamcrest.CoreMatchers.nullValue;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+import static org.junit.matchers.JUnitMatchers.hasItem;
+import static org.junit.matchers.JUnitMatchers.hasItems;
+import static org.springframework.core.env.AbstractEnvironment.ACTIVE_PROFILES_PROPERTY_NAME;
+import static org.springframework.core.env.AbstractEnvironment.DEFAULT_PROFILES_PROPERTY_NAME;
+
+import java.lang.reflect.Field;
+import java.security.AccessControlException;
+import java.security.Permission;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Map;
+
+import org.junit.Test;
+import org.springframework.mock.env.MockPropertySource;
+
+
+/**
+ * Unit tests for {@link DefaultEnvironment}.
+ *
+ * @author Chris Beams
+ */
+public class EnvironmentTests {
+
+	private static final String ALLOWED_PROPERTY_NAME = "theanswer";
+	private static final String ALLOWED_PROPERTY_VALUE = "42";
+
+	private static final String DISALLOWED_PROPERTY_NAME = "verboten";
+	private static final String DISALLOWED_PROPERTY_VALUE = "secret";
+
+	private static final String STRING_PROPERTY_NAME = "stringPropName";
+	private static final String STRING_PROPERTY_VALUE = "stringPropValue";
+	private static final Object NON_STRING_PROPERTY_NAME = new Object();
+	private static final Object NON_STRING_PROPERTY_VALUE = new Object();
+
+	private ConfigurableEnvironment environment = new DefaultEnvironment();
+
+	@Test
+	public void activeProfiles() {
+		assertThat(environment.getActiveProfiles().length, is(0));
+		environment.setActiveProfiles("local", "embedded");
+		String[] activeProfiles = environment.getActiveProfiles();
+		assertThat(Arrays.asList(activeProfiles), hasItems("local", "embedded"));
+		assertThat(activeProfiles.length, is(2));
+	}
+
+	@Test
+	public void getActiveProfiles_systemPropertiesEmpty() {
+		assertThat(environment.getActiveProfiles().length, is(0));
+		System.setProperty(ACTIVE_PROFILES_PROPERTY_NAME, "");
+		assertThat(environment.getActiveProfiles().length, is(0));
+		System.getProperties().remove(ACTIVE_PROFILES_PROPERTY_NAME);
+	}
+
+	@Test
+	public void getActiveProfiles_fromSystemProperties() {
+		assertThat(environment.getActiveProfiles().length, is(0));
+		System.setProperty(ACTIVE_PROFILES_PROPERTY_NAME, "foo");
+		assertThat(Arrays.asList(environment.getActiveProfiles()), hasItem("foo"));
+		System.getProperties().remove(ACTIVE_PROFILES_PROPERTY_NAME);
+	}
+
+	@Test
+	public void getActiveProfiles_fromSystemProperties_withMultipleProfiles() {
+		assertThat(environment.getActiveProfiles().length, is(0));
+		System.setProperty(ACTIVE_PROFILES_PROPERTY_NAME, "foo,bar");
+		assertThat(Arrays.asList(environment.getActiveProfiles()), hasItems("foo", "bar"));
+		System.getProperties().remove(ACTIVE_PROFILES_PROPERTY_NAME);
+	}
+
+	@Test
+	public void getActiveProfiles_fromSystemProperties_withMulitpleProfiles_withWhitespace() {
+		assertThat(environment.getActiveProfiles().length, is(0));
+		System.setProperty(ACTIVE_PROFILES_PROPERTY_NAME, " bar , baz "); // notice whitespace
+		assertThat(Arrays.asList(environment.getActiveProfiles()), hasItems("bar", "baz"));
+		System.getProperties().remove(ACTIVE_PROFILES_PROPERTY_NAME);
+	}
+
+	@Test
+	public void getDefaultProfiles() {
+		assertThat(environment.getDefaultProfiles().length, is(0));
+		environment.getPropertySources().addFirst(new MockPropertySource().withProperty(DEFAULT_PROFILES_PROPERTY_NAME, "pd1"));
+		assertThat(environment.getDefaultProfiles().length, is(1));
+		assertThat(Arrays.asList(environment.getDefaultProfiles()), hasItem("pd1"));
+	}
+
+	@Test
+	public void setDefaultProfiles() {
+		environment.setDefaultProfiles();
+		assertThat(environment.getDefaultProfiles().length, is(0));
+		environment.setDefaultProfiles("pd1");
+		assertThat(Arrays.asList(environment.getDefaultProfiles()), hasItem("pd1"));
+		environment.setDefaultProfiles("pd2", "pd3");
+		assertThat(Arrays.asList(environment.getDefaultProfiles()), not(hasItem("pd1")));
+		assertThat(Arrays.asList(environment.getDefaultProfiles()), hasItems("pd2", "pd3"));
+	}
+
+	@Test(expected=IllegalArgumentException.class)
+	public void acceptsProfiles_mustSpecifyAtLeastOne() {
+		environment.acceptsProfiles();
+	}
+
+	@Test
+	public void acceptsProfiles_activeProfileSetProgrammatically() {
+		assertThat(environment.acceptsProfiles("p1", "p2"), is(false));
+		environment.setActiveProfiles("p1");
+		assertThat(environment.acceptsProfiles("p1", "p2"), is(true));
+		environment.setActiveProfiles("p2");
+		assertThat(environment.acceptsProfiles("p1", "p2"), is(true));
+		environment.setActiveProfiles("p1", "p2");
+		assertThat(environment.acceptsProfiles("p1", "p2"), is(true));
+	}
+
+	@Test
+	public void acceptsProfiles_activeProfileSetViaProperty() {
+		assertThat(environment.acceptsProfiles("p1"), is(false));
+		environment.getPropertySources().addFirst(new MockPropertySource().withProperty(ACTIVE_PROFILES_PROPERTY_NAME, "p1"));
+		assertThat(environment.acceptsProfiles("p1"), is(true));
+	}
+
+	@Test
+	public void acceptsProfiles_defaultProfile() {
+		assertThat(environment.acceptsProfiles("pd"), is(false));
+		environment.setDefaultProfiles("pd");
+		assertThat(environment.acceptsProfiles("pd"), is(true));
+		environment.setActiveProfiles("p1");
+		assertThat(environment.acceptsProfiles("pd"), is(false));
+		assertThat(environment.acceptsProfiles("p1"), is(true));
+	}
+
+	@Test
+	public void getSystemProperties_withAndWithoutSecurityManager() {
+		System.setProperty(ALLOWED_PROPERTY_NAME, ALLOWED_PROPERTY_VALUE);
+		System.setProperty(DISALLOWED_PROPERTY_NAME, DISALLOWED_PROPERTY_VALUE);
+		System.getProperties().put(STRING_PROPERTY_NAME, NON_STRING_PROPERTY_VALUE);
+		System.getProperties().put(NON_STRING_PROPERTY_NAME, STRING_PROPERTY_VALUE);
+
+		{
+			Map<?, ?> systemProperties = environment.getSystemProperties();
+			assertThat(systemProperties, notNullValue());
+			assertSame(systemProperties, System.getProperties());
+			assertThat(systemProperties.get(ALLOWED_PROPERTY_NAME), equalTo((Object)ALLOWED_PROPERTY_VALUE));
+			assertThat(systemProperties.get(DISALLOWED_PROPERTY_NAME), equalTo((Object)DISALLOWED_PROPERTY_VALUE));
+
+			// non-string keys and values work fine... until the security manager is introduced below
+			assertThat(systemProperties.get(STRING_PROPERTY_NAME), equalTo(NON_STRING_PROPERTY_VALUE));
+			assertThat(systemProperties.get(NON_STRING_PROPERTY_NAME), equalTo((Object)STRING_PROPERTY_VALUE));
+		}
+
+		SecurityManager oldSecurityManager = System.getSecurityManager();
+		SecurityManager securityManager = new SecurityManager() {
+			@Override
+			public void checkPropertiesAccess() {
+				// see http://download.oracle.com/javase/1.5.0/docs/api/java/lang/System.html#getProperties()
+				throw new AccessControlException("Accessing the system properties is disallowed");
+			}
+			@Override
+			public void checkPropertyAccess(String key) {
+				// see http://download.oracle.com/javase/1.5.0/docs/api/java/lang/System.html#getProperty(java.lang.String)
+				if (DISALLOWED_PROPERTY_NAME.equals(key)) {
+					throw new AccessControlException(
+							format("Accessing the system property [%s] is disallowed", DISALLOWED_PROPERTY_NAME));
+				}
+			}
+			@Override
+			public void checkPermission(Permission perm) {
+				// allow everything else
+			}
+		};
+		System.setSecurityManager(securityManager);
+
+		{
+			Map<?, ?> systemProperties = environment.getSystemProperties();
+			assertThat(systemProperties, notNullValue());
+			assertThat(systemProperties, instanceOf(ReadOnlySystemAttributesMap.class));
+			assertThat((String)systemProperties.get(ALLOWED_PROPERTY_NAME), equalTo(ALLOWED_PROPERTY_VALUE));
+			assertThat(systemProperties.get(DISALLOWED_PROPERTY_NAME), equalTo(null));
+
+			// nothing we can do here in terms of warning the user that there was
+			// actually a (non-string) value available. By this point, we only
+			// have access to calling System.getProperty(), which itself returns null
+			// if the value is non-string.  So we're stuck with returning a potentially
+			// misleading null.
+			assertThat(systemProperties.get(STRING_PROPERTY_NAME), nullValue());
+
+			// in the case of a non-string *key*, however, we can do better.  Alert
+			// the user that under these very special conditions (non-object key +
+			// SecurityManager that disallows access to system properties), they
+			// cannot do what they're attempting.
+			try {
+				systemProperties.get(NON_STRING_PROPERTY_NAME);
+				fail("Expected IllegalArgumentException when searching with non-string key against ReadOnlySystemAttributesMap");
+			} catch (IllegalArgumentException ex) {
+				// expected
+			}
+		}
+
+		System.setSecurityManager(oldSecurityManager);
+		System.clearProperty(ALLOWED_PROPERTY_NAME);
+		System.clearProperty(DISALLOWED_PROPERTY_NAME);
+		System.getProperties().remove(STRING_PROPERTY_NAME);
+		System.getProperties().remove(NON_STRING_PROPERTY_NAME);
+	}
+
+	@Test
+	public void getSystemEnvironment_withAndWithoutSecurityManager() throws Exception {
+		getModifiableSystemEnvironment().put(ALLOWED_PROPERTY_NAME, ALLOWED_PROPERTY_VALUE);
+		getModifiableSystemEnvironment().put(DISALLOWED_PROPERTY_NAME, DISALLOWED_PROPERTY_VALUE);
+
+		{
+			Map<String, String> systemEnvironment = environment.getSystemEnvironment();
+			assertThat(systemEnvironment, notNullValue());
+			assertSame(systemEnvironment, System.getenv());
+		}
+
+		SecurityManager oldSecurityManager = System.getSecurityManager();
+		SecurityManager securityManager = new SecurityManager() {
+			@Override
+			public void checkPermission(Permission perm) {
+				//see http://download.oracle.com/javase/1.5.0/docs/api/java/lang/System.html#getenv()
+				if ("getenv.*".equals(perm.getName())) {
+					throw new AccessControlException("Accessing the system environment is disallowed");
+				}
+				//see http://download.oracle.com/javase/1.5.0/docs/api/java/lang/System.html#getenv(java.lang.String)
+				if (("getenv."+DISALLOWED_PROPERTY_NAME).equals(perm.getName())) {
+					throw new AccessControlException(
+							format("Accessing the system environment variable [%s] is disallowed", DISALLOWED_PROPERTY_NAME));
+				}
+			}
+		};
+		System.setSecurityManager(securityManager);
+
+		{
+			Map<String, String> systemEnvironment = environment.getSystemEnvironment();
+			assertThat(systemEnvironment, notNullValue());
+			assertThat(systemEnvironment, instanceOf(ReadOnlySystemAttributesMap.class));
+			assertThat(systemEnvironment.get(ALLOWED_PROPERTY_NAME), equalTo(ALLOWED_PROPERTY_VALUE));
+			assertThat(systemEnvironment.get(DISALLOWED_PROPERTY_NAME), nullValue());
+		}
+
+		System.setSecurityManager(oldSecurityManager);
+		getModifiableSystemEnvironment().remove(ALLOWED_PROPERTY_NAME);
+		getModifiableSystemEnvironment().remove(DISALLOWED_PROPERTY_NAME);
+	}
+
+	// TODO SPR-7508: duplicated from EnvironmentPropertyResolutionSearchTests
+	@SuppressWarnings("unchecked")
+	private static Map<String, String> getModifiableSystemEnvironment() throws Exception {
+		Class<?>[] classes = Collections.class.getDeclaredClasses();
+		Map<String, String> systemEnv = System.getenv();
+		for (Class<?> cl : classes) {
+			if ("java.util.Collections$UnmodifiableMap".equals(cl.getName())) {
+				Field field = cl.getDeclaredField("m");
+				field.setAccessible(true);
+				Object obj = field.get(systemEnv);
+				return (Map<String, String>) obj;
+			}
+		}
+		throw new IllegalStateException();
+	}
+}

org.springframework.core/src/test/java/org/springframework/core/env/PropertyResolverTests.java

@@ -0,0 +1,282 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.core.env;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.hamcrest.CoreMatchers.nullValue;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.mock.env.MockPropertySource;
+
+
+/**
+ * Unit tests for {@link PropertyResolver}.
+ *
+ * @author Chris Beams
+ * @since 3.1
+ * @see PropertySourcesPropertyResolver
+ */
+public class PropertyResolverTests {
+	private Properties testProperties;
+	private MutablePropertySources propertySources;
+	private ConfigurablePropertyResolver propertyResolver;
+
+	@Before
+	public void setUp() {
+		propertySources = new MutablePropertySources();
+		propertyResolver = new PropertySourcesPropertyResolver(propertySources);
+		testProperties = new Properties();
+		propertySources.addFirst(new PropertiesPropertySource("testProperties", testProperties));
+	}
+
+	@Test
+	public void containsProperty() {
+		assertThat(propertyResolver.containsProperty("foo"), is(false));
+		testProperties.put("foo", "bar");
+		assertThat(propertyResolver.containsProperty("foo"), is(true));
+	}
+
+	@Test
+	public void getProperty() {
+		assertThat(propertyResolver.getProperty("foo"), nullValue());
+		testProperties.put("foo", "bar");
+		assertThat(propertyResolver.getProperty("foo"), is("bar"));
+	}
+
+	@Test
+	public void getProperty_propertySourceSearchOrderIsFIFO() {
+		MutablePropertySources sources = new MutablePropertySources();
+		PropertyResolver resolver = new PropertySourcesPropertyResolver(sources);
+		sources.addFirst(new MockPropertySource("ps1").withProperty("pName", "ps1Value"));
+		assertThat(resolver.getProperty("pName"), equalTo("ps1Value"));
+		sources.addFirst(new MockPropertySource("ps2").withProperty("pName", "ps2Value"));
+		assertThat(resolver.getProperty("pName"), equalTo("ps2Value"));
+		sources.addFirst(new MockPropertySource("ps3").withProperty("pName", "ps3Value"));
+		assertThat(resolver.getProperty("pName"), equalTo("ps3Value"));
+	}
+
+	@Test
+	public void getProperty_withExplicitNullValue() {
+		// java.util.Properties does not allow null values (because Hashtable does not)
+		Map<String, String> nullableProperties = new HashMap<String, String>();
+		propertySources.addLast(new MapPropertySource("nullableProperties", nullableProperties));
+		nullableProperties.put("foo", null);
+		assertThat(propertyResolver.getProperty("foo"), nullValue());
+	}
+
+	@Test
+	public void getProperty_withStringArrayConversion() {
+		testProperties.put("foo", "bar,baz");
+		assertThat(propertyResolver.getProperty("foo", String[].class), equalTo(new String[] { "bar", "baz" }));
+	}
+
+
+	@Test
+	public void getProperty_withNonConvertibleTargetType() {
+		testProperties.put("foo", "bar");
+
+		class TestType { }
+
+		try {
+			propertyResolver.getProperty("foo", TestType.class);
+			fail("Expected IllegalArgumentException due to non-convertible types");
+		} catch (IllegalArgumentException ex) {
+			// expected
+		}
+	}
+
+	@Test
+	public void getProperty_doesNotCache_replaceExistingKeyPostConstruction() {
+		String key = "foo";
+		String value1 = "bar";
+		String value2 = "biz";
+
+		HashMap<String, String> map = new HashMap<String, String>();
+		map.put(key, value1); // before construction
+		MutablePropertySources propertySources = new MutablePropertySources();
+		propertySources.addFirst(new MapPropertySource("testProperties", map));
+		PropertyResolver propertyResolver = new PropertySourcesPropertyResolver(propertySources);
+		assertThat(propertyResolver.getProperty(key), equalTo(value1));
+		map.put(key, value2); // after construction and first resolution
+		assertThat(propertyResolver.getProperty(key), equalTo(value2));
+	}
+
+	@Test
+	public void getProperty_doesNotCache_addNewKeyPostConstruction() {
+		HashMap<String, String> map = new HashMap<String, String>();
+		MutablePropertySources propertySources = new MutablePropertySources();
+		propertySources.addFirst(new MapPropertySource("testProperties", map));
+		PropertyResolver propertyResolver = new PropertySourcesPropertyResolver(propertySources);
+		assertThat(propertyResolver.getProperty("foo"), equalTo(null));
+		map.put("foo", "42");
+		assertThat(propertyResolver.getProperty("foo"), equalTo("42"));
+	}
+
+	@Test
+	public void getPropertySources_replacePropertySource() {
+		propertySources = new MutablePropertySources();
+		propertyResolver = new PropertySourcesPropertyResolver(propertySources);
+		propertySources.addLast(new MockPropertySource("local").withProperty("foo", "localValue"));
+		propertySources.addLast(new MockPropertySource("system").withProperty("foo", "systemValue"));
+
+		// 'local' was added first so has precedence
+		assertThat(propertyResolver.getProperty("foo"), equalTo("localValue"));
+
+		// replace 'local' with new property source
+		propertySources.replace("local", new MockPropertySource("new").withProperty("foo", "newValue"));
+
+		// 'system' now has precedence
+		assertThat(propertyResolver.getProperty("foo"), equalTo("newValue"));
+
+		assertThat(propertySources.size(), is(2));
+	}
+
+	@Test
+	public void getRequiredProperty() {
+		testProperties.put("exists", "xyz");
+		assertThat(propertyResolver.getRequiredProperty("exists"), is("xyz"));
+
+		try {
+			propertyResolver.getRequiredProperty("bogus");
+			fail("expected IllegalStateException");
+		} catch (IllegalStateException ex) {
+			// expected
+		}
+	}
+
+	@Test
+	public void getRequiredProperty_withStringArrayConversion() {
+		testProperties.put("exists", "abc,123");
+		assertThat(propertyResolver.getRequiredProperty("exists", String[].class), equalTo(new String[] { "abc", "123" }));
+
+		try {
+			propertyResolver.getRequiredProperty("bogus", String[].class);
+			fail("expected IllegalStateException");
+		} catch (IllegalStateException ex) {
+			// expected
+		}
+	}
+
+	@Test
+	public void asProperties() {
+		propertySources = new MutablePropertySources();
+		propertyResolver = new PropertySourcesPropertyResolver(propertySources);
+		assertThat(propertyResolver.asProperties(), notNullValue());
+
+		propertySources.addLast(new MockPropertySource("highestPrecedence").withProperty("common", "highCommon").withProperty("highKey", "highVal"));
+		propertySources.addLast(new MockPropertySource("middlePrecedence").withProperty("common", "midCommon").withProperty("midKey", "midVal"));
+		propertySources.addLast(new MockPropertySource("lowestPrecedence").withProperty("common", "lowCommon").withProperty("lowKey", "lowVal"));
+
+		Properties props = propertyResolver.asProperties();
+		assertThat(props.getProperty("common"), is("highCommon"));
+		assertThat(props.getProperty("lowKey"), is("lowVal"));
+		assertThat(props.getProperty("midKey"), is("midVal"));
+		assertThat(props.getProperty("highKey"), is("highVal"));
+		assertThat(props.size(), is(4));
+	}
+
+	@Test
+	public void asProperties_withMixedPropertySourceTypes() {
+		class Foo { }
+		class FooPropertySource extends PropertySource<Foo> {
+			public FooPropertySource() { super("fooProperties", new Foo()); }
+			public String[] getPropertyNames() { return new String[] {"pName"}; }
+			public String getProperty(String key) { return "fooValue"; }
+		}
+		propertySources = new MutablePropertySources();
+		propertyResolver = new PropertySourcesPropertyResolver(propertySources);
+		assertThat(propertyResolver.asProperties(), notNullValue());
+
+		propertySources.addLast(new MockPropertySource());
+		propertySources.addLast(new FooPropertySource());
+
+		Properties props = propertyResolver.asProperties();
+		assertThat(props.getProperty("pName"), is("fooValue"));
+		assertThat(props.size(), is(1));
+	}
+
+
+	@Test
+	public void resolvePlaceholders() {
+		MutablePropertySources propertySources = new MutablePropertySources();
+		propertySources.addFirst(new MockPropertySource().withProperty("key", "value"));
+		PropertyResolver resolver = new PropertySourcesPropertyResolver(propertySources);
+		assertThat(resolver.resolvePlaceholders("Replace this ${key}"), equalTo("Replace this value"));
+	}
+
+	@Test
+	public void resolvePlaceholders_withUnresolvable() {
+		MutablePropertySources propertySources = new MutablePropertySources();
+		propertySources.addFirst(new MockPropertySource().withProperty("key", "value"));
+		PropertyResolver resolver = new PropertySourcesPropertyResolver(propertySources);
+		assertThat(resolver.resolvePlaceholders("Replace this ${key} plus ${unknown}"),
+				equalTo("Replace this value plus ${unknown}"));
+	}
+
+	@Test
+	public void resolvePlaceholders_withDefault() {
+		MutablePropertySources propertySources = new MutablePropertySources();
+		propertySources.addFirst(new MockPropertySource().withProperty("key", "value"));
+		PropertyResolver resolver = new PropertySourcesPropertyResolver(propertySources);
+		assertThat(resolver.resolvePlaceholders("Replace this ${key} plus ${unknown:defaultValue}"),
+				equalTo("Replace this value plus defaultValue"));
+	}
+
+	@Test(expected=IllegalArgumentException.class)
+	public void resolvePlaceholders_withNullInput() {
+		new PropertySourcesPropertyResolver(new MutablePropertySources()).resolvePlaceholders(null);
+	}
+
+	@Test
+	public void resolveRequiredPlaceholders() {
+		MutablePropertySources propertySources = new MutablePropertySources();
+		propertySources.addFirst(new MockPropertySource().withProperty("key", "value"));
+		PropertyResolver resolver = new PropertySourcesPropertyResolver(propertySources);
+		assertThat(resolver.resolveRequiredPlaceholders("Replace this ${key}"), equalTo("Replace this value"));
+	}
+
+	@Test(expected=IllegalArgumentException.class)
+	public void resolveRequiredPlaceholders_withUnresolvable() {
+		MutablePropertySources propertySources = new MutablePropertySources();
+		propertySources.addFirst(new MockPropertySource().withProperty("key", "value"));
+		PropertyResolver resolver = new PropertySourcesPropertyResolver(propertySources);
+		resolver.resolveRequiredPlaceholders("Replace this ${key} plus ${unknown}");
+	}
+
+	@Test
+	public void resolveRequiredPlaceholders_withDefault() {
+		MutablePropertySources propertySources = new MutablePropertySources();
+		propertySources.addFirst(new MockPropertySource().withProperty("key", "value"));
+		PropertyResolver resolver = new PropertySourcesPropertyResolver(propertySources);
+		assertThat(resolver.resolveRequiredPlaceholders("Replace this ${key} plus ${unknown:defaultValue}"),
+				equalTo("Replace this value plus defaultValue"));
+	}
+
+	@Test(expected=IllegalArgumentException.class)
+	public void resolveRequiredPlaceholders_withNullInput() {
+		new PropertySourcesPropertyResolver(new MutablePropertySources()).resolveRequiredPlaceholders(null);
+	}
+}

org.springframework.core/src/test/java/org/springframework/core/env/PropertySourceTests.java

@@ -20,8 +20,9 @@ import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertThat;
 
+import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.LinkedList;
+import java.util.List;
 import java.util.Map;
 import java.util.Properties;
 
@@ -66,7 +67,7 @@ public class PropertySourceTests {
 
 		PropertySource<?> ps1 = new MapPropertySource("ps1", map1);
 		ps1.getSource();
-		LinkedList<PropertySource<?>> propertySources = new LinkedList<PropertySource<?>>();
+		List<PropertySource<?>> propertySources = new ArrayList<PropertySource<?>>();
 		assertThat(propertySources.add(ps1), equalTo(true));
 		assertThat(propertySources.contains(ps1), is(true));
 		assertThat(propertySources.contains(PropertySource.named("ps1")), is(true));

org.springframework.core/src/test/java/org/springframework/core/env/PropertySourcesTests.java

@@ -0,0 +1,149 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.core.env;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.CoreMatchers.nullValue;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.springframework.mock.env.MockPropertySource;
+
+public class PropertySourcesTests {
+	@Test
+	public void test() {
+		MutablePropertySources sources = new MutablePropertySources();
+		sources.addLast(new MockPropertySource("b").withProperty("p1", "bValue"));
+		sources.addLast(new MockPropertySource("d").withProperty("p1", "dValue"));
+		sources.addLast(new MockPropertySource("f").withProperty("p1", "fValue"));
+
+		assertThat(sources.size(), equalTo(3));
+		assertThat(sources.contains("a"), is(false));
+		assertThat(sources.contains("b"), is(true));
+		assertThat(sources.contains("c"), is(false));
+		assertThat(sources.contains("d"), is(true));
+		assertThat(sources.contains("e"), is(false));
+		assertThat(sources.contains("f"), is(true));
+		assertThat(sources.contains("g"), is(false));
+
+		assertThat(sources.get("b"), not(nullValue()));
+		assertThat(sources.get("b").getProperty("p1"), equalTo("bValue"));
+		assertThat(sources.get("d"), not(nullValue()));
+		assertThat(sources.get("d").getProperty("p1"), equalTo("dValue"));
+
+		sources.addBefore("b", new MockPropertySource("a"));
+		sources.addAfter("b", new MockPropertySource("c"));
+
+		assertThat(sources.size(), equalTo(5));
+		assertThat(sources.asList().indexOf(PropertySource.named("a")), is(0));
+		assertThat(sources.asList().indexOf(PropertySource.named("b")), is(1));
+		assertThat(sources.asList().indexOf(PropertySource.named("c")), is(2));
+		assertThat(sources.asList().indexOf(PropertySource.named("d")), is(3));
+		assertThat(sources.asList().indexOf(PropertySource.named("f")), is(4));
+
+		sources.addBefore("f", new MockPropertySource("e"));
+		sources.addAfter("f", new MockPropertySource("g"));
+
+		assertThat(sources.size(), equalTo(7));
+		assertThat(sources.asList().indexOf(PropertySource.named("a")), is(0));
+		assertThat(sources.asList().indexOf(PropertySource.named("b")), is(1));
+		assertThat(sources.asList().indexOf(PropertySource.named("c")), is(2));
+		assertThat(sources.asList().indexOf(PropertySource.named("d")), is(3));
+		assertThat(sources.asList().indexOf(PropertySource.named("e")), is(4));
+		assertThat(sources.asList().indexOf(PropertySource.named("f")), is(5));
+		assertThat(sources.asList().indexOf(PropertySource.named("g")), is(6));
+
+		sources.addLast(new MockPropertySource("a"));
+		assertThat(sources.size(), equalTo(7));
+		assertThat(sources.asList().indexOf(PropertySource.named("b")), is(0));
+		assertThat(sources.asList().indexOf(PropertySource.named("c")), is(1));
+		assertThat(sources.asList().indexOf(PropertySource.named("d")), is(2));
+		assertThat(sources.asList().indexOf(PropertySource.named("e")), is(3));
+		assertThat(sources.asList().indexOf(PropertySource.named("f")), is(4));
+		assertThat(sources.asList().indexOf(PropertySource.named("g")), is(5));
+		assertThat(sources.asList().indexOf(PropertySource.named("a")), is(6));
+
+		sources.addFirst(new MockPropertySource("a"));
+		assertThat(sources.size(), equalTo(7));
+		assertThat(sources.asList().indexOf(PropertySource.named("a")), is(0));
+		assertThat(sources.asList().indexOf(PropertySource.named("b")), is(1));
+		assertThat(sources.asList().indexOf(PropertySource.named("c")), is(2));
+		assertThat(sources.asList().indexOf(PropertySource.named("d")), is(3));
+		assertThat(sources.asList().indexOf(PropertySource.named("e")), is(4));
+		assertThat(sources.asList().indexOf(PropertySource.named("f")), is(5));
+		assertThat(sources.asList().indexOf(PropertySource.named("g")), is(6));
+
+		assertEquals(sources.remove("a"), PropertySource.named("a"));
+		assertThat(sources.size(), equalTo(6));
+		assertThat(sources.contains("a"), is(false));
+
+		assertEquals(sources.remove("a"), null);
+		assertThat(sources.size(), equalTo(6));
+
+		String bogusPS = "bogus";
+		try {
+			sources.addAfter(bogusPS, new MockPropertySource("h"));
+			fail("expected non-existent PropertySource exception");
+		} catch (IllegalArgumentException ex) {
+			assertThat(ex.getMessage(),
+					equalTo(String.format(MutablePropertySources.NON_EXISTENT_PROPERTY_SOURCE_MESSAGE, bogusPS)));
+		}
+
+		sources.addFirst(new MockPropertySource("a"));
+		assertThat(sources.size(), equalTo(7));
+		assertThat(sources.asList().indexOf(PropertySource.named("a")), is(0));
+		assertThat(sources.asList().indexOf(PropertySource.named("b")), is(1));
+		assertThat(sources.asList().indexOf(PropertySource.named("c")), is(2));
+
+		sources.replace("a", new MockPropertySource("a-replaced"));
+		assertThat(sources.size(), equalTo(7));
+		assertThat(sources.asList().indexOf(PropertySource.named("a-replaced")), is(0));
+		assertThat(sources.asList().indexOf(PropertySource.named("b")), is(1));
+		assertThat(sources.asList().indexOf(PropertySource.named("c")), is(2));
+
+		sources.replace("a-replaced", new MockPropertySource("a"));
+
+		try {
+			sources.replace(bogusPS, new MockPropertySource("bogus-replaced"));
+			fail("expected non-existent PropertySource exception");
+		} catch (IllegalArgumentException ex) {
+			assertThat(ex.getMessage(),
+					equalTo(String.format(MutablePropertySources.NON_EXISTENT_PROPERTY_SOURCE_MESSAGE, bogusPS)));
+		}
+
+		try {
+			sources.addBefore("b", new MockPropertySource("b"));
+			fail("expected exception");
+		} catch (IllegalArgumentException ex) {
+			assertThat(ex.getMessage(),
+					equalTo(String.format(MutablePropertySources.ILLEGAL_RELATIVE_ADDITION_MESSAGE, "b")));
+		}
+
+		try {
+			sources.addAfter("b", new MockPropertySource("b"));
+			fail("expected exception");
+		} catch (IllegalArgumentException ex) {
+			assertThat(ex.getMessage(),
+					equalTo(String.format(MutablePropertySources.ILLEGAL_RELATIVE_ADDITION_MESSAGE, "b")));
+		}
+	}
+
+}

org.springframework.core/src/test/java/org/springframework/mock/env/MockPropertySource.java

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2002-2011 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.mock.env;
+
+import java.util.Properties;
+
+import org.springframework.core.env.PropertiesPropertySource;
+import org.springframework.core.env.PropertySource;
+
+/**
+ * Simple {@link PropertySource} implementation for use in testing. Accepts
+ * a user-provided {@link Properties} object, or if omitted during construction,
+ * the implementation will initialize its own.
+ *
+ * The {@link #setProperty} and {@link #withProperty} methods are exposed for
+ * convenience, for example:
+ * <pre>
+ * {@code
+ *   PropertySource<?> source = new MockPropertySource().withProperty("foo", "bar");
+ * }
+ * </pre>
+ *
+ * @author Chris Beams
+ * @since 3.1
+ * @see MockEnvironment
+ */
+public class MockPropertySource extends PropertiesPropertySource {
+
+	/**
+	 * {@value} is the default name for {@link MockPropertySource} instances not
+	 * otherwise given an explicit name.
+	 * @see #MockPropertySource()
+	 * @see #MockPropertySource(String)
+	 */
+	public static final String MOCK_PROPERTIES_PROPERTY_SOURCE_NAME = "mockProperties";
+
+	/**
+	 * Create a new {@code MockPropertySource} named {@value #MOCK_PROPERTIES_PROPERTY_SOURCE_NAME}
+	 * that will maintain its own internal {@link Properties} instance.
+	 */
+	public MockPropertySource() {
+		this(new Properties());
+	}
+
+	/**
+	 * Create a new {@code MockPropertySource} with the given name that will
+	 * maintain its own internal {@link Properties} instance.
+	 * @param name the {@linkplain #getName() name} of the property source
+	 */
+	public MockPropertySource(String name) {
+		this(name, new Properties());
+	}
+
+	/**
+	 * Create a new {@code MockPropertySource} named {@value #MOCK_PROPERTIES_PROPERTY_SOURCE_NAME}
+	 * and backed by the given {@link Properties} object.
+	 * @param properties the properties to use
+	 */
+	public MockPropertySource(Properties properties) {
+		this(MOCK_PROPERTIES_PROPERTY_SOURCE_NAME, properties);
+	}
+
+	/**
+	 * Create a new {@code MockPropertySource} with with the given name and backed by the given
+	 * {@link Properties} object
+	 * @param name the {@linkplain #getName() name} of the property source
+	 * @param properties the properties to use
+	 */
+	public MockPropertySource(String name, Properties properties) {
+		super(name, properties);
+	}
+
+	/**
+	 * Set the given property on the underlying {@link Properties} object.
+	 */
+	public void setProperty(String key, String value) {
+		this.source.put(key, value);
+	}
+
+	/**
+	 * Convenient synonym for {@link #setProperty} that returns the current instance.
+	 * Useful for method chaining and fluent-style use.
+	 * @return this {@link MockPropertySource} instance
+	 */
+	public MockPropertySource withProperty(String key, String value) {
+		this.setProperty(key, value);
+		return this;
+	}
+}