Merge 3.1.0 development branch into trunk

Branch in question is 'env' branch from git://git.springsource.org/sandbox/cbeams.git; merged into
git-svn repository with:

    git merge -s recursive -Xtheirs --no-commit env

No merge conflicts, but did need to

    git rm spring-build

prior to committing.

With this change, Spring 3.1.0 development is now happening on SVN
trunk. Further commits to the 3.0.x line will happen in an as-yet
uncreated SVN branch.  3.1.0 snapshots will be available
per the usual nightly CI build from trunk.

org.springframework.context/src/test/java/example/profilescan/ProfileAnnotatedComponent.java

@@ -0,0 +1,13 @@
+package example.profilescan;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Component;
+
+@Profile(ProfileAnnotatedComponent.PROFILE_NAME)
+@Component(ProfileAnnotatedComponent.BEAN_NAME)
+public class ProfileAnnotatedComponent {
+
+	public static final String BEAN_NAME = "profileAnnotatedComponent";
+	public static final String PROFILE_NAME = "test";
+
+}

org.springframework.context/src/test/java/org/springframework/context/annotation/AsmCircularImportDetectionTests.java

@@ -16,6 +16,7 @@
 package org.springframework.context.annotation;
 
 import org.springframework.beans.factory.parsing.FailFastProblemReporter;
+import org.springframework.core.env.DefaultEnvironment;
 import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
 
 /**
@@ -32,7 +33,7 @@ public class AsmCircularImportDetectionTests extends AbstractCircularImportDetec
 
 	@Override
 	protected ConfigurationClassParser newParser() {
-		return new ConfigurationClassParser(new CachingMetadataReaderFactory(), new FailFastProblemReporter());
+		return new ConfigurationClassParser(new CachingMetadataReaderFactory(), new FailFastProblemReporter(), new DefaultEnvironment());
 	}
 
 	@Override

org.springframework.context/src/test/java/org/springframework/context/annotation/ClassPathBeanDefinitionScannerTests.java

@@ -152,11 +152,12 @@ public class ClassPathBeanDefinitionScannerTests {
 	public void testSimpleScanWithDefaultFiltersAndOverriddenEqualNamedBean() {
 		GenericApplicationContext context = new GenericApplicationContext();
 		context.registerBeanDefinition("myNamedDao", new RootBeanDefinition(NamedStubDao.class));
+		int initialBeanCount = context.getBeanDefinitionCount();
 		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(context);
 		scanner.setIncludeAnnotationConfig(false);
-		int beanCount = scanner.scan(BASE_PACKAGE);
-		assertEquals(5, beanCount);
-		assertEquals(6, context.getBeanDefinitionCount());
+		int scannedBeanCount = scanner.scan(BASE_PACKAGE);
+		assertEquals(5, scannedBeanCount);
+		assertEquals(initialBeanCount + scannedBeanCount, context.getBeanDefinitionCount());
 		assertTrue(context.containsBean("serviceInvocationCounter"));
 		assertTrue(context.containsBean("fooServiceImpl"));
 		assertTrue(context.containsBean("stubFooDao"));
@@ -170,11 +171,12 @@ public class ClassPathBeanDefinitionScannerTests {
 		RootBeanDefinition bd = new RootBeanDefinition(NamedStubDao.class);
 		bd.setScope(RootBeanDefinition.SCOPE_PROTOTYPE);
 		context.registerBeanDefinition("myNamedDao", bd);
+		int initialBeanCount = context.getBeanDefinitionCount();
 		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(context);
 		scanner.setIncludeAnnotationConfig(false);
-		int beanCount = scanner.scan(BASE_PACKAGE);
-		assertEquals(5, beanCount);
-		assertEquals(6, context.getBeanDefinitionCount());
+		int scannedBeanCount = scanner.scan(BASE_PACKAGE);
+		assertEquals(5, scannedBeanCount);
+		assertEquals(initialBeanCount + scannedBeanCount, context.getBeanDefinitionCount());
 		assertTrue(context.containsBean("serviceInvocationCounter"));
 		assertTrue(context.containsBean("fooServiceImpl"));
 		assertTrue(context.containsBean("stubFooDao"));
@@ -362,11 +364,12 @@ public class ClassPathBeanDefinitionScannerTests {
 	public void testMultipleScanCalls() {
 		GenericApplicationContext context = new GenericApplicationContext();
 		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(context);
-		int beanCount = scanner.scan(BASE_PACKAGE);
-		assertEquals(10, beanCount);
-		assertEquals(beanCount, context.getBeanDefinitionCount());
+		int initialBeanCount = context.getBeanDefinitionCount();
+		int scannedBeanCount = scanner.scan(BASE_PACKAGE);
+		assertEquals(10, scannedBeanCount);
+		assertEquals(scannedBeanCount, context.getBeanDefinitionCount() - initialBeanCount);
 		int addedBeanCount = scanner.scan("org.springframework.aop.aspectj.annotation");
-		assertEquals(beanCount + addedBeanCount, context.getBeanDefinitionCount());
+		assertEquals(initialBeanCount + scannedBeanCount + addedBeanCount, context.getBeanDefinitionCount());
 	}
 
 	@Test

org.springframework.context/src/test/java/org/springframework/context/annotation/ClassPathScanningCandidateComponentProviderTests.java

@@ -16,10 +16,30 @@
 
 package org.springframework.context.annotation;
 
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+
 import java.util.Iterator;
 import java.util.Set;
 import java.util.regex.Pattern;
 
+import org.aspectj.lang.annotation.Aspect;
+import org.junit.Test;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.core.env.ConfigurableEnvironment;
+import org.springframework.core.env.DefaultEnvironment;
+import org.springframework.core.type.filter.AnnotationTypeFilter;
+import org.springframework.core.type.filter.AssignableTypeFilter;
+import org.springframework.core.type.filter.RegexPatternTypeFilter;
+import org.springframework.stereotype.Component;
+import org.springframework.stereotype.Controller;
+import org.springframework.stereotype.Repository;
+import org.springframework.stereotype.Service;
+
+import example.profilescan.ProfileAnnotatedComponent;
 import example.scannable.FooDao;
 import example.scannable.FooService;
 import example.scannable.FooServiceImpl;
@@ -28,18 +48,6 @@ import example.scannable.NamedComponent;
 import example.scannable.NamedStubDao;
 import example.scannable.ServiceInvocationCounter;
 import example.scannable.StubFooDao;
-import org.aspectj.lang.annotation.Aspect;
-import static org.junit.Assert.*;
-import org.junit.Test;
-
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.core.type.filter.AnnotationTypeFilter;
-import org.springframework.core.type.filter.AssignableTypeFilter;
-import org.springframework.core.type.filter.RegexPatternTypeFilter;
-import org.springframework.stereotype.Component;
-import org.springframework.stereotype.Controller;
-import org.springframework.stereotype.Repository;
-import org.springframework.stereotype.Service;
 
 /**
  * @author Mark Fisher
@@ -49,7 +57,7 @@ import org.springframework.stereotype.Service;
 public class ClassPathScanningCandidateComponentProviderTests {
 
 	private static final String TEST_BASE_PACKAGE = "example.scannable";
-			//ClassPathScanningCandidateComponentProviderTests.class.getPackage().getName();
+	private static final String TEST_PROFILE_PACKAGE = "example.profilescan";
 
 
 	@Test
@@ -102,7 +110,6 @@ public class ClassPathScanningCandidateComponentProviderTests {
 		assertFalse(containsBeanClass(candidates, NamedStubDao.class));
 	}
 
-	@SuppressWarnings("unchecked")
 	@Test
 	public void testWithAspectAnnotationOnly() throws Exception {
 		ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false);
@@ -155,6 +162,59 @@ public class ClassPathScanningCandidateComponentProviderTests {
 		assertFalse(containsBeanClass(candidates, FooServiceImpl.class));
 	}
 
+	@Test
+	public void testWithNullEnvironment() {
+		ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(true);
+		Set<BeanDefinition> candidates = provider.findCandidateComponents(TEST_PROFILE_PACKAGE);
+		assertThat(containsBeanClass(candidates, ProfileAnnotatedComponent.class), is(false));
+	}
+
+	@Test
+	public void testWithInactiveProfile() {
+		ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(true);
+		ConfigurableEnvironment env = new DefaultEnvironment();
+		env.setActiveProfiles("other");
+		provider.setEnvironment(env);
+		Set<BeanDefinition> candidates = provider.findCandidateComponents(TEST_PROFILE_PACKAGE);
+		assertThat(containsBeanClass(candidates, ProfileAnnotatedComponent.class), is(false));
+	}
+
+	@Test
+	public void testWithActiveProfile() {
+		ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(true);
+		ConfigurableEnvironment env = new DefaultEnvironment();
+		env.setActiveProfiles(ProfileAnnotatedComponent.PROFILE_NAME);
+		provider.setEnvironment(env);
+		Set<BeanDefinition> candidates = provider.findCandidateComponents(TEST_PROFILE_PACKAGE);
+		assertThat(containsBeanClass(candidates, ProfileAnnotatedComponent.class), is(true));
+	}
+
+	@Test
+	public void testIntegrationWithAnnotationConfigApplicationContext_noProfile() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+		ctx.register(ProfileAnnotatedComponent.class);
+		ctx.refresh();
+		assertThat(ctx.containsBean(ProfileAnnotatedComponent.BEAN_NAME), is(false));
+	}
+
+	@Test
+	public void testIntegrationWithAnnotationConfigApplicationContext_validProfile() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+		ctx.getEnvironment().setActiveProfiles(ProfileAnnotatedComponent.PROFILE_NAME);
+		ctx.register(ProfileAnnotatedComponent.class);
+		ctx.refresh();
+		assertThat(ctx.containsBean(ProfileAnnotatedComponent.BEAN_NAME), is(true));
+	}
+
+	@Test
+	public void testIntegrationWithAnnotationConfigApplicationContext_invalidProfile() {
+		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
+		ctx.getEnvironment().setActiveProfiles("other");
+		ctx.register(ProfileAnnotatedComponent.class);
+		ctx.refresh();
+		assertThat(ctx.containsBean(ProfileAnnotatedComponent.BEAN_NAME), is(false));
+	}
+
 	private boolean containsBeanClass(Set<BeanDefinition> candidates, Class beanClass) {
 		for (Iterator it = candidates.iterator(); it.hasNext();) {
 			ScannedGenericBeanDefinition definition = (ScannedGenericBeanDefinition) it.next();

org.springframework.context/src/test/java/org/springframework/context/annotation/ComponentScanAnnotationTests.java

@@ -0,0 +1,60 @@
+/*
+ * 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.context.annotation;
+
+import org.junit.Test;
+import org.springframework.beans.factory.support.DefaultBeanNameGenerator;
+import org.springframework.context.annotation.ComponentScan.ExcludeFilter;
+import org.springframework.context.annotation.ComponentScan.IncludeFilter;
+import org.springframework.core.type.filter.TypeFilter;
+
+/**
+ * Unit tests for {@link ComponentScan} annotation.
+ *
+ * @author Chris Beams
+ * @since 3.1
+ */
+public class ComponentScanAnnotationTests {
+	@Test
+	public void test() {
+
+	}
+}
+
+@interface MyAnnotation { }
+
+@Configuration
+@ComponentScan(
+	packageOf={TestBean.class},
+	nameGenerator = DefaultBeanNameGenerator.class,
+	scopedProxy = ScopedProxyMode.NO,
+	scopeResolver = AnnotationScopeMetadataResolver.class,
+	useDefaultFilters = false,
+	resourcePattern = "**/*custom.class",
+	includeFilters = {
+		@IncludeFilter(type = FilterType.ANNOTATION, value = MyAnnotation.class)
+	},
+	excludeFilters = {
+		@ExcludeFilter(type = FilterType.CUSTOM, value = TypeFilter.class)
+	}
+)
+class MyConfig {
+
+}
+
+@ComponentScan(packageOf=example.scannable.NamedComponent.class)
+class SimpleConfig { }

org.springframework.context/src/test/java/org/springframework/context/annotation/ComponentScanParserTests.java

@@ -16,7 +16,12 @@
 
 package org.springframework.context.annotation;
 
-import static org.junit.Assert.*;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
 
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
@@ -26,11 +31,14 @@ import java.lang.annotation.Target;
 import org.junit.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.ApplicationContext;
+import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
+import org.springframework.context.support.GenericXmlApplicationContext;
 import org.springframework.core.type.classreading.MetadataReader;
 import org.springframework.core.type.classreading.MetadataReaderFactory;
 import org.springframework.core.type.filter.TypeFilter;
 
+import example.profilescan.ProfileAnnotatedComponent;
 import example.scannable.AutowiredQualifierFooService;
 
 /**
@@ -88,6 +96,31 @@ public class ComponentScanParserTests {
 		assertNotNull(testBean.getDependency());
 	}
 
+	@Test
+	public void testComponentScanRespectsProfileAnnotation() {
+		String xmlLocation = "org/springframework/context/annotation/componentScanRespectsProfileAnnotationTests.xml";
+		{ // should exclude the profile-annotated bean if active profiles remains unset
+			GenericXmlApplicationContext context = new GenericXmlApplicationContext();
+			context.load(xmlLocation);
+			context.refresh();
+			assertThat(context.containsBean(ProfileAnnotatedComponent.BEAN_NAME), is(false));
+		}
+		{ // should include the profile-annotated bean with active profiles set
+			GenericXmlApplicationContext context = new GenericXmlApplicationContext();
+			context.getEnvironment().setActiveProfiles(ProfileAnnotatedComponent.PROFILE_NAME);
+			context.load(xmlLocation);
+			context.refresh();
+			assertThat(context.containsBean(ProfileAnnotatedComponent.BEAN_NAME), is(true));
+		}
+		{ // ensure the same works for AbstractRefreshableApplicationContext impls too
+			ConfigurableApplicationContext context =
+				new ClassPathXmlApplicationContext(new String[]{xmlLocation}, false);
+			context.getEnvironment().setActiveProfiles(ProfileAnnotatedComponent.PROFILE_NAME);
+			context.refresh();
+			assertThat(context.containsBean(ProfileAnnotatedComponent.BEAN_NAME), is(true));
+		}
+	}
+
 
 	@Target({ElementType.TYPE, ElementType.FIELD})
 	@Retention(RetentionPolicy.RUNTIME)

org.springframework.context/src/test/java/org/springframework/context/annotation/componentScanRespectsProfileAnnotationTests.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+		xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		xmlns:context="http://www.springframework.org/schema/context"
+		xsi:schemaLocation="http://www.springframework.org/schema/beans
+				http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+				http://www.springframework.org/schema/context
+				http://www.springframework.org/schema/context/spring-context-3.0.xsd">
+
+	<context:component-scan base-package="example.profilescan"/>
+
+</beans>

org.springframework.context/src/test/java/org/springframework/context/config/ContextNamespaceHandlerTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2008 the original author or authors.
+ * 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.
@@ -16,23 +16,27 @@
 
 package org.springframework.context.config;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
 import java.util.Calendar;
 import java.util.Date;
 import java.util.Map;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import org.junit.Before;
 import org.junit.Test;
-
+import org.springframework.beans.factory.config.AbstractPropertyPlaceholderConfigurer;
 import org.springframework.beans.factory.config.PropertyOverrideConfigurer;
 import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;
+import org.springframework.context.support.GenericXmlApplicationContext;
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.mock.env.MockEnvironment;
 
 /**
  * @author Arjen Poutsma
  * @author Dave Syer
+ * @author Chris Beams
  * @since 2.5.6
  */
 public class ContextNamespaceHandlerTests {
@@ -41,9 +45,9 @@ public class ContextNamespaceHandlerTests {
 	public void propertyPlaceholder() throws Exception {
 		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
 				"contextNamespaceHandlerTests-replace.xml", getClass());
-		Map<String, PropertyPlaceholderConfigurer> beans = applicationContext
-				.getBeansOfType(PropertyPlaceholderConfigurer.class);
-		assertFalse("No PropertyPlaceHolderConfigurer found", beans.isEmpty());
+		Map<String, AbstractPropertyPlaceholderConfigurer> beans = applicationContext
+				.getBeansOfType(AbstractPropertyPlaceholderConfigurer.class);
+		assertFalse("No PropertyPlaceholderConfigurer found", beans.isEmpty());
 		String s = (String) applicationContext.getBean("string");
 		assertEquals("No properties replaced", "bar", s);
 	}
@@ -56,7 +60,7 @@ public class ContextNamespaceHandlerTests {
 					"contextNamespaceHandlerTests-system.xml", getClass());
 			Map<String, PropertyPlaceholderConfigurer> beans = applicationContext
 					.getBeansOfType(PropertyPlaceholderConfigurer.class);
-			assertFalse("No PropertyPlaceHolderConfigurer found", beans.isEmpty());
+			assertFalse("No PropertyPlaceholderConfigurer found", beans.isEmpty());
 			String s = (String) applicationContext.getBean("string");
 			assertEquals("No properties replaced", "spam", s);
 		} finally {
@@ -66,13 +70,27 @@ public class ContextNamespaceHandlerTests {
 		}
 	}
 
+	@Test
+	public void propertyPlaceholderEnvironmentProperties() throws Exception {
+		MockEnvironment env = MockEnvironment.withProperty("foo", "spam");
+		GenericXmlApplicationContext applicationContext = new GenericXmlApplicationContext();
+		applicationContext.setEnvironment(env);
+		applicationContext.load(new ClassPathResource("contextNamespaceHandlerTests-simple.xml", getClass()));
+		applicationContext.refresh();
+		Map<String, AbstractPropertyPlaceholderConfigurer> beans = applicationContext
+				.getBeansOfType(AbstractPropertyPlaceholderConfigurer.class);
+		assertFalse("No PropertyPlaceholderConfigurer found", beans.isEmpty());
+		String s = (String) applicationContext.getBean("string");
+		assertEquals("No properties replaced", "spam", s);
+	}
+
 	@Test
 	public void propertyPlaceholderLocation() throws Exception {
 		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
 				"contextNamespaceHandlerTests-location.xml", getClass());
 		Map<String, PropertyPlaceholderConfigurer> beans = applicationContext
 				.getBeansOfType(PropertyPlaceholderConfigurer.class);
-		assertFalse("No PropertyPlaceHolderConfigurer found", beans.isEmpty());
+		assertFalse("No PropertyPlaceholderConfigurer found", beans.isEmpty());
 		String s = (String) applicationContext.getBean("foo");
 		assertEquals("No properties replaced", "bar", s);
 		s = (String) applicationContext.getBean("bar");
@@ -85,9 +103,9 @@ public class ContextNamespaceHandlerTests {
 	public void propertyPlaceholderIgnored() throws Exception {
 		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
 				"contextNamespaceHandlerTests-replace-ignore.xml", getClass());
-		Map<String, PropertyPlaceholderConfigurer> beans = applicationContext
-				.getBeansOfType(PropertyPlaceholderConfigurer.class);
-		assertFalse("No PropertyPlaceHolderConfigurer found", beans.isEmpty());
+		Map<String, AbstractPropertyPlaceholderConfigurer> beans = applicationContext
+				.getBeansOfType(AbstractPropertyPlaceholderConfigurer.class);
+		assertFalse("No PropertyPlaceholderConfigurer found", beans.isEmpty());
 		String s = (String) applicationContext.getBean("string");
 		assertEquals("Properties replaced", "${bar}", s);
 	}

org.springframework.context/src/test/java/org/springframework/context/expression/ApplicationContextExpressionTests.java

@@ -240,7 +240,6 @@ public class ApplicationContextExpressionTests {
 			System.getProperties().remove("country");
 			System.getProperties().remove("name");
 		}
-		System.out.println(sw.getTotalTimeMillis());
 		assertTrue("Prototype creation took too long: " + sw.getTotalTimeMillis(), sw.getTotalTimeMillis() < 6000);
 	}
 

org.springframework.context/src/test/java/org/springframework/context/expression/EnvironmentAccessorIntegrationTests.java

@@ -0,0 +1,58 @@
+/*
+ * 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.context.expression;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertThat;
+import static org.springframework.beans.factory.support.BeanDefinitionBuilder.genericBeanDefinition;
+
+import java.util.HashMap;
+
+import org.junit.Test;
+import org.springframework.beans.factory.support.DefaultListableBeanFactory;
+import org.springframework.context.support.AbstractApplicationContext;
+import org.springframework.context.support.GenericApplicationContext;
+
+import test.beans.TestBean;
+
+
+/**
+ * Integration tests for {@link EnvironmentAccessor}, which is registered with
+ * SpEL for all {@link AbstractApplicationContext} implementations via
+ * {@link StandardBeanExpressionResolver}.
+ *
+ * @author Chris Beams
+ */
+public class EnvironmentAccessorIntegrationTests {
+
+	@Test
+	@SuppressWarnings("all")
+	public void braceAccess() {
+		DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
+		bf.registerBeanDefinition("testBean",
+				genericBeanDefinition(TestBean.class)
+					.addPropertyValue("name", "#{environment['my.name']}")
+					.getBeanDefinition());
+
+		GenericApplicationContext ctx = new GenericApplicationContext(bf);
+		ctx.getEnvironment().addPropertySource("testMap", new HashMap() {{ put("my.name", "myBean"); }});
+		ctx.refresh();
+
+		assertThat(ctx.getBean(TestBean.class).getName(), equalTo("myBean"));
+	}
+
+}

org.springframework.context/src/test/java/org/springframework/context/support/EnvironmentAwarePropertyPlaceholderConfigurerTests.java

@@ -0,0 +1,91 @@
+/*
+ * 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.context.support;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertThat;
+import static org.springframework.beans.factory.support.BeanDefinitionBuilder.genericBeanDefinition;
+
+import org.junit.Test;
+import org.springframework.beans.factory.support.DefaultListableBeanFactory;
+import org.springframework.mock.env.MockEnvironment;
+
+import test.beans.TestBean;
+
+/**
+ * Unit tests for {@link EnvironmentAwarePropertyPlaceholderConfigurer}.
+ * 
+ * @author Chris Beams
+ * @since 3.1
+ * @see EnvironmentAwarePropertyPlaceholderConfigurerTests
+ */
+public class EnvironmentAwarePropertyPlaceholderConfigurerTests {
+
+	@Test(expected=IllegalArgumentException.class)
+	public void environmentNotNull() {
+		new EnvironmentAwarePropertyPlaceholderConfigurer().postProcessBeanFactory(new DefaultListableBeanFactory());
+	}
+
+	@Test
+	public void localPropertiesOverrideFalse() {
+		localPropertiesOverride(false);
+	}
+
+	@Test
+	public void localPropertiesOverrideTrue() {
+		localPropertiesOverride(true);
+	}
+
+	private void localPropertiesOverride(boolean override) {
+		DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
+		bf.registerBeanDefinition("testBean",
+				genericBeanDefinition(TestBean.class)
+					.addPropertyValue("name", "${foo}")
+					.getBeanDefinition());
+
+		EnvironmentAwarePropertyPlaceholderConfigurer ppc = new EnvironmentAwarePropertyPlaceholderConfigurer();
+
+		ppc.setLocalOverride(override);
+		ppc.setProperties(MockEnvironment.withProperty("foo", "local").asProperties());
+		ppc.setEnvironment(MockEnvironment.withProperty("foo", "enclosing"));
+		ppc.postProcessBeanFactory(bf);
+		if (override) {
+			assertThat(bf.getBean(TestBean.class).getName(), equalTo("local"));
+		} else {
+			assertThat(bf.getBean(TestBean.class).getName(), equalTo("enclosing"));
+		}
+	}
+
+	@Test
+	public void simpleReplacement() {
+		DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
+		bf.registerBeanDefinition("testBean",
+				genericBeanDefinition(TestBean.class)
+					.addPropertyValue("name", "${my.name}")
+					.getBeanDefinition());
+
+		MockEnvironment env = new MockEnvironment();
+		env.setProperty("my.name", "myValue");
+
+		EnvironmentAwarePropertyPlaceholderConfigurer ppc =
+			new EnvironmentAwarePropertyPlaceholderConfigurer();
+		ppc.setEnvironment(env);
+		ppc.postProcessBeanFactory(bf);
+		assertThat(bf.getBean(TestBean.class).getName(), equalTo("myValue"));
+	}
+
+}

org.springframework.context/src/test/java/org/springframework/mock/env/MockEnvironment.java

@@ -0,0 +1,48 @@
+/*
+ * 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.mock.env;
+
+import org.springframework.core.env.AbstractEnvironment;
+import org.springframework.core.env.ConfigurableEnvironment;
+
+
+/**
+ * Simple {@link ConfigurableEnvironment} implementation exposing a
+ * {@link #setProperty(String, String)} and {@link #withProperty(String, String)}
+ * methods for testing purposes.
+ * 
+ * @author Chris Beams
+ * @see MockPropertySource
+ */
+public class MockEnvironment extends AbstractEnvironment {
+
+	private MockPropertySource propertySource = new MockPropertySource();
+
+	public MockEnvironment() {
+		getPropertySources().add(propertySource);
+	}
+
+	public void setProperty(String key, String value) {
+		propertySource.setProperty(key, value);
+	}
+
+	public static MockEnvironment withProperty(String key, String value) {
+		MockEnvironment environment = new MockEnvironment();
+		environment.setProperty(key, value);
+		return environment;
+	}
+}

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

@@ -0,0 +1,42 @@
+/*
+ * 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.mock.env;
+
+import java.util.Properties;
+
+import org.springframework.core.env.PropertiesPropertySource;
+
+public class MockPropertySource extends PropertiesPropertySource {
+
+	public MockPropertySource() {
+		this(new Properties());
+	}
+
+	private MockPropertySource(Properties properties) {
+		super("mockProperties", properties);
+	}
+
+	public void setProperty(String key, String value) {
+		this.source.setProperty(key, value);
+	}
+
+	public static MockPropertySource withProperty(String key, String value) {
+		Properties properties = new Properties();
+		properties.setProperty(key, value);
+		return new MockPropertySource(properties);
+	}
+}