Re-adding ConfigurationPostProcessorTests after its brief removal in r814. @Ignore-ing the testCglibClassesAreLoadedJustInTimeForEnhancement() method as it turns out this was one of the culprits in the recent build breakage. The classloader hacking causes subtle downstream effects, breaking unrelated tests. The test method is still useful, but should only be run on a manual basis to ensure CGLIB is not prematurely classloaded, and should not be run as part of the automated build.

org.springframework.context/src/test/java/org/springframework/context/annotation/support/ConfigurationPostProcessorTests.java

@@ -0,0 +1,146 @@
+/*
+ * Copyright 2002-2009 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.support;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+import static org.springframework.beans.factory.support.BeanDefinitionBuilder.*;
+
+import java.lang.reflect.Field;
+import java.util.Vector;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import org.springframework.beans.factory.support.DefaultListableBeanFactory;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.util.ClassUtils;
+
+
+/**
+ * Unit tests for {@link ConfigurationClassPostProcessor}.
+ *
+ * @author Chris Beams
+ */
+public class ConfigurationPostProcessorTests {
+
+	private static final String ORIG_CGLIB_TEST_CLASS = ConfigurationClassPostProcessor.CGLIB_TEST_CLASS;
+	private static final String BOGUS_CGLIB_TEST_CLASS = "a.bogus.class";
+
+	/**
+	 * CGLIB is an optional dependency for Spring.  If users attempt
+	 * to use {@link Configuration} classes, they'll need it on the classpath;
+	 * if Configuration classes are present in the bean factory and CGLIB
+	 * is not present, an instructive exception should be thrown.
+	 */
+	@Test
+	public void testFailFastIfCglibNotPresent() {
+		@Configuration class Config { }
+
+		DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
+		factory.registerBeanDefinition("config", rootBeanDefinition(Config.class).getBeanDefinition());
+		ConfigurationClassPostProcessor cpp = new ConfigurationClassPostProcessor();
+
+		// temporarily set the cglib test class to something bogus
+		ConfigurationClassPostProcessor.CGLIB_TEST_CLASS = BOGUS_CGLIB_TEST_CLASS;
+
+		try {
+			cpp.postProcessBeanFactory(factory);
+		} catch (RuntimeException ex) {
+			assertTrue(ex.getMessage().contains("CGLIB is required to process @Configuration classes"));
+		} finally {
+			ConfigurationClassPostProcessor.CGLIB_TEST_CLASS = ORIG_CGLIB_TEST_CLASS;
+		}
+	}
+
+	/**
+	 * In order to keep Spring's footprint as small as possible, CGLIB must
+	 * not be required on the classpath unless the user is taking advantage
+	 * of {@link Configuration} classes.
+	 * 
+	 * This test will fail if any CGLIB classes are classloaded before the call
+	 * to {@link ConfigurationClassPostProcessor#enhanceConfigurationClasses}
+	 */
+	@Ignore @Test // because classloader hacking below causes extremely hard to
+	              // debug downstream side effects. Re-enable at will to verify
+	              // CGLIB is not prematurely classloaded, but this technique is
+	              // not stable enough to leave enabled.
+	public void testCglibClassesAreLoadedJustInTimeForEnhancement() throws Exception {
+		ClassLoader classLoader = ClassUtils.getDefaultClassLoader();
+		Field classesField = ClassLoader.class.getDeclaredField("classes");
+		classesField.setAccessible(true);
+
+		// first, remove any CGLIB classes that may have been loaded by other tests
+		@SuppressWarnings("unchecked")
+		Vector<Class<?>> classes = (Vector<Class<?>>) classesField.get(classLoader);
+
+		Vector<Class<?>> cglibClassesAlreadyLoaded = new Vector<Class<?>>();
+		for(Class<?> loadedClass : classes)
+			if(loadedClass.getName().startsWith("net.sf.cglib"))
+				cglibClassesAlreadyLoaded.add(loadedClass);
+
+		for(Class<?> cglibClass : cglibClassesAlreadyLoaded)
+			classes.remove(cglibClass);
+
+		// now, execute a scenario where everything except enhancement occurs
+		// -- no CGLIB classes should get loaded!
+		testFailFastIfCglibNotPresent();
+
+		// test to ensure that indeed no CGLIB classes have been loaded
+		for(Class<?> loadedClass : classes)
+			if(loadedClass.getName().startsWith("net.sf.cglib"))
+				fail("CGLIB class should not have been eagerly loaded: " + loadedClass.getName());
+	}
+
+	/**
+	 * Enhanced {@link Configuration} classes are only necessary for respecting
+	 * certain bean semantics, like singleton-scoping, scoped proxies, etc.
+	 * 
+	 * Technically, {@link ConfigurationClassPostProcessor} could fail to enhance the
+	 * registered Configuration classes and many use cases would still work.
+	 * Certain cases, however, like inter-bean singleton references would not.
+	 * We test for such a case below, and in doing so prove that enhancement is
+	 * working.
+	 */
+	@Test
+	public void testEnhancementIsPresentBecauseSingletonSemanticsAreRespected() {
+		DefaultListableBeanFactory beanFactory = new  DefaultListableBeanFactory();
+		beanFactory.registerBeanDefinition("config",
+				rootBeanDefinition(SingletonBeanConfig.class).getBeanDefinition());
+		new ConfigurationClassPostProcessor().postProcessBeanFactory(beanFactory);
+		Foo foo = (Foo) beanFactory.getBean("foo");
+		Bar bar = (Bar) beanFactory.getBean("bar");
+		assertThat(foo, sameInstance(bar.foo));
+	}
+
+	@Configuration
+	static class SingletonBeanConfig {
+		public @Bean Foo foo() {
+			return new Foo();
+		}
+
+		public @Bean Bar bar() {
+			return new Bar(foo());
+		}
+	}
+
+	static class Foo { }
+	static class Bar {
+		final Foo foo;
+		public Bar(Foo foo) { this.foo = foo; }
+	}
+	
+}