Verify scope support for 'lite' @Beans in the TCF

Introduced AtBeanLiteModeScopeTests integration tests to verify proper 
scoping of beans created in 'lite' mode.

Updated comments in TACCWithoutACTests to better reflect the runtime 
behavior for 'lite' @Bean methods.

Issue: SPR-9401

spring-test/src/test/java/org/springframework/test/context/junit4/spr9051/AtBeanLiteModeScopeTests.java

@@ -0,0 +1,104 @@
+/*
+ * 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.spr9051;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+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.ApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Scope;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+/**
+ * Integration tests that verify proper scoping of beans created in
+ * <em>{@code @Bean} Lite Mode</em>.
+ * 
+ * @author Sam Brannen
+ * @since 3.2
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration(classes = AtBeanLiteModeScopeTests.LiteBeans.class)
+public class AtBeanLiteModeScopeTests {
+
+	/**
+	 * This is intentionally <b>not</b> annotated with {@code @Configuration}.
+	 */
+	static class LiteBeans {
+
+		@Bean
+		public LifecycleBean singleton() {
+			LifecycleBean bean = new LifecycleBean("singleton");
+			assertFalse(bean.isInitialized());
+			return bean;
+		}
+
+		@Bean
+		@Scope("prototype")
+		public LifecycleBean prototype() {
+			LifecycleBean bean = new LifecycleBean("prototype");
+			assertFalse(bean.isInitialized());
+			return bean;
+		}
+	}
+
+
+	@Autowired
+	private ApplicationContext applicationContext;
+
+	@Autowired
+	@Qualifier("singleton")
+	private LifecycleBean injectedSingletonBean;
+
+	@Autowired
+	@Qualifier("prototype")
+	private LifecycleBean injectedPrototypeBean;
+
+
+	@Test
+	public void singletonLiteBean() {
+		assertNotNull(injectedSingletonBean);
+		assertTrue(injectedSingletonBean.isInitialized());
+
+		LifecycleBean retrievedSingletonBean = applicationContext.getBean("singleton", LifecycleBean.class);
+		assertNotNull(retrievedSingletonBean);
+		assertTrue(retrievedSingletonBean.isInitialized());
+
+		assertSame(injectedSingletonBean, retrievedSingletonBean);
+	}
+
+	@Test
+	public void prototypeLiteBean() {
+		assertNotNull(injectedPrototypeBean);
+		assertTrue(injectedPrototypeBean.isInitialized());
+
+		LifecycleBean retrievedPrototypeBean = applicationContext.getBean("prototype", LifecycleBean.class);
+		assertNotNull(retrievedPrototypeBean);
+		assertTrue(retrievedPrototypeBean.isInitialized());
+
+		assertNotSame(injectedPrototypeBean, retrievedPrototypeBean);
+	}
+
+}

spring-test/src/test/java/org/springframework/test/context/junit4/spr9051/TransactionalAnnotatedConfigClassesWithoutAtConfigurationTests.java

@@ -73,21 +73,23 @@ public class TransactionalAnnotatedConfigClassesWithoutAtConfigurationTests exte
 
 		/**
 		 * Since this method does not reside in a true {@code @Configuration class},
-		 * it acts as a factory method instead of a singleton bean. The result is
+		 * it acts as a factory method when invoked directly (e.g., from
-		 * that this method will be called at least twice:
+		 * {@link #transactionManager()}) and as a singleton bean when retrieved 
+		 * through the application context (e.g., when injected into the test
+		 * instance). The result is that this method will be called twice:
 		 * 
-		 * <ul>
+		 * <ol>
 		 * <li>once <em>indirectly</em> by the {@link TransactionalTestExecutionListener}
 		 * when it retrieves the {@link PlatformTransactionManager} from the
 		 * application context</li>
 		 * <li>and again when the {@link DataSource} is injected into the test
 		 * instance in {@link AbstractTransactionalAnnotatedConfigClassTests#setDataSource(DataSource)}.</li>
-		 *</ul>
+		 *</ol>
 		 *
 		 * Consequently, the {@link JdbcTemplate} used by this test instance and
 		 * the {@link PlatformTransactionManager} used by the Spring TestContext
 		 * Framework will operate on two different {@code DataSource} instances,
-		 * which is most certainly not the desired or intended behavior.
+		 * which is almost certainly not the desired or intended behavior.
 		 */
 		@Bean
 		public DataSource dataSource() {