Log context cache statistics in the TCF

Prior to this commit, finding out how many application contexts had
been loaded within a test suite required the use of reflection and a
bit of hacking.

This commit addresses this issue by logging ContextCache statistics
whenever an application context is loaded by the Spring TestContext
Framework (TCF).

The log output can be enabled by setting the
"org.springframework.test.context.cache" logging category to DEBUG.

Issue: SPR-12409
(cherry picked from commit a09bc9b)

Author: jhoeller

spring-test/src/main/java/org/springframework/test/context/CacheAwareContextLoaderDelegate.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2013 the original author or authors.
+ * Copyright 2002-2014 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.
@@ -18,6 +18,7 @@
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+
 import org.springframework.context.ApplicationContext;
 import org.springframework.util.Assert;
 
@@ -37,6 +38,8 @@ public class CacheAwareContextLoaderDelegate {
 
 	private static final Log logger = LogFactory.getLog(CacheAwareContextLoaderDelegate.class);
 
+	private static final Log statsLogger = LogFactory.getLog("org.springframework.test.context.cache");
+
 	private final ContextCache contextCache;
 
 
@@ -45,6 +48,7 @@ public class CacheAwareContextLoaderDelegate {
 		this.contextCache = contextCache;
 	}
 
+
 	/**
 	 * Load the {@code ApplicationContext} for the supplied merged context
 	 * configuration. Supports both the {@link SmartContextLoader} and
@@ -53,9 +57,10 @@ public class CacheAwareContextLoaderDelegate {
 	 */
 	private ApplicationContext loadContextInternal(MergedContextConfiguration mergedContextConfiguration)
 			throws Exception {
+
 		ContextLoader contextLoader = mergedContextConfiguration.getContextLoader();
-		Assert.notNull(contextLoader, "Cannot load an ApplicationContext with a NULL 'contextLoader'. "
-				+ "Consider annotating your test class with @ContextConfiguration or @ContextHierarchy.");
+		Assert.notNull(contextLoader, "Cannot load an ApplicationContext with a NULL 'contextLoader'. " +
+				"Consider annotating your test class with @ContextConfiguration or @ContextHierarchy.");
 
 		ApplicationContext applicationContext;
 
@@ -65,8 +70,8 @@ private ApplicationContext loadContextInternal(MergedContextConfiguration merged
 		}
 		else {
 			String[] locations = mergedContextConfiguration.getLocations();
-			Assert.notNull(locations, "Cannot load an ApplicationContext with a NULL 'locations' array. "
-					+ "Consider annotating your test class with @ContextConfiguration or @ContextHierarchy.");
+			Assert.notNull(locations, "Cannot load an ApplicationContext with a NULL 'locations' array. " +
+					"Consider annotating your test class with @ContextConfiguration or @ContextHierarchy.");
 			applicationContext = contextLoader.loadContext(locations);
 		}
 
@@ -76,35 +81,39 @@ private ApplicationContext loadContextInternal(MergedContextConfiguration merged
 	/**
 	 * Load the {@link ApplicationContext application context} for the supplied
 	 * merged context configuration.
-	 *
 	 * <p>If the context is present in the cache it will simply be returned;
 	 * otherwise, it will be loaded, stored in the cache, and returned.
 	 * @return the application context
 	 * @throws IllegalStateException if an error occurs while retrieving or
 	 * loading the application context
 	 */
 	public ApplicationContext loadContext(MergedContextConfiguration mergedContextConfiguration) {
-		synchronized (contextCache) {
-			ApplicationContext context = contextCache.get(mergedContextConfiguration);
+		synchronized (this.contextCache) {
+			ApplicationContext context = this.contextCache.get(mergedContextConfiguration);
 			if (context == null) {
 				try {
 					context = loadContextInternal(mergedContextConfiguration);
 					if (logger.isDebugEnabled()) {
-						logger.debug(String.format("Storing ApplicationContext in cache under key [%s].",
-							mergedContextConfiguration));
+						logger.debug(String.format("Storing ApplicationContext in cache under key [%s]",
+								mergedContextConfiguration));
 					}
-					contextCache.put(mergedContextConfiguration, context);
+					this.contextCache.put(mergedContextConfiguration, context);
 				}
 				catch (Exception ex) {
 					throw new IllegalStateException("Failed to load ApplicationContext", ex);
 				}
 			}
 			else {
 				if (logger.isDebugEnabled()) {
-					logger.debug(String.format("Retrieved ApplicationContext from cache with key [%s].",
-						mergedContextConfiguration));
+					logger.debug(String.format("Retrieved ApplicationContext from cache with key [%s]",
+							mergedContextConfiguration));
 				}
 			}
+
+			if (statsLogger.isDebugEnabled()) {
+				statsLogger.debug("Spring test ApplicationContext cache statistics: " + this.contextCache);
+			}
+
 			return context;
 		}
 	}