Support ApplicationContextInitializers in the TCF

Starting with Spring 3.1 applications can specify
contextInitializerClasses via context-param and init-param in web.xml;
however, there is currently no way to have such initializers invoked in
integration testing scenarios without writing a custom
SmartContextLoader. For comprehensive integration testing it should
therefore be possible to re-use ApplicationContextInitializers in the
Spring TestContext Framework as well.

This commit makes this possible at the @ContextConfiguration level by
allowing an array of ACI types to be specified, and the out-of-the-box
SmartContextLoader implementations invoke the declared initializers at
the appropriate time.

 - Added initializers and inheritInitializers attributes to
   @ContextConfiguration.

 - Introduced support for ApplicationContextInitializers in
   ContextConfigurationAttributes, MergedContextConfiguration, and
   ContextLoaderUtils.

 - MergedContextConfiguration stores context initializer classes as a
   Set and incorporates them into the implementations of hashCode() and
   equals() for proper context caching.

 - ApplicationContextInitializers are invoked in the new
   prepareContext(GenericApplicationContext, MergedContextConfiguration)
   method in AbstractGenericContextLoader, and ordering declared via the
   Ordered interface and @Order annotation is honored.

 - Updated DelegatingSmartContextLoader to support initializers.
   Specifically, a test class may optionally declare neither XML
   configuration files nor annotated classes and instead declare only
   application context initializers. In such cases, an attempt will
   still be made to detect defaults, but their absence will not result
   an an exception.

 - Documented support for application context initializers in Javadoc
   and in the testing chapter of the reference manual.

Issue: SPR-9011

spring-test/src/test/java/org/springframework/test/context/ContextLoaderUtilsTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2011 the original author or authors.
+ * Copyright 2002-2012 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,19 +16,24 @@
 
 package org.springframework.test.context;
 
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.springframework.test.context.ContextLoaderUtils.*;
+import static org.junit.Assert.*;
 
 import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
 import org.junit.Test;
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.support.GenericApplicationContext;
 import org.springframework.test.context.support.AnnotationConfigContextLoader;
 import org.springframework.test.context.support.DelegatingSmartContextLoader;
 import org.springframework.test.context.support.GenericPropertiesContextLoader;
+import org.springframework.web.context.support.GenericWebApplicationContext;
 
 /**
  * Unit tests for {@link ContextLoaderUtils}.
@@ -40,6 +45,8 @@ public class ContextLoaderUtilsTests {
 
 	private static final Class<?>[] EMPTY_CLASS_ARRAY = new Class<?>[0];
 	private static final String[] EMPTY_STRING_ARRAY = new String[0];
+	private static final Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> EMPTY_INITIALIZER_CLASSES = //
+	Collections.<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> emptySet();
 
 
 	private void assertAttributes(ContextConfigurationAttributes attributes, Class<?> expectedDeclaringClass,
@@ -72,9 +79,20 @@ public class ContextLoaderUtilsTests {
 			AnnotationConfigContextLoader.class, true);
 	}
 
-	private void assertMergedContextConfiguration(MergedContextConfiguration mergedConfig, Class<?> expectedTestClass,
+	private void assertMergedConfig(MergedContextConfiguration mergedConfig, Class<?> expectedTestClass,
 			String[] expectedLocations, Class<?>[] expectedClasses,
 			Class<? extends ContextLoader> expectedContextLoaderClass) {
+		assertMergedConfig(mergedConfig, expectedTestClass, expectedLocations, expectedClasses,
+			EMPTY_INITIALIZER_CLASSES, expectedContextLoaderClass);
+	}
+
+	private void assertMergedConfig(
+			MergedContextConfiguration mergedConfig,
+			Class<?> expectedTestClass,
+			String[] expectedLocations,
+			Class<?>[] expectedClasses,
+			Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> expectedInitializerClasses,
+			Class<? extends ContextLoader> expectedContextLoaderClass) {
 		assertNotNull(mergedConfig);
 		assertEquals(expectedTestClass, mergedConfig.getTestClass());
 		assertNotNull(mergedConfig.getLocations());
@@ -83,16 +101,18 @@ public class ContextLoaderUtilsTests {
 		assertArrayEquals(expectedClasses, mergedConfig.getClasses());
 		assertNotNull(mergedConfig.getActiveProfiles());
 		assertEquals(expectedContextLoaderClass, mergedConfig.getContextLoader().getClass());
+		assertNotNull(mergedConfig.getContextInitializerClasses());
+		assertEquals(expectedInitializerClasses, mergedConfig.getContextInitializerClasses());
 	}
 
 	@Test(expected = IllegalStateException.class)
-	public void resolveContextConfigurationAttributesWithConflictingLocations() {
-		ContextLoaderUtils.resolveContextConfigurationAttributes(ConflictingLocations.class);
+	public void resolveConfigAttributesWithConflictingLocations() {
+		resolveContextConfigurationAttributes(ConflictingLocations.class);
 	}
 
 	@Test
-	public void resolveContextConfigurationAttributesWithBareAnnotations() {
-		List<ContextConfigurationAttributes> attributesList = ContextLoaderUtils.resolveContextConfigurationAttributes(BareAnnotations.class);
+	public void resolveConfigAttributesWithBareAnnotations() {
+		List<ContextConfigurationAttributes> attributesList = resolveContextConfigurationAttributes(BareAnnotations.class);
 		assertNotNull(attributesList);
 		assertEquals(1, attributesList.size());
 		assertAttributes(attributesList.get(0), BareAnnotations.class, EMPTY_STRING_ARRAY, EMPTY_CLASS_ARRAY,
@@ -100,24 +120,24 @@ public class ContextLoaderUtilsTests {
 	}
 
 	@Test
-	public void resolveContextConfigurationAttributesWithLocalAnnotationAndLocations() {
-		List<ContextConfigurationAttributes> attributesList = ContextLoaderUtils.resolveContextConfigurationAttributes(LocationsFoo.class);
+	public void resolveConfigAttributesWithLocalAnnotationAndLocations() {
+		List<ContextConfigurationAttributes> attributesList = resolveContextConfigurationAttributes(LocationsFoo.class);
 		assertNotNull(attributesList);
 		assertEquals(1, attributesList.size());
 		assertLocationsFooAttributes(attributesList.get(0));
 	}
 
 	@Test
-	public void resolveContextConfigurationAttributesWithLocalAnnotationAndClasses() {
-		List<ContextConfigurationAttributes> attributesList = ContextLoaderUtils.resolveContextConfigurationAttributes(ClassesFoo.class);
+	public void resolveConfigAttributesWithLocalAnnotationAndClasses() {
+		List<ContextConfigurationAttributes> attributesList = resolveContextConfigurationAttributes(ClassesFoo.class);
 		assertNotNull(attributesList);
 		assertEquals(1, attributesList.size());
 		assertClassesFooAttributes(attributesList.get(0));
 	}
 
 	@Test
-	public void resolveContextConfigurationAttributesWithLocalAndInheritedAnnotationsAndLocations() {
-		List<ContextConfigurationAttributes> attributesList = ContextLoaderUtils.resolveContextConfigurationAttributes(LocationsBar.class);
+	public void resolveConfigAttributesWithLocalAndInheritedAnnotationsAndLocations() {
+		List<ContextConfigurationAttributes> attributesList = resolveContextConfigurationAttributes(LocationsBar.class);
 		assertNotNull(attributesList);
 		assertEquals(2, attributesList.size());
 		assertLocationsFooAttributes(attributesList.get(0));
@@ -125,8 +145,8 @@ public class ContextLoaderUtilsTests {
 	}
 
 	@Test
-	public void resolveContextConfigurationAttributesWithLocalAndInheritedAnnotationsAndClasses() {
-		List<ContextConfigurationAttributes> attributesList = ContextLoaderUtils.resolveContextConfigurationAttributes(ClassesBar.class);
+	public void resolveConfigAttributesWithLocalAndInheritedAnnotationsAndClasses() {
+		List<ContextConfigurationAttributes> attributesList = resolveContextConfigurationAttributes(ClassesBar.class);
 		assertNotNull(attributesList);
 		assertEquals(2, attributesList.size());
 		assertClassesFooAttributes(attributesList.get(0));
@@ -134,16 +154,16 @@ public class ContextLoaderUtilsTests {
 	}
 
 	@Test(expected = IllegalArgumentException.class)
-	public void buildMergedContextConfigurationWithoutAnnotation() {
-		ContextLoaderUtils.buildMergedContextConfiguration(Enigma.class, null);
+	public void buildMergedConfigWithoutAnnotation() {
+		buildMergedContextConfiguration(Enigma.class, null);
 	}
 
 	@Test
-	public void buildMergedContextConfigurationWithBareAnnotations() {
+	public void buildMergedConfigWithBareAnnotations() {
 		Class<BareAnnotations> testClass = BareAnnotations.class;
-		MergedContextConfiguration mergedConfig = ContextLoaderUtils.buildMergedContextConfiguration(testClass, null);
+		MergedContextConfiguration mergedConfig = buildMergedContextConfiguration(testClass, null);
 
-		assertMergedContextConfiguration(
+		assertMergedConfig(
 			mergedConfig,
 			testClass,
 			new String[] { "classpath:/org/springframework/test/context/ContextLoaderUtilsTests$BareAnnotations-context.xml" },
@@ -151,86 +171,159 @@ public class ContextLoaderUtilsTests {
 	}
 
 	@Test
-	public void buildMergedContextConfigurationWithLocalAnnotationAndLocations() {
+	public void buildMergedConfigWithLocalAnnotationAndLocations() {
 		Class<?> testClass = LocationsFoo.class;
-		MergedContextConfiguration mergedConfig = ContextLoaderUtils.buildMergedContextConfiguration(testClass, null);
+		MergedContextConfiguration mergedConfig = buildMergedContextConfiguration(testClass, null);
 
-		assertMergedContextConfiguration(mergedConfig, testClass, new String[] { "classpath:/foo.xml" },
-			EMPTY_CLASS_ARRAY, DelegatingSmartContextLoader.class);
+		assertMergedConfig(mergedConfig, testClass, new String[] { "classpath:/foo.xml" }, EMPTY_CLASS_ARRAY,
+			DelegatingSmartContextLoader.class);
 	}
 
 	@Test
-	public void buildMergedContextConfigurationWithLocalAnnotationAndClasses() {
+	public void buildMergedConfigWithLocalAnnotationAndClasses() {
 		Class<?> testClass = ClassesFoo.class;
-		MergedContextConfiguration mergedConfig = ContextLoaderUtils.buildMergedContextConfiguration(testClass, null);
+		MergedContextConfiguration mergedConfig = buildMergedContextConfiguration(testClass, null);
 
-		assertMergedContextConfiguration(mergedConfig, testClass, EMPTY_STRING_ARRAY,
-			new Class<?>[] { FooConfig.class }, DelegatingSmartContextLoader.class);
+		assertMergedConfig(mergedConfig, testClass, EMPTY_STRING_ARRAY, new Class<?>[] { FooConfig.class },
+			DelegatingSmartContextLoader.class);
 	}
 
 	@Test
-	public void buildMergedContextConfigurationWithLocalAnnotationAndOverriddenContextLoaderAndLocations() {
+	public void buildMergedConfigWithLocalAnnotationAndOverriddenContextLoaderAndLocations() {
 		Class<?> testClass = LocationsFoo.class;
 		Class<? extends ContextLoader> expectedContextLoaderClass = GenericPropertiesContextLoader.class;
-		MergedContextConfiguration mergedConfig = ContextLoaderUtils.buildMergedContextConfiguration(testClass,
+		MergedContextConfiguration mergedConfig = buildMergedContextConfiguration(testClass,
 			expectedContextLoaderClass.getName());
 
-		assertMergedContextConfiguration(mergedConfig, testClass, new String[] { "classpath:/foo.xml" },
-			EMPTY_CLASS_ARRAY, expectedContextLoaderClass);
+		assertMergedConfig(mergedConfig, testClass, new String[] { "classpath:/foo.xml" }, EMPTY_CLASS_ARRAY,
+			expectedContextLoaderClass);
 	}
 
 	@Test
-	public void buildMergedContextConfigurationWithLocalAnnotationAndOverriddenContextLoaderAndClasses() {
+	public void buildMergedConfigWithLocalAnnotationAndOverriddenContextLoaderAndClasses() {
 		Class<?> testClass = ClassesFoo.class;
 		Class<? extends ContextLoader> expectedContextLoaderClass = GenericPropertiesContextLoader.class;
-		MergedContextConfiguration mergedConfig = ContextLoaderUtils.buildMergedContextConfiguration(testClass,
+		MergedContextConfiguration mergedConfig = buildMergedContextConfiguration(testClass,
 			expectedContextLoaderClass.getName());
 
-		assertMergedContextConfiguration(mergedConfig, testClass, EMPTY_STRING_ARRAY,
-			new Class<?>[] { FooConfig.class }, expectedContextLoaderClass);
+		assertMergedConfig(mergedConfig, testClass, EMPTY_STRING_ARRAY, new Class<?>[] { FooConfig.class },
+			expectedContextLoaderClass);
 	}
 
 	@Test
-	public void buildMergedContextConfigurationWithLocalAndInheritedAnnotationsAndLocations() {
+	public void buildMergedConfigWithLocalAndInheritedAnnotationsAndLocations() {
 		Class<?> testClass = LocationsBar.class;
 		String[] expectedLocations = new String[] { "/foo.xml", "/bar.xml" };
 
-		MergedContextConfiguration mergedConfig = ContextLoaderUtils.buildMergedContextConfiguration(testClass, null);
-		assertMergedContextConfiguration(mergedConfig, testClass, expectedLocations, EMPTY_CLASS_ARRAY,
+		MergedContextConfiguration mergedConfig = buildMergedContextConfiguration(testClass, null);
+		assertMergedConfig(mergedConfig, testClass, expectedLocations, EMPTY_CLASS_ARRAY,
 			AnnotationConfigContextLoader.class);
 	}
 
 	@Test
-	public void buildMergedContextConfigurationWithLocalAndInheritedAnnotationsAndClasses() {
+	public void buildMergedConfigWithLocalAndInheritedAnnotationsAndClasses() {
 		Class<?> testClass = ClassesBar.class;
 		Class<?>[] expectedClasses = new Class<?>[] { FooConfig.class, BarConfig.class };
 
-		MergedContextConfiguration mergedConfig = ContextLoaderUtils.buildMergedContextConfiguration(testClass, null);
-		assertMergedContextConfiguration(mergedConfig, testClass, EMPTY_STRING_ARRAY, expectedClasses,
+		MergedContextConfiguration mergedConfig = buildMergedContextConfiguration(testClass, null);
+		assertMergedConfig(mergedConfig, testClass, EMPTY_STRING_ARRAY, expectedClasses,
 			AnnotationConfigContextLoader.class);
 	}
 
+	@Test
+	public void buildMergedConfigWithAnnotationsAndOverriddenLocations() {
+		Class<?> testClass = OverriddenLocationsBar.class;
+		String[] expectedLocations = new String[] { "/bar.xml" };
+
+		MergedContextConfiguration mergedConfig = buildMergedContextConfiguration(testClass, null);
+		assertMergedConfig(mergedConfig, testClass, expectedLocations, EMPTY_CLASS_ARRAY,
+			AnnotationConfigContextLoader.class);
+	}
+
+	@Test
+	public void buildMergedConfigWithAnnotationsAndOverriddenClasses() {
+		Class<?> testClass = OverriddenClassesBar.class;
+		Class<?>[] expectedClasses = new Class<?>[] { BarConfig.class };
+
+		MergedContextConfiguration mergedConfig = buildMergedContextConfiguration(testClass, null);
+		assertMergedConfig(mergedConfig, testClass, EMPTY_STRING_ARRAY, expectedClasses,
+			AnnotationConfigContextLoader.class);
+	}
+
+	@Test
+	public void buildMergedConfigWithLocalInitializer() {
+		Class<?> testClass = InitializersFoo.class;
+		Class<?>[] expectedClasses = new Class<?>[] { FooConfig.class };
+		Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> expectedInitializerClasses//
+		= new HashSet<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>>();
+		expectedInitializerClasses.add(FooInitializer.class);
+
+		MergedContextConfiguration mergedConfig = buildMergedContextConfiguration(testClass, null);
+		assertMergedConfig(mergedConfig, testClass, EMPTY_STRING_ARRAY, expectedClasses, expectedInitializerClasses,
+			DelegatingSmartContextLoader.class);
+	}
+
+	@Test
+	public void buildMergedConfigWithLocalAndInheritedInitializer() {
+		Class<?> testClass = InitializersBar.class;
+		Class<?>[] expectedClasses = new Class<?>[] { FooConfig.class, BarConfig.class };
+		Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> expectedInitializerClasses//
+		= new HashSet<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>>();
+		expectedInitializerClasses.add(FooInitializer.class);
+		expectedInitializerClasses.add(BarInitializer.class);
+
+		MergedContextConfiguration mergedConfig = buildMergedContextConfiguration(testClass, null);
+		assertMergedConfig(mergedConfig, testClass, EMPTY_STRING_ARRAY, expectedClasses, expectedInitializerClasses,
+			DelegatingSmartContextLoader.class);
+	}
+
+	@Test
+	public void buildMergedConfigWithOverriddenInitializers() {
+		Class<?> testClass = OverriddenInitializersBar.class;
+		Class<?>[] expectedClasses = new Class<?>[] { FooConfig.class, BarConfig.class };
+		Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> expectedInitializerClasses//
+		= new HashSet<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>>();
+		expectedInitializerClasses.add(BarInitializer.class);
+
+		MergedContextConfiguration mergedConfig = buildMergedContextConfiguration(testClass, null);
+		assertMergedConfig(mergedConfig, testClass, EMPTY_STRING_ARRAY, expectedClasses, expectedInitializerClasses,
+			DelegatingSmartContextLoader.class);
+	}
+
+	@Test
+	public void buildMergedConfigWithOverriddenInitializersAndClasses() {
+		Class<?> testClass = OverriddenInitializersAndClassesBar.class;
+		Class<?>[] expectedClasses = new Class<?>[] { BarConfig.class };
+		Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> expectedInitializerClasses//
+		= new HashSet<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>>();
+		expectedInitializerClasses.add(BarInitializer.class);
+
+		MergedContextConfiguration mergedConfig = buildMergedContextConfiguration(testClass, null);
+		assertMergedConfig(mergedConfig, testClass, EMPTY_STRING_ARRAY, expectedClasses, expectedInitializerClasses,
+			DelegatingSmartContextLoader.class);
+	}
+
 	@Test
 	public void resolveActiveProfilesWithoutAnnotation() {
-		String[] profiles = ContextLoaderUtils.resolveActiveProfiles(Enigma.class);
+		String[] profiles = resolveActiveProfiles(Enigma.class);
 		assertArrayEquals(EMPTY_STRING_ARRAY, profiles);
 	}
 
 	@Test
 	public void resolveActiveProfilesWithNoProfilesDeclared() {
-		String[] profiles = ContextLoaderUtils.resolveActiveProfiles(BareAnnotations.class);
+		String[] profiles = resolveActiveProfiles(BareAnnotations.class);
 		assertArrayEquals(EMPTY_STRING_ARRAY, profiles);
 	}
 
 	@Test
 	public void resolveActiveProfilesWithEmptyProfiles() {
-		String[] profiles = ContextLoaderUtils.resolveActiveProfiles(EmptyProfiles.class);
+		String[] profiles = resolveActiveProfiles(EmptyProfiles.class);
 		assertArrayEquals(EMPTY_STRING_ARRAY, profiles);
 	}
 
 	@Test
 	public void resolveActiveProfilesWithDuplicatedProfiles() {
-		String[] profiles = ContextLoaderUtils.resolveActiveProfiles(DuplicatedProfiles.class);
+		String[] profiles = resolveActiveProfiles(DuplicatedProfiles.class);
 		assertNotNull(profiles);
 		assertEquals(3, profiles.length);
 
@@ -242,28 +335,28 @@ public class ContextLoaderUtilsTests {
 
 	@Test
 	public void resolveActiveProfilesWithLocalAnnotation() {
-		String[] profiles = ContextLoaderUtils.resolveActiveProfiles(LocationsFoo.class);
+		String[] profiles = resolveActiveProfiles(LocationsFoo.class);
 		assertNotNull(profiles);
 		assertArrayEquals(new String[] { "foo" }, profiles);
 	}
 
 	@Test
 	public void resolveActiveProfilesWithInheritedAnnotationAndLocations() {
-		String[] profiles = ContextLoaderUtils.resolveActiveProfiles(InheritedLocationsFoo.class);
+		String[] profiles = resolveActiveProfiles(InheritedLocationsFoo.class);
 		assertNotNull(profiles);
 		assertArrayEquals(new String[] { "foo" }, profiles);
 	}
 
 	@Test
 	public void resolveActiveProfilesWithInheritedAnnotationAndClasses() {
-		String[] profiles = ContextLoaderUtils.resolveActiveProfiles(InheritedClassesFoo.class);
+		String[] profiles = resolveActiveProfiles(InheritedClassesFoo.class);
 		assertNotNull(profiles);
 		assertArrayEquals(new String[] { "foo" }, profiles);
 	}
 
 	@Test
 	public void resolveActiveProfilesWithLocalAndInheritedAnnotations() {
-		String[] profiles = ContextLoaderUtils.resolveActiveProfiles(LocationsBar.class);
+		String[] profiles = resolveActiveProfiles(LocationsBar.class);
 		assertNotNull(profiles);
 		assertEquals(2, profiles.length);
 
@@ -274,7 +367,7 @@ public class ContextLoaderUtilsTests {
 
 	@Test
 	public void resolveActiveProfilesWithOverriddenAnnotation() {
-		String[] profiles = ContextLoaderUtils.resolveActiveProfiles(Animals.class);
+		String[] profiles = resolveActiveProfiles(Animals.class);
 		assertNotNull(profiles);
 		assertEquals(2, profiles.length);
 
@@ -333,13 +426,51 @@ public class ContextLoaderUtilsTests {
 	private static class LocationsBar extends LocationsFoo {
 	}
 
+	@ContextConfiguration(locations = "/bar.xml", inheritLocations = false, loader = AnnotationConfigContextLoader.class)
+	@ActiveProfiles("bar")
+	private static class OverriddenLocationsBar extends LocationsFoo {
+	}
+
 	@ContextConfiguration(classes = BarConfig.class, inheritLocations = true, loader = AnnotationConfigContextLoader.class)
 	@ActiveProfiles("bar")
 	private static class ClassesBar extends ClassesFoo {
 	}
 
+	@ContextConfiguration(classes = BarConfig.class, inheritLocations = false, loader = AnnotationConfigContextLoader.class)
+	@ActiveProfiles("bar")
+	private static class OverriddenClassesBar extends ClassesFoo {
+	}
+
 	@ActiveProfiles(profiles = { "dog", "cat" }, inheritProfiles = false)
 	private static class Animals extends LocationsBar {
 	}
 
+	private static class FooInitializer implements ApplicationContextInitializer<GenericApplicationContext> {
+
+		public void initialize(GenericApplicationContext applicationContext) {
+		}
+	}
+
+	private static class BarInitializer implements ApplicationContextInitializer<GenericWebApplicationContext> {
+
+		public void initialize(GenericWebApplicationContext applicationContext) {
+		}
+	}
+
+	@ContextConfiguration(classes = FooConfig.class, initializers = FooInitializer.class)
+	private static class InitializersFoo {
+	}
+
+	@ContextConfiguration(classes = BarConfig.class, initializers = BarInitializer.class)
+	private static class InitializersBar extends InitializersFoo {
+	}
+
+	@ContextConfiguration(classes = BarConfig.class, initializers = BarInitializer.class, inheritInitializers = false)
+	private static class OverriddenInitializersBar extends InitializersFoo {
+	}
+
+	@ContextConfiguration(classes = BarConfig.class, inheritLocations = false, initializers = BarInitializer.class, inheritInitializers = false)
+	private static class OverriddenInitializersAndClassesBar extends InitializersFoo {
+	}
+
 }

spring-test/src/test/java/org/springframework/test/context/MergedContextConfigurationTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2011 the original author or authors.
+ * Copyright 2002-2012 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,17 +16,25 @@
 
 package org.springframework.test.context;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
+
+import java.util.HashSet;
+import java.util.Set;
 
 import org.junit.Test;
+
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.context.support.GenericApplicationContext;
 import org.springframework.test.context.support.AnnotationConfigContextLoader;
 import org.springframework.test.context.support.GenericXmlContextLoader;
 
 /**
  * Unit tests for {@link MergedContextConfiguration}.
  * 
+ * <p>These tests primarily exist to ensure that {@code MergedContextConfiguration}
+ * can safely be used as the cache key for {@link ContextCache}.
+ * 
  * @author Sam Brannen
  * @since 3.1
  */
@@ -42,6 +50,7 @@ public class MergedContextConfigurationTests {
 	public void hashCodeWithNulls() {
 		MergedContextConfiguration mergedConfig1 = new MergedContextConfiguration(null, null, null, null, null);
 		MergedContextConfiguration mergedConfig2 = new MergedContextConfiguration(null, null, null, null, null);
+		assertTrue(mergedConfig1.hashCode() > 0);
 		assertEquals(mergedConfig1.hashCode(), mergedConfig2.hashCode());
 	}
 
@@ -155,6 +164,42 @@ public class MergedContextConfigurationTests {
 		assertFalse(mergedConfig1.hashCode() == mergedConfig2.hashCode());
 	}
 
+	@Test
+	public void hashCodeWithSameInitializers() {
+		Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> initializerClasses1 = //
+		new HashSet<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>>();
+		initializerClasses1.add(FooInitializer.class);
+		initializerClasses1.add(BarInitializer.class);
+
+		Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> initializerClasses2 = //
+		new HashSet<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>>();
+		initializerClasses2.add(BarInitializer.class);
+		initializerClasses2.add(FooInitializer.class);
+
+		MergedContextConfiguration mergedConfig1 = new MergedContextConfiguration(getClass(), EMPTY_STRING_ARRAY,
+			EMPTY_CLASS_ARRAY, initializerClasses1, EMPTY_STRING_ARRAY, loader);
+		MergedContextConfiguration mergedConfig2 = new MergedContextConfiguration(getClass(), EMPTY_STRING_ARRAY,
+			EMPTY_CLASS_ARRAY, initializerClasses2, EMPTY_STRING_ARRAY, loader);
+		assertEquals(mergedConfig1.hashCode(), mergedConfig2.hashCode());
+	}
+
+	@Test
+	public void hashCodeWithDifferentInitializers() {
+		Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> initializerClasses1 = //
+		new HashSet<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>>();
+		initializerClasses1.add(FooInitializer.class);
+
+		Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> initializerClasses2 = //
+		new HashSet<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>>();
+		initializerClasses2.add(BarInitializer.class);
+
+		MergedContextConfiguration mergedConfig1 = new MergedContextConfiguration(getClass(), EMPTY_STRING_ARRAY,
+			EMPTY_CLASS_ARRAY, initializerClasses1, EMPTY_STRING_ARRAY, loader);
+		MergedContextConfiguration mergedConfig2 = new MergedContextConfiguration(getClass(), EMPTY_STRING_ARRAY,
+			EMPTY_CLASS_ARRAY, initializerClasses2, EMPTY_STRING_ARRAY, loader);
+		assertFalse(mergedConfig1.hashCode() == mergedConfig2.hashCode());
+	}
+
 	@Test
 	public void equalsBasics() {
 		MergedContextConfiguration mergedConfig = new MergedContextConfiguration(null, null, null, null, null);
@@ -193,6 +238,7 @@ public class MergedContextConfigurationTests {
 		MergedContextConfiguration mergedConfig2 = new MergedContextConfiguration(getClass(), EMPTY_STRING_ARRAY,
 			EMPTY_CLASS_ARRAY, EMPTY_STRING_ARRAY, new AnnotationConfigContextLoader());
 		assertFalse(mergedConfig1.equals(mergedConfig2));
+		assertFalse(mergedConfig2.equals(mergedConfig1));
 	}
 
 	@Test
@@ -214,6 +260,7 @@ public class MergedContextConfigurationTests {
 		MergedContextConfiguration mergedConfig2 = new MergedContextConfiguration(getClass(), locations2,
 			EMPTY_CLASS_ARRAY, EMPTY_STRING_ARRAY, loader);
 		assertFalse(mergedConfig1.equals(mergedConfig2));
+		assertFalse(mergedConfig2.equals(mergedConfig1));
 	}
 
 	@Test
@@ -235,6 +282,7 @@ public class MergedContextConfigurationTests {
 		MergedContextConfiguration mergedConfig2 = new MergedContextConfiguration(getClass(), EMPTY_STRING_ARRAY,
 			classes2, EMPTY_STRING_ARRAY, loader);
 		assertFalse(mergedConfig1.equals(mergedConfig2));
+		assertFalse(mergedConfig2.equals(mergedConfig1));
 	}
 
 	@Test
@@ -278,6 +326,57 @@ public class MergedContextConfigurationTests {
 		MergedContextConfiguration mergedConfig2 = new MergedContextConfiguration(getClass(), EMPTY_STRING_ARRAY,
 			EMPTY_CLASS_ARRAY, activeProfiles2, loader);
 		assertFalse(mergedConfig1.equals(mergedConfig2));
+		assertFalse(mergedConfig2.equals(mergedConfig1));
+	}
+
+	@Test
+	public void equalsWithSameInitializers() {
+		Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> initializerClasses1 = //
+		new HashSet<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>>();
+		initializerClasses1.add(FooInitializer.class);
+		initializerClasses1.add(BarInitializer.class);
+
+		Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> initializerClasses2 = //
+		new HashSet<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>>();
+		initializerClasses2.add(BarInitializer.class);
+		initializerClasses2.add(FooInitializer.class);
+
+		MergedContextConfiguration mergedConfig1 = new MergedContextConfiguration(getClass(), EMPTY_STRING_ARRAY,
+			EMPTY_CLASS_ARRAY, initializerClasses1, EMPTY_STRING_ARRAY, loader);
+		MergedContextConfiguration mergedConfig2 = new MergedContextConfiguration(getClass(), EMPTY_STRING_ARRAY,
+			EMPTY_CLASS_ARRAY, initializerClasses2, EMPTY_STRING_ARRAY, loader);
+		assertEquals(mergedConfig1, mergedConfig2);
+	}
+
+	@Test
+	public void equalsWithDifferentInitializers() {
+		Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> initializerClasses1 = //
+		new HashSet<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>>();
+		initializerClasses1.add(FooInitializer.class);
+
+		Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> initializerClasses2 = //
+		new HashSet<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>>();
+		initializerClasses2.add(BarInitializer.class);
+
+		MergedContextConfiguration mergedConfig1 = new MergedContextConfiguration(getClass(), EMPTY_STRING_ARRAY,
+			EMPTY_CLASS_ARRAY, initializerClasses1, EMPTY_STRING_ARRAY, loader);
+		MergedContextConfiguration mergedConfig2 = new MergedContextConfiguration(getClass(), EMPTY_STRING_ARRAY,
+			EMPTY_CLASS_ARRAY, initializerClasses2, EMPTY_STRING_ARRAY, loader);
+		assertFalse(mergedConfig1.equals(mergedConfig2));
+		assertFalse(mergedConfig2.equals(mergedConfig1));
+	}
+
+
+	private static class FooInitializer implements ApplicationContextInitializer<GenericApplicationContext> {
+
+		public void initialize(GenericApplicationContext applicationContext) {
+		}
+	}
+
+	private static class BarInitializer implements ApplicationContextInitializer<GenericApplicationContext> {
+
+		public void initialize(GenericApplicationContext applicationContext) {
+		}
 	}
 
 }

spring-test/src/test/java/org/springframework/test/context/junit4/aci/AciTestSuite.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2002-2012 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.test.context.junit4.aci;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.test.context.junit4.aci.annotation.InitializerWithoutConfigFilesOrClassesTest;
+import org.springframework.test.context.junit4.aci.annotation.MergedInitializersAnnotationConfigTests;
+import org.springframework.test.context.junit4.aci.annotation.MultipleInitializersAnnotationConfigTests;
+import org.springframework.test.context.junit4.aci.annotation.OrderedInitializersAnnotationConfigTests;
+import org.springframework.test.context.junit4.aci.annotation.OverriddenInitializersAnnotationConfigTests;
+import org.springframework.test.context.junit4.aci.annotation.SingleInitializerAnnotationConfigTests;
+import org.springframework.test.context.junit4.aci.xml.MultipleInitializersXmlConfigTests;
+
+/**
+ * Convenience test suite for integration tests that verify support for
+ * {@link ApplicationContextInitializer ApplicationContextInitializers} (ACIs)
+ * in the TestContext framework.
+ *
+ * @author Sam Brannen
+ * @since 3.2
+ */
+@RunWith(Suite.class)
+// Note: the following 'multi-line' layout is for enhanced code readability.
+@SuiteClasses({//
+	MultipleInitializersXmlConfigTests.class,//
+	SingleInitializerAnnotationConfigTests.class,//
+	MultipleInitializersAnnotationConfigTests.class,//
+	MergedInitializersAnnotationConfigTests.class,//
+	OverriddenInitializersAnnotationConfigTests.class,//
+	OrderedInitializersAnnotationConfigTests.class,//
+	InitializerWithoutConfigFilesOrClassesTest.class //
+})
+public class AciTestSuite {
+}

spring-test/src/test/java/org/springframework/test/context/junit4/aci/DevProfileInitializer.java

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2002-2012 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.test.context.junit4.aci;
+
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.context.support.GenericApplicationContext;
+
+/**
+ * @author Sam Brannen
+ * @since 3.2
+ */
+public class DevProfileInitializer implements ApplicationContextInitializer<GenericApplicationContext> {
+
+	public void initialize(GenericApplicationContext applicationContext) {
+		applicationContext.getEnvironment().setActiveProfiles("dev");
+	}
+}

spring-test/src/test/java/org/springframework/test/context/junit4/aci/FooBarAliasInitializer.java

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2002-2012 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.test.context.junit4.aci;
+
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.context.support.GenericApplicationContext;
+
+/**
+ * @author Sam Brannen
+ * @since 3.2
+ */
+public class FooBarAliasInitializer implements ApplicationContextInitializer<GenericApplicationContext> {
+
+	public void initialize(GenericApplicationContext applicationContext) {
+		applicationContext.registerAlias("foo", "bar");
+	}
+}

spring-test/src/test/java/org/springframework/test/context/junit4/aci/annotation/DevProfileConfig.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2002-2012 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.test.context.junit4.aci.annotation;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
+
+/**
+ * @author Sam Brannen
+ * @since 3.2
+ */
+@Configuration
+@Profile("dev")
+class DevProfileConfig {
+
+	@Bean
+	public String baz() {
+		return "dev profile config";
+	}
+}

spring-test/src/test/java/org/springframework/test/context/junit4/aci/annotation/GlobalConfig.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2002-2012 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.test.context.junit4.aci.annotation;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * @author Sam Brannen
+ * @since 3.2
+ */
+@Configuration
+class GlobalConfig {
+
+	@Bean
+	public String foo() {
+		return "foo";
+	}
+
+	@Bean
+	public String baz() {
+		return "global config";
+	}
+}

spring-test/src/test/java/org/springframework/test/context/junit4/aci/annotation/InitializerWithoutConfigFilesOrClassesTest.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2002-2012 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.test.context.junit4.aci.annotation;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.context.annotation.AnnotatedBeanDefinitionReader;
+import org.springframework.context.support.GenericApplicationContext;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.junit4.aci.annotation.InitializerWithoutConfigFilesOrClassesTest.EntireAppInitializer;
+
+/**
+ * Integration test that verifies support for {@link ApplicationContextInitializer
+ * ApplicationContextInitializers} in the TestContext framework when the test
+ * class declares neither XML configuration files nor annotated configuration classes.
+ *
+ * @author Sam Brannen
+ * @since 3.2
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(initializers = EntireAppInitializer.class)
+public class InitializerWithoutConfigFilesOrClassesTest {
+
+	@Autowired
+	private String foo;
+
+
+	@Test
+	public void foo() {
+		assertEquals("foo", foo);
+	}
+
+
+	static class EntireAppInitializer implements ApplicationContextInitializer<GenericApplicationContext> {
+
+		public void initialize(GenericApplicationContext applicationContext) {
+			new AnnotatedBeanDefinitionReader(applicationContext).register(GlobalConfig.class);
+		}
+	}
+
+}

spring-test/src/test/java/org/springframework/test/context/junit4/aci/annotation/MergedInitializersAnnotationConfigTests.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2002-2012 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.test.context.junit4.aci.annotation;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.aci.DevProfileInitializer;
+
+/**
+ * Integration tests that verify support for {@link ApplicationContextInitializer
+ * ApplicationContextInitializers} in conjunction with annotation-driven
+ * configuration in the TestContext framework.
+ *
+ * @author Sam Brannen
+ * @since 3.2
+ */
+@ContextConfiguration(initializers = DevProfileInitializer.class)
+public class MergedInitializersAnnotationConfigTests extends SingleInitializerAnnotationConfigTests {
+
+	@Test
+	public void activeBeans() {
+		assertEquals("foo", foo);
+		assertEquals("foo", bar);
+		assertEquals("dev profile config", baz);
+	}
+}

spring-test/src/test/java/org/springframework/test/context/junit4/aci/annotation/MultipleInitializersAnnotationConfigTests.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2002-2012 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.test.context.junit4.aci.annotation;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.junit4.aci.DevProfileInitializer;
+import org.springframework.test.context.junit4.aci.FooBarAliasInitializer;
+
+/**
+ * Integration tests that verify support for {@link ApplicationContextInitializer
+ * ApplicationContextInitializers} in conjunction with annotation-driven
+ * configuration in the TestContext framework.
+ *
+ * @author Sam Brannen
+ * @since 3.2
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { GlobalConfig.class, DevProfileConfig.class }, initializers = {
+	FooBarAliasInitializer.class, DevProfileInitializer.class })
+public class MultipleInitializersAnnotationConfigTests {
+
+	@Autowired
+	private String foo, bar, baz;
+
+
+	@Test
+	public void activeBeans() {
+		assertEquals("foo", foo);
+		assertEquals("foo", bar);
+		assertEquals("dev profile config", baz);
+	}
+
+}

spring-test/src/test/java/org/springframework/test/context/junit4/aci/annotation/OrderedInitializersAnnotationConfigTests.java

@@ -0,0 +1,145 @@
+/*
+ * Copyright 2002-2012 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.test.context.junit4.aci.annotation;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Profile;
+import org.springframework.context.support.GenericApplicationContext;
+import org.springframework.core.Ordered;
+import org.springframework.core.annotation.Order;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.junit4.aci.annotation.OrderedInitializersAnnotationConfigTests.ConfigTwo;
+import org.springframework.test.context.junit4.aci.annotation.OrderedInitializersAnnotationConfigTests.ConfigOne;
+import org.springframework.test.context.junit4.aci.annotation.OrderedInitializersAnnotationConfigTests.GlobalConfig;
+import org.springframework.test.context.junit4.aci.annotation.OrderedInitializersAnnotationConfigTests.OrderedOneInitializer;
+import org.springframework.test.context.junit4.aci.annotation.OrderedInitializersAnnotationConfigTests.OrderedTwoInitializer;
+
+/**
+ * Integration tests that verify that any {@link ApplicationContextInitializer
+ * ApplicationContextInitializers} implementing
+ * {@link org.springframework.core.Ordered Ordered} or marked with
+ * {@link org.springframework.core.annotation.Order @Order} will be sorted
+ * appropriately in conjunction with annotation-driven configuration in the
+ * TestContext framework.
+ *
+ * @author Sam Brannen
+ * @since 3.2
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+// Note: the ordering of the config classes is intentionally: global, two, one.
+// Note: the ordering of the initializers is intentionally: two, one.
+@ContextConfiguration(classes = { GlobalConfig.class, ConfigTwo.class, ConfigOne.class }, initializers = {
+	OrderedTwoInitializer.class, OrderedOneInitializer.class })
+public class OrderedInitializersAnnotationConfigTests {
+
+	private static final String PROFILE_GLOBAL = "global";
+	private static final String PROFILE_ONE = "one";
+	private static final String PROFILE_TWO = "two";
+
+	@Autowired
+	private String foo, bar, baz;
+
+
+	@Test
+	public void activeBeans() {
+		assertEquals(PROFILE_GLOBAL, foo);
+		assertEquals(PROFILE_GLOBAL, bar);
+		assertEquals(PROFILE_TWO, baz);
+	}
+
+
+	// -------------------------------------------------------------------------
+
+	@Configuration
+	static class GlobalConfig {
+
+		@Bean
+		public String foo() {
+			return PROFILE_GLOBAL;
+		}
+
+		@Bean
+		public String bar() {
+			return PROFILE_GLOBAL;
+		}
+
+		@Bean
+		public String baz() {
+			return PROFILE_GLOBAL;
+		}
+	}
+
+	@Configuration
+	@Profile(PROFILE_ONE)
+	static class ConfigOne {
+
+		@Bean
+		public String foo() {
+			return PROFILE_ONE;
+		}
+
+		@Bean
+		public String bar() {
+			return PROFILE_ONE;
+		}
+
+		@Bean
+		public String baz() {
+			return PROFILE_ONE;
+		}
+	}
+
+	@Configuration
+	@Profile(PROFILE_TWO)
+	static class ConfigTwo {
+
+		@Bean
+		public String baz() {
+			return PROFILE_TWO;
+		}
+	}
+
+	// -------------------------------------------------------------------------
+
+	static class OrderedOneInitializer implements ApplicationContextInitializer<GenericApplicationContext>, Ordered {
+
+		public void initialize(GenericApplicationContext applicationContext) {
+			applicationContext.getEnvironment().setActiveProfiles(PROFILE_ONE);
+		}
+
+		public int getOrder() {
+			return 1;
+		}
+	}
+
+	@Order(2)
+	static class OrderedTwoInitializer implements ApplicationContextInitializer<GenericApplicationContext> {
+
+		public void initialize(GenericApplicationContext applicationContext) {
+			applicationContext.getEnvironment().setActiveProfiles(PROFILE_TWO);
+		}
+	}
+
+}

spring-test/src/test/java/org/springframework/test/context/junit4/aci/annotation/OverriddenInitializersAnnotationConfigTests.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2002-2012 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.test.context.junit4.aci.annotation;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.aci.DevProfileInitializer;
+
+/**
+ * Integration tests that verify support for {@link ApplicationContextInitializer
+ * ApplicationContextInitializers} in conjunction with annotation-driven
+ * configuration in the TestContext framework.
+ *
+ * @author Sam Brannen
+ * @since 3.2
+ */
+@ContextConfiguration(initializers = DevProfileInitializer.class, inheritInitializers = false)
+public class OverriddenInitializersAnnotationConfigTests extends SingleInitializerAnnotationConfigTests {
+
+	@Test
+	@Override
+	public void activeBeans() {
+		assertEquals("foo", foo);
+		assertNull(bar);
+		assertEquals("dev profile config", baz);
+	}
+}

spring-test/src/test/java/org/springframework/test/context/junit4/aci/annotation/SingleInitializerAnnotationConfigTests.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2002-2012 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.test.context.junit4.aci.annotation;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.junit4.aci.FooBarAliasInitializer;
+
+/**
+ * Integration tests that verify support for {@link ApplicationContextInitializer
+ * ApplicationContextInitializers} in conjunction with annotation-driven
+ * configuration in the TestContext framework.
+ *
+ * @author Sam Brannen
+ * @since 3.2
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = { GlobalConfig.class, DevProfileConfig.class }, initializers = FooBarAliasInitializer.class)
+public class SingleInitializerAnnotationConfigTests {
+
+	@Autowired
+	protected String foo;
+
+	@Autowired(required = false)
+	@Qualifier("bar")
+	protected String bar;
+
+	@Autowired
+	protected String baz;
+
+
+	@Test
+	public void activeBeans() {
+		assertEquals("foo", foo);
+		assertEquals("foo", bar);
+		assertEquals("global config", baz);
+	}
+
+}

spring-test/src/test/java/org/springframework/test/context/junit4/aci/xml/MultipleInitializersXmlConfigTests-context.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
+
+	<bean id="foo" class="java.lang.String">
+		<constructor-arg value="foo" />
+	</bean>
+
+	<bean id="baz" class="java.lang.String">
+		<constructor-arg value="global config" />
+	</bean>
+
+	<beans profile="dev">
+		<bean id="baz" class="java.lang.String">
+			<constructor-arg value="dev profile config" />
+		</bean>
+	</beans>
+
+</beans>

spring-test/src/test/java/org/springframework/test/context/junit4/aci/xml/MultipleInitializersXmlConfigTests.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2002-2012 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.test.context.junit4.aci.xml;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.ApplicationContextInitializer;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.junit4.aci.DevProfileInitializer;
+import org.springframework.test.context.junit4.aci.FooBarAliasInitializer;
+
+/**
+ * Integration tests that verify support for {@link ApplicationContextInitializer
+ * ApplicationContextInitializers} in conjunction with XML configuration files
+ * in the TestContext framework.
+ *
+ * @author Sam Brannen
+ * @since 3.2
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(initializers = { FooBarAliasInitializer.class, DevProfileInitializer.class })
+public class MultipleInitializersXmlConfigTests {
+
+	@Autowired
+	private String foo, bar, baz;
+
+
+	@Test
+	public void activeBeans() {
+		assertEquals("foo", foo);
+		assertEquals("foo", bar);
+		assertEquals("dev profile config", baz);
+	}
+
+}