/**
 * Construct a new {@code DefaultBootstrapContext} from the supplied arguments.
 * @param testClass the test class for this bootstrap context; never {@code null}
 * @param cacheAwareContextLoaderDelegate the context loader delegate to use for
 * transparent interaction with the {@code ContextCache}; never {@code null}
 */
public DefaultBootstrapContext(Class<?> testClass, CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate) {
	Assert.notNull(testClass, "Test class must not be null");
	Assert.notNull(cacheAwareContextLoaderDelegate, "CacheAwareContextLoaderDelegate must not be null");
	this.testClass = testClass;
	this.cacheAwareContextLoaderDelegate = cacheAwareContextLoaderDelegate;
}
 

/**
 * Construct a new {@code DefaultTestContext} from the supplied arguments.
 * @param testClass the test class for this test context
 * @param mergedContextConfiguration the merged application context
 * configuration for this test context
 * @param cacheAwareContextLoaderDelegate the delegate to use for loading
 * and closing the application context for this test context
 */
public DefaultTestContext(Class<?> testClass, MergedContextConfiguration mergedContextConfiguration,
		CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate) {

	Assert.notNull(testClass, "Test Class must not be null");
	Assert.notNull(mergedContextConfiguration, "MergedContextConfiguration must not be null");
	Assert.notNull(cacheAwareContextLoaderDelegate, "CacheAwareContextLoaderDelegate must not be null");
	this.testClass = testClass;
	this.mergedContextConfiguration = mergedContextConfiguration;
	this.cacheAwareContextLoaderDelegate = cacheAwareContextLoaderDelegate;
}
 

private MergedContextConfiguration buildDefaultMergedContextConfiguration(Class<?> testClass,
		CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate) {

	List<ContextConfigurationAttributes> defaultConfigAttributesList =
			Collections.singletonList(new ContextConfigurationAttributes(testClass));

	ContextLoader contextLoader = resolveContextLoader(testClass, defaultConfigAttributesList);
	if (logger.isInfoEnabled()) {
		logger.info(String.format(
				"Neither @ContextConfiguration nor @ContextHierarchy found for test class [%s], using %s",
				testClass.getName(), contextLoader.getClass().getSimpleName()));
	}
	return buildMergedContextConfiguration(testClass, defaultConfigAttributesList, null,
			cacheAwareContextLoaderDelegate, false);
}
 

MergedContextConfiguration buildMergedContextConfiguration(Class<?> testClass) {
	CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate = Mockito.mock(CacheAwareContextLoaderDelegate.class);
	BootstrapContext bootstrapContext = BootstrapTestUtils.buildBootstrapContext(testClass, cacheAwareContextLoaderDelegate);
	TestContextBootstrapper bootstrapper = BootstrapTestUtils.resolveTestContextBootstrapper(bootstrapContext);
	return bootstrapper.buildMergedContextConfiguration();
}
 

/**
 * Construct a new {@code DefaultBootstrapContext} from the supplied arguments.
 * @param testClass the test class for this bootstrap context; never {@code null}
 * @param cacheAwareContextLoaderDelegate the context loader delegate to use for
 * transparent interaction with the {@code ContextCache}; never {@code null}
 */
public DefaultBootstrapContext(Class<?> testClass, CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate) {
	Assert.notNull(testClass, "Test class must not be null");
	Assert.notNull(cacheAwareContextLoaderDelegate, "CacheAwareContextLoaderDelegate must not be null");
	this.testClass = testClass;
	this.cacheAwareContextLoaderDelegate = cacheAwareContextLoaderDelegate;
}
 

/**
 * Construct a new {@code DefaultTestContext} from the supplied arguments.
 * @param testClass the test class for this test context
 * @param mergedContextConfiguration the merged application context
 * configuration for this test context
 * @param cacheAwareContextLoaderDelegate the delegate to use for loading
 * and closing the application context for this test context
 */
public DefaultTestContext(Class<?> testClass, MergedContextConfiguration mergedContextConfiguration,
		CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate) {

	Assert.notNull(testClass, "Test Class must not be null");
	Assert.notNull(mergedContextConfiguration, "MergedContextConfiguration must not be null");
	Assert.notNull(cacheAwareContextLoaderDelegate, "CacheAwareContextLoaderDelegate must not be null");
	this.testClass = testClass;
	this.mergedContextConfiguration = mergedContextConfiguration;
	this.cacheAwareContextLoaderDelegate = cacheAwareContextLoaderDelegate;
}
 

private MergedContextConfiguration buildDefaultMergedContextConfiguration(Class<?> testClass,
		CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate) {

	List<ContextConfigurationAttributes> defaultConfigAttributesList =
			Collections.singletonList(new ContextConfigurationAttributes(testClass));

	ContextLoader contextLoader = resolveContextLoader(testClass, defaultConfigAttributesList);
	if (logger.isInfoEnabled()) {
		logger.info(String.format(
				"Neither @ContextConfiguration nor @ContextHierarchy found for test class [%s], using %s",
				testClass.getName(), contextLoader.getClass().getSimpleName()));
	}
	return buildMergedContextConfiguration(testClass, defaultConfigAttributesList, null,
			cacheAwareContextLoaderDelegate, false);
}
 

/**
 * Construct a new {@code DefaultBootstrapContext} from the supplied arguments.
 * @param testClass the test class for this bootstrap context; never {@code null}
 * @param cacheAwareContextLoaderDelegate the context loader delegate to use for
 * transparent interaction with the {@code ContextCache}; never {@code null}
 */
public DefaultBootstrapContext(Class<?> testClass, CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate) {
	Assert.notNull(testClass, "Test class must not be null");
	Assert.notNull(cacheAwareContextLoaderDelegate, "CacheAwareContextLoaderDelegate must not be null");
	this.testClass = testClass;
	this.cacheAwareContextLoaderDelegate = cacheAwareContextLoaderDelegate;
}
 

/**
 * Construct a new {@code DefaultTestContext} from the supplied arguments.
 * @param testClass the test class for this test context; never {@code null}
 * @param mergedContextConfiguration the merged application context
 * configuration for this test context; never {@code null}
 * @param cacheAwareContextLoaderDelegate the delegate to use for loading
 * and closing the application context for this test context; never {@code null}
 */
public DefaultTestContext(Class<?> testClass, MergedContextConfiguration mergedContextConfiguration,
		CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate) {
	Assert.notNull(testClass, "testClass must not be null");
	Assert.notNull(mergedContextConfiguration, "MergedContextConfiguration must not be null");
	Assert.notNull(cacheAwareContextLoaderDelegate, "CacheAwareContextLoaderDelegate must not be null");
	this.testClass = testClass;
	this.mergedContextConfiguration = mergedContextConfiguration;
	this.cacheAwareContextLoaderDelegate = cacheAwareContextLoaderDelegate;
}
 

/**
 * {@inheritDoc}
 */
@Override
public CacheAwareContextLoaderDelegate getCacheAwareContextLoaderDelegate() {
	return this.cacheAwareContextLoaderDelegate;
}
 

/**
 * {@inheritDoc}
 */
@SuppressWarnings("unchecked")
@Override
public final MergedContextConfiguration buildMergedContextConfiguration() {
	Class<?> testClass = getBootstrapContext().getTestClass();
	CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate = getCacheAwareContextLoaderDelegate();

	if (MetaAnnotationUtils.findAnnotationDescriptorForTypes(
			testClass, ContextConfiguration.class, ContextHierarchy.class) == null) {
		return buildDefaultMergedContextConfiguration(testClass, cacheAwareContextLoaderDelegate);
	}

	if (AnnotationUtils.findAnnotation(testClass, ContextHierarchy.class) != null) {
		Map<String, List<ContextConfigurationAttributes>> hierarchyMap =
				ContextLoaderUtils.buildContextHierarchyMap(testClass);
		MergedContextConfiguration parentConfig = null;
		MergedContextConfiguration mergedConfig = null;

		for (List<ContextConfigurationAttributes> list : hierarchyMap.values()) {
			List<ContextConfigurationAttributes> reversedList = new ArrayList<>(list);
			Collections.reverse(reversedList);

			// Don't use the supplied testClass; instead ensure that we are
			// building the MCC for the actual test class that declared the
			// configuration for the current level in the context hierarchy.
			Assert.notEmpty(reversedList, "ContextConfigurationAttributes list must not be empty");
			Class<?> declaringClass = reversedList.get(0).getDeclaringClass();

			mergedConfig = buildMergedContextConfiguration(
					declaringClass, reversedList, parentConfig, cacheAwareContextLoaderDelegate, true);
			parentConfig = mergedConfig;
		}

		// Return the last level in the context hierarchy
		Assert.state(mergedConfig != null, "No merged context configuration");
		return mergedConfig;
	}
	else {
		return buildMergedContextConfiguration(testClass,
				ContextLoaderUtils.resolveContextConfigurationAttributes(testClass),
				null, cacheAwareContextLoaderDelegate, true);
	}
}
 

/**
 * Build the {@link MergedContextConfiguration merged context configuration}
 * for the supplied {@link Class testClass}, context configuration attributes,
 * and parent context configuration.
 * @param testClass the test class for which the {@code MergedContextConfiguration}
 * should be built (must not be {@code null})
 * @param configAttributesList the list of context configuration attributes for the
 * specified test class, ordered <em>bottom-up</em> (i.e., as if we were
 * traversing up the class hierarchy); never {@code null} or empty
 * @param parentConfig the merged context configuration for the parent application
 * context in a context hierarchy, or {@code null} if there is no parent
 * @param cacheAwareContextLoaderDelegate the cache-aware context loader delegate to
 * be passed to the {@code MergedContextConfiguration} constructor
 * @param requireLocationsClassesOrInitializers whether locations, classes, or
 * initializers are required; typically {@code true} but may be set to {@code false}
 * if the configured loader supports empty configuration
 * @return the merged context configuration
 * @see #resolveContextLoader
 * @see ContextLoaderUtils#resolveContextConfigurationAttributes
 * @see SmartContextLoader#processContextConfiguration
 * @see ContextLoader#processLocations
 * @see ActiveProfilesUtils#resolveActiveProfiles
 * @see ApplicationContextInitializerUtils#resolveInitializerClasses
 * @see MergedContextConfiguration
 */
private MergedContextConfiguration buildMergedContextConfiguration(Class<?> testClass,
		List<ContextConfigurationAttributes> configAttributesList, @Nullable MergedContextConfiguration parentConfig,
		CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate,
		boolean requireLocationsClassesOrInitializers) {

	Assert.notEmpty(configAttributesList, "ContextConfigurationAttributes list must not be null or empty");

	ContextLoader contextLoader = resolveContextLoader(testClass, configAttributesList);
	List<String> locations = new ArrayList<>();
	List<Class<?>> classes = new ArrayList<>();
	List<Class<?>> initializers = new ArrayList<>();

	for (ContextConfigurationAttributes configAttributes : configAttributesList) {
		if (logger.isTraceEnabled()) {
			logger.trace(String.format("Processing locations and classes for context configuration attributes %s",
					configAttributes));
		}
		if (contextLoader instanceof SmartContextLoader) {
			SmartContextLoader smartContextLoader = (SmartContextLoader) contextLoader;
			smartContextLoader.processContextConfiguration(configAttributes);
			locations.addAll(0, Arrays.asList(configAttributes.getLocations()));
			classes.addAll(0, Arrays.asList(configAttributes.getClasses()));
		}
		else {
			String[] processedLocations = contextLoader.processLocations(
					configAttributes.getDeclaringClass(), configAttributes.getLocations());
			locations.addAll(0, Arrays.asList(processedLocations));
			// Legacy ContextLoaders don't know how to process classes
		}
		initializers.addAll(0, Arrays.asList(configAttributes.getInitializers()));
		if (!configAttributes.isInheritLocations()) {
			break;
		}
	}

	Set<ContextCustomizer> contextCustomizers = getContextCustomizers(testClass,
			Collections.unmodifiableList(configAttributesList));

	Assert.state(!(requireLocationsClassesOrInitializers &&
			areAllEmpty(locations, classes, initializers, contextCustomizers)), () -> String.format(
			"%s was unable to detect defaults, and no ApplicationContextInitializers " +
			"or ContextCustomizers were declared for context configuration attributes %s",
			contextLoader.getClass().getSimpleName(), configAttributesList));

	MergedTestPropertySources mergedTestPropertySources =
			TestPropertySourceUtils.buildMergedTestPropertySources(testClass);
	MergedContextConfiguration mergedConfig = new MergedContextConfiguration(testClass,
			StringUtils.toStringArray(locations), ClassUtils.toClassArray(classes),
			ApplicationContextInitializerUtils.resolveInitializerClasses(configAttributesList),
			ActiveProfilesUtils.resolveActiveProfiles(testClass),
			mergedTestPropertySources.getLocations(),
			mergedTestPropertySources.getProperties(),
			contextCustomizers, contextLoader, cacheAwareContextLoaderDelegate, parentConfig);

	return processMergedContextConfiguration(mergedConfig);
}
 

/**
 * {@inheritDoc}
 */
@Override
public CacheAwareContextLoaderDelegate getCacheAwareContextLoaderDelegate() {
	return this.cacheAwareContextLoaderDelegate;
}
 

/**
 * {@inheritDoc}
 */
@SuppressWarnings("unchecked")
@Override
public final MergedContextConfiguration buildMergedContextConfiguration() {
	Class<?> testClass = getBootstrapContext().getTestClass();
	CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate = getCacheAwareContextLoaderDelegate();

	if (MetaAnnotationUtils.findAnnotationDescriptorForTypes(
			testClass, ContextConfiguration.class, ContextHierarchy.class) == null) {
		return buildDefaultMergedContextConfiguration(testClass, cacheAwareContextLoaderDelegate);
	}

	if (AnnotationUtils.findAnnotation(testClass, ContextHierarchy.class) != null) {
		Map<String, List<ContextConfigurationAttributes>> hierarchyMap =
				ContextLoaderUtils.buildContextHierarchyMap(testClass);
		MergedContextConfiguration parentConfig = null;
		MergedContextConfiguration mergedConfig = null;

		for (List<ContextConfigurationAttributes> list : hierarchyMap.values()) {
			List<ContextConfigurationAttributes> reversedList = new ArrayList<>(list);
			Collections.reverse(reversedList);

			// Don't use the supplied testClass; instead ensure that we are
			// building the MCC for the actual test class that declared the
			// configuration for the current level in the context hierarchy.
			Assert.notEmpty(reversedList, "ContextConfigurationAttributes list must not be empty");
			Class<?> declaringClass = reversedList.get(0).getDeclaringClass();

			mergedConfig = buildMergedContextConfiguration(
					declaringClass, reversedList, parentConfig, cacheAwareContextLoaderDelegate, true);
			parentConfig = mergedConfig;
		}

		// Return the last level in the context hierarchy
		Assert.state(mergedConfig != null, "No merged context configuration");
		return mergedConfig;
	}
	else {
		return buildMergedContextConfiguration(testClass,
				ContextLoaderUtils.resolveContextConfigurationAttributes(testClass),
				null, cacheAwareContextLoaderDelegate, true);
	}
}
 

/**
 * Build the {@link MergedContextConfiguration merged context configuration}
 * for the supplied {@link Class testClass}, context configuration attributes,
 * and parent context configuration.
 * @param testClass the test class for which the {@code MergedContextConfiguration}
 * should be built (must not be {@code null})
 * @param configAttributesList the list of context configuration attributes for the
 * specified test class, ordered <em>bottom-up</em> (i.e., as if we were
 * traversing up the class hierarchy); never {@code null} or empty
 * @param parentConfig the merged context configuration for the parent application
 * context in a context hierarchy, or {@code null} if there is no parent
 * @param cacheAwareContextLoaderDelegate the cache-aware context loader delegate to
 * be passed to the {@code MergedContextConfiguration} constructor
 * @param requireLocationsClassesOrInitializers whether locations, classes, or
 * initializers are required; typically {@code true} but may be set to {@code false}
 * if the configured loader supports empty configuration
 * @return the merged context configuration
 * @see #resolveContextLoader
 * @see ContextLoaderUtils#resolveContextConfigurationAttributes
 * @see SmartContextLoader#processContextConfiguration
 * @see ContextLoader#processLocations
 * @see ActiveProfilesUtils#resolveActiveProfiles
 * @see ApplicationContextInitializerUtils#resolveInitializerClasses
 * @see MergedContextConfiguration
 */
private MergedContextConfiguration buildMergedContextConfiguration(Class<?> testClass,
		List<ContextConfigurationAttributes> configAttributesList, @Nullable MergedContextConfiguration parentConfig,
		CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate,
		boolean requireLocationsClassesOrInitializers) {

	Assert.notEmpty(configAttributesList, "ContextConfigurationAttributes list must not be null or empty");

	ContextLoader contextLoader = resolveContextLoader(testClass, configAttributesList);
	List<String> locations = new ArrayList<>();
	List<Class<?>> classes = new ArrayList<>();
	List<Class<?>> initializers = new ArrayList<>();

	for (ContextConfigurationAttributes configAttributes : configAttributesList) {
		if (logger.isTraceEnabled()) {
			logger.trace(String.format("Processing locations and classes for context configuration attributes %s",
					configAttributes));
		}
		if (contextLoader instanceof SmartContextLoader) {
			SmartContextLoader smartContextLoader = (SmartContextLoader) contextLoader;
			smartContextLoader.processContextConfiguration(configAttributes);
			locations.addAll(0, Arrays.asList(configAttributes.getLocations()));
			classes.addAll(0, Arrays.asList(configAttributes.getClasses()));
		}
		else {
			String[] processedLocations = contextLoader.processLocations(
					configAttributes.getDeclaringClass(), configAttributes.getLocations());
			locations.addAll(0, Arrays.asList(processedLocations));
			// Legacy ContextLoaders don't know how to process classes
		}
		initializers.addAll(0, Arrays.asList(configAttributes.getInitializers()));
		if (!configAttributes.isInheritLocations()) {
			break;
		}
	}

	Set<ContextCustomizer> contextCustomizers = getContextCustomizers(testClass,
			Collections.unmodifiableList(configAttributesList));

	Assert.state(!(requireLocationsClassesOrInitializers &&
			areAllEmpty(locations, classes, initializers, contextCustomizers)), () -> String.format(
			"%s was unable to detect defaults, and no ApplicationContextInitializers " +
			"or ContextCustomizers were declared for context configuration attributes %s",
			contextLoader.getClass().getSimpleName(), configAttributesList));

	MergedTestPropertySources mergedTestPropertySources =
			TestPropertySourceUtils.buildMergedTestPropertySources(testClass);
	MergedContextConfiguration mergedConfig = new MergedContextConfiguration(testClass,
			StringUtils.toStringArray(locations), ClassUtils.toClassArray(classes),
			ApplicationContextInitializerUtils.resolveInitializerClasses(configAttributesList),
			ActiveProfilesUtils.resolveActiveProfiles(testClass),
			mergedTestPropertySources.getLocations(),
			mergedTestPropertySources.getProperties(),
			contextCustomizers, contextLoader, cacheAwareContextLoaderDelegate, parentConfig);

	return processMergedContextConfiguration(mergedConfig);
}
 

MergedContextConfiguration buildMergedContextConfiguration(Class<?> testClass) {
	CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate = Mockito.mock(CacheAwareContextLoaderDelegate.class);
	BootstrapContext bootstrapContext = BootstrapTestUtils.buildBootstrapContext(testClass, cacheAwareContextLoaderDelegate);
	TestContextBootstrapper bootstrapper = BootstrapTestUtils.resolveTestContextBootstrapper(bootstrapContext);
	return bootstrapper.buildMergedContextConfiguration();
}
 

/**
 * {@inheritDoc}
 */
@Override
public CacheAwareContextLoaderDelegate getCacheAwareContextLoaderDelegate() {
	return this.cacheAwareContextLoaderDelegate;
}
 

/**
 * {@inheritDoc}
 */
@SuppressWarnings("unchecked")
@Override
public final MergedContextConfiguration buildMergedContextConfiguration() {
	Class<?> testClass = getBootstrapContext().getTestClass();
	CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate = getCacheAwareContextLoaderDelegate();

	if (MetaAnnotationUtils.findAnnotationDescriptorForTypes(testClass, ContextConfiguration.class,
		ContextHierarchy.class) == null) {
		if (logger.isInfoEnabled()) {
			logger.info(String.format(
				"Neither @ContextConfiguration nor @ContextHierarchy found for test class [%s]",
				testClass.getName()));
		}
		return new MergedContextConfiguration(testClass, null, null, null, null);
	}

	if (AnnotationUtils.findAnnotation(testClass, ContextHierarchy.class) != null) {
		Map<String, List<ContextConfigurationAttributes>> hierarchyMap = ContextLoaderUtils.buildContextHierarchyMap(testClass);
		MergedContextConfiguration parentConfig = null;
		MergedContextConfiguration mergedConfig = null;

		for (List<ContextConfigurationAttributes> list : hierarchyMap.values()) {
			List<ContextConfigurationAttributes> reversedList = new ArrayList<ContextConfigurationAttributes>(list);
			Collections.reverse(reversedList);

			// Don't use the supplied testClass; instead ensure that we are
			// building the MCC for the actual test class that declared the
			// configuration for the current level in the context hierarchy.
			Assert.notEmpty(reversedList, "ContextConfigurationAttributes list must not be empty");
			Class<?> declaringClass = reversedList.get(0).getDeclaringClass();

			mergedConfig = buildMergedContextConfiguration(declaringClass, reversedList, parentConfig,
				cacheAwareContextLoaderDelegate);
			parentConfig = mergedConfig;
		}

		// Return the last level in the context hierarchy
		return mergedConfig;
	}
	else {
		return buildMergedContextConfiguration(testClass,
			ContextLoaderUtils.resolveContextConfigurationAttributes(testClass), null,
			cacheAwareContextLoaderDelegate);
	}
}
 

/**
 * Build the {@link MergedContextConfiguration merged context configuration}
 * for the supplied {@link Class testClass}, context configuration attributes,
 * and parent context configuration.
 * @param testClass the test class for which the {@code MergedContextConfiguration}
 * should be built (must not be {@code null})
 * @param configAttributesList the list of context configuration attributes for the
 * specified test class, ordered <em>bottom-up</em> (i.e., as if we were
 * traversing up the class hierarchy); never {@code null} or empty
 * @param parentConfig the merged context configuration for the parent application
 * context in a context hierarchy, or {@code null} if there is no parent
 * @param cacheAwareContextLoaderDelegate the cache-aware context loader delegate to
 * be passed to the {@code MergedContextConfiguration} constructor
 * @return the merged context configuration
 * @see #resolveContextLoader
 * @see ContextLoaderUtils#resolveContextConfigurationAttributes
 * @see SmartContextLoader#processContextConfiguration
 * @see ContextLoader#processLocations
 * @see ActiveProfilesUtils#resolveActiveProfiles
 * @see ApplicationContextInitializerUtils#resolveInitializerClasses
 * @see MergedContextConfiguration
 */
private MergedContextConfiguration buildMergedContextConfiguration(Class<?> testClass,
		List<ContextConfigurationAttributes> configAttributesList, MergedContextConfiguration parentConfig,
		CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate) {

	ContextLoader contextLoader = resolveContextLoader(testClass, configAttributesList);
	List<String> locationsList = new ArrayList<String>();
	List<Class<?>> classesList = new ArrayList<Class<?>>();

	for (ContextConfigurationAttributes configAttributes : configAttributesList) {
		if (logger.isTraceEnabled()) {
			logger.trace(String.format("Processing locations and classes for context configuration attributes %s",
				configAttributes));
		}
		if (contextLoader instanceof SmartContextLoader) {
			SmartContextLoader smartContextLoader = (SmartContextLoader) contextLoader;
			smartContextLoader.processContextConfiguration(configAttributes);
			locationsList.addAll(0, Arrays.asList(configAttributes.getLocations()));
			classesList.addAll(0, Arrays.asList(configAttributes.getClasses()));
		}
		else {
			String[] processedLocations = contextLoader.processLocations(configAttributes.getDeclaringClass(),
				configAttributes.getLocations());
			locationsList.addAll(0, Arrays.asList(processedLocations));
			// Legacy ContextLoaders don't know how to process classes
		}
		if (!configAttributes.isInheritLocations()) {
			break;
		}
	}

	String[] locations = StringUtils.toStringArray(locationsList);
	Class<?>[] classes = ClassUtils.toClassArray(classesList);
	Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> initializerClasses = //
	ApplicationContextInitializerUtils.resolveInitializerClasses(configAttributesList);
	String[] activeProfiles = ActiveProfilesUtils.resolveActiveProfiles(testClass);
	MergedTestPropertySources mergedTestPropertySources = TestPropertySourceUtils.buildMergedTestPropertySources(testClass);

	MergedContextConfiguration mergedConfig = new MergedContextConfiguration(testClass, locations, classes,
		initializerClasses, activeProfiles, mergedTestPropertySources.getLocations(),
		mergedTestPropertySources.getProperties(), contextLoader, cacheAwareContextLoaderDelegate, parentConfig);

	return processMergedContextConfiguration(mergedConfig);
}
 

MergedContextConfiguration buildMergedContextConfiguration(Class<?> testClass) {
	CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate = Mockito.mock(CacheAwareContextLoaderDelegate.class);
	BootstrapContext bootstrapContext = BootstrapTestUtils.buildBootstrapContext(testClass, cacheAwareContextLoaderDelegate);
	TestContextBootstrapper bootstrapper = BootstrapTestUtils.resolveTestContextBootstrapper(bootstrapContext);
	return bootstrapper.buildMergedContextConfiguration();
}
 

/**
 * Create a new {@code WebMergedContextConfiguration} instance for the
 * supplied parameters.
 * <p>If a {@code null} value is supplied for {@code locations},
 * {@code classes}, {@code activeProfiles}, {@code propertySourceLocations},
 * or {@code propertySourceProperties} an empty array will be stored instead.
 * If a {@code null} value is supplied for the
 * {@code contextInitializerClasses} an empty set will be stored instead.
 * If an <em>empty</em> value is supplied for the {@code resourceBasePath}
 * an empty string will be used. Furthermore, active profiles will be sorted,
 * and duplicate profiles will be removed.
 * @param testClass the test class for which the configuration was merged
 * @param locations the merged resource locations
 * @param classes the merged annotated classes
 * @param contextInitializerClasses the merged context initializer classes
 * @param activeProfiles the merged active bean definition profiles
 * @param propertySourceLocations the merged {@code PropertySource} locations
 * @param propertySourceProperties the merged {@code PropertySource} properties
 * @param resourceBasePath the resource path to the root directory of the web application
 * @param contextLoader the resolved {@code ContextLoader}
 * @param cacheAwareContextLoaderDelegate a cache-aware context loader
 * delegate with which to retrieve the parent context
 * @param parent the parent configuration or {@code null} if there is no parent
 * @since 4.1
 */
public WebMergedContextConfiguration(Class<?> testClass, @Nullable String[] locations, @Nullable Class<?>[] classes,
		@Nullable Set<Class<? extends ApplicationContextInitializer<?>>> contextInitializerClasses,
		@Nullable String[] activeProfiles, @Nullable String[] propertySourceLocations, @Nullable String[] propertySourceProperties,
		String resourceBasePath, ContextLoader contextLoader,
		CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate, @Nullable MergedContextConfiguration parent) {

	this(testClass, locations, classes, contextInitializerClasses, activeProfiles, propertySourceLocations,
		propertySourceProperties, null, resourceBasePath, contextLoader, cacheAwareContextLoaderDelegate, parent);
}
 

/**
 * Create a new {@code WebMergedContextConfiguration} instance for the
 * supplied parameters.
 * <p>If a {@code null} value is supplied for {@code locations},
 * {@code classes}, {@code activeProfiles}, {@code propertySourceLocations},
 * or {@code propertySourceProperties} an empty array will be stored instead.
 * If a {@code null} value is supplied for {@code contextInitializerClasses}
 * or {@code contextCustomizers}, an empty set will be stored instead.
 * If an <em>empty</em> value is supplied for the {@code resourceBasePath}
 * an empty string will be used. Furthermore, active profiles will be sorted,
 * and duplicate profiles will be removed.
 * @param testClass the test class for which the configuration was merged
 * @param locations the merged context resource locations
 * @param classes the merged annotated classes
 * @param contextInitializerClasses the merged context initializer classes
 * @param activeProfiles the merged active bean definition profiles
 * @param propertySourceLocations the merged {@code PropertySource} locations
 * @param propertySourceProperties the merged {@code PropertySource} properties
 * @param contextCustomizers the context customizers
 * @param resourceBasePath the resource path to the root directory of the web application
 * @param contextLoader the resolved {@code ContextLoader}
 * @param cacheAwareContextLoaderDelegate a cache-aware context loader
 * delegate with which to retrieve the parent context
 * @param parent the parent configuration or {@code null} if there is no parent
 * @since 4.3
 */
public WebMergedContextConfiguration(Class<?> testClass, @Nullable String[] locations, @Nullable Class<?>[] classes,
		@Nullable Set<Class<? extends ApplicationContextInitializer<?>>> contextInitializerClasses,
		@Nullable String[] activeProfiles, @Nullable String[] propertySourceLocations, @Nullable String[] propertySourceProperties,
		@Nullable Set<ContextCustomizer> contextCustomizers, String resourceBasePath, ContextLoader contextLoader,
		CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate, @Nullable MergedContextConfiguration parent) {

	super(testClass, locations, classes, contextInitializerClasses, activeProfiles, propertySourceLocations,
		propertySourceProperties, contextCustomizers, contextLoader, cacheAwareContextLoaderDelegate, parent);

	this.resourceBasePath = (StringUtils.hasText(resourceBasePath) ? resourceBasePath : "");
}
 

/**
 * Create a new {@code WebMergedContextConfiguration} instance for the
 * supplied parameters.
 * <p>If a {@code null} value is supplied for {@code locations},
 * {@code classes}, {@code activeProfiles}, {@code propertySourceLocations},
 * or {@code propertySourceProperties} an empty array will be stored instead.
 * If a {@code null} value is supplied for the
 * {@code contextInitializerClasses} an empty set will be stored instead.
 * If an <em>empty</em> value is supplied for the {@code resourceBasePath}
 * an empty string will be used. Furthermore, active profiles will be sorted,
 * and duplicate profiles will be removed.
 * @param testClass the test class for which the configuration was merged
 * @param locations the merged resource locations
 * @param classes the merged annotated classes
 * @param contextInitializerClasses the merged context initializer classes
 * @param activeProfiles the merged active bean definition profiles
 * @param propertySourceLocations the merged {@code PropertySource} locations
 * @param propertySourceProperties the merged {@code PropertySource} properties
 * @param resourceBasePath the resource path to the root directory of the web application
 * @param contextLoader the resolved {@code ContextLoader}
 * @param cacheAwareContextLoaderDelegate a cache-aware context loader
 * delegate with which to retrieve the parent context
 * @param parent the parent configuration or {@code null} if there is no parent
 * @since 4.1
 */
public WebMergedContextConfiguration(Class<?> testClass, @Nullable String[] locations, @Nullable Class<?>[] classes,
		@Nullable Set<Class<? extends ApplicationContextInitializer<?>>> contextInitializerClasses,
		@Nullable String[] activeProfiles, @Nullable String[] propertySourceLocations, @Nullable String[] propertySourceProperties,
		String resourceBasePath, ContextLoader contextLoader,
		CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate, @Nullable MergedContextConfiguration parent) {

	this(testClass, locations, classes, contextInitializerClasses, activeProfiles, propertySourceLocations,
		propertySourceProperties, null, resourceBasePath, contextLoader, cacheAwareContextLoaderDelegate, parent);
}
 

/**
 * Create a new {@code WebMergedContextConfiguration} instance for the
 * supplied parameters.
 * <p>If a {@code null} value is supplied for {@code locations},
 * {@code classes}, {@code activeProfiles}, {@code propertySourceLocations},
 * or {@code propertySourceProperties} an empty array will be stored instead.
 * If a {@code null} value is supplied for {@code contextInitializerClasses}
 * or {@code contextCustomizers}, an empty set will be stored instead.
 * If an <em>empty</em> value is supplied for the {@code resourceBasePath}
 * an empty string will be used. Furthermore, active profiles will be sorted,
 * and duplicate profiles will be removed.
 * @param testClass the test class for which the configuration was merged
 * @param locations the merged context resource locations
 * @param classes the merged annotated classes
 * @param contextInitializerClasses the merged context initializer classes
 * @param activeProfiles the merged active bean definition profiles
 * @param propertySourceLocations the merged {@code PropertySource} locations
 * @param propertySourceProperties the merged {@code PropertySource} properties
 * @param contextCustomizers the context customizers
 * @param resourceBasePath the resource path to the root directory of the web application
 * @param contextLoader the resolved {@code ContextLoader}
 * @param cacheAwareContextLoaderDelegate a cache-aware context loader
 * delegate with which to retrieve the parent context
 * @param parent the parent configuration or {@code null} if there is no parent
 * @since 4.3
 */
public WebMergedContextConfiguration(Class<?> testClass, @Nullable String[] locations, @Nullable Class<?>[] classes,
		@Nullable Set<Class<? extends ApplicationContextInitializer<?>>> contextInitializerClasses,
		@Nullable String[] activeProfiles, @Nullable String[] propertySourceLocations, @Nullable String[] propertySourceProperties,
		@Nullable Set<ContextCustomizer> contextCustomizers, String resourceBasePath, ContextLoader contextLoader,
		CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate, @Nullable MergedContextConfiguration parent) {

	super(testClass, locations, classes, contextInitializerClasses, activeProfiles, propertySourceLocations,
		propertySourceProperties, contextCustomizers, contextLoader, cacheAwareContextLoaderDelegate, parent);

	this.resourceBasePath = (StringUtils.hasText(resourceBasePath) ? resourceBasePath : "");
}
 

public static void assertDependencyMissing(Class<?> testClass, Class<?> expectedMissingDependency) {

		CacheAwareContextLoaderDelegate delegate = new DefaultCacheAwareContextLoaderDelegate();
		BootstrapContext bootstrapContext = new DefaultBootstrapContext(testClass, delegate);

		SpringBootTestContextBootstrapper bootstrapper = new SpringBootTestContextBootstrapper();
		bootstrapper.setBootstrapContext(bootstrapContext);

		MergedContextConfiguration configuration = bootstrapper.buildMergedContextConfiguration();

		AssertableApplicationContext context = AssertableApplicationContext.get(() -> {

			SpringBootContextLoader loader = new SpringBootContextLoader();

			try {

				return (ConfigurableApplicationContext) loader.loadContext(configuration);

			} catch (Exception e) {

				if (e instanceof RuntimeException) {
					throw (RuntimeException) e;
				}

				throw new RuntimeException(e);
			}
		});

		assertThat(context).hasFailed();

		assertThat(context).getFailure().isInstanceOfSatisfying(UnsatisfiedDependencyException.class, it -> {
			assertThat(it.getMostSpecificCause()).isInstanceOfSatisfying(NoSuchBeanDefinitionException.class, ex -> {
				assertThat(ex.getBeanType()).isEqualTo(expectedMissingDependency);
			});
		});
	}
 

/**
 * Create a new {@code WebMergedContextConfiguration} instance for the
 * supplied parameters.
 * <p>Delegates to
 * {@link #WebMergedContextConfiguration(Class, String[], Class[], Set, String[], String[], String[], String, ContextLoader, CacheAwareContextLoaderDelegate, MergedContextConfiguration)}.
 * @param testClass the test class for which the configuration was merged
 * @param locations the merged resource locations
 * @param classes the merged annotated classes
 * @param contextInitializerClasses the merged context initializer classes
 * @param activeProfiles the merged active bean definition profiles
 * @param resourceBasePath the resource path to the root directory of the web application
 * @param contextLoader the resolved {@code ContextLoader}
 * @param cacheAwareContextLoaderDelegate a cache-aware context loader
 * delegate with which to retrieve the parent context
 * @param parent the parent configuration or {@code null} if there is no parent
 * @since 3.2.2
 * @deprecated as of Spring 4.1, use
 * {@link #WebMergedContextConfiguration(Class, String[], Class[], Set, String[], String[], String[], String, ContextLoader, CacheAwareContextLoaderDelegate, MergedContextConfiguration)}
 * instead.
 */
@Deprecated
public WebMergedContextConfiguration(Class<?> testClass, String[] locations, Class<?>[] classes,
		Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> contextInitializerClasses,
		String[] activeProfiles, String resourceBasePath, ContextLoader contextLoader,
		CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate, MergedContextConfiguration parent) {

	this(testClass, locations, classes, contextInitializerClasses, activeProfiles, null, null, resourceBasePath,
		contextLoader, cacheAwareContextLoaderDelegate, parent);
}
 

/**
 * Create a new {@code WebMergedContextConfiguration} instance for the
 * supplied parameters.
 * <p>If a {@code null} value is supplied for {@code locations},
 * {@code classes}, {@code activeProfiles}, {@code propertySourceLocations},
 * or {@code propertySourceProperties} an empty array will be stored instead.
 * If a {@code null} value is supplied for the
 * {@code contextInitializerClasses} an empty set will be stored instead.
 * If an <em>empty</em> value is supplied for the {@code resourceBasePath}
 * an empty string will be used. Furthermore, active profiles will be sorted,
 * and duplicate profiles will be removed.
 * @param testClass the test class for which the configuration was merged
 * @param locations the merged resource locations
 * @param classes the merged annotated classes
 * @param contextInitializerClasses the merged context initializer classes
 * @param activeProfiles the merged active bean definition profiles
 * @param propertySourceLocations the merged {@code PropertySource} locations
 * @param propertySourceProperties the merged {@code PropertySource} properties
 * @param resourceBasePath the resource path to the root directory of the web application
 * @param contextLoader the resolved {@code ContextLoader}
 * @param cacheAwareContextLoaderDelegate a cache-aware context loader
 * delegate with which to retrieve the parent context
 * @param parent the parent configuration or {@code null} if there is no parent
 * @since 4.1
 */
public WebMergedContextConfiguration(Class<?> testClass, String[] locations, Class<?>[] classes,
		Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> contextInitializerClasses,
		String[] activeProfiles, String[] propertySourceLocations, String[] propertySourceProperties,
		String resourceBasePath, ContextLoader contextLoader,
		CacheAwareContextLoaderDelegate cacheAwareContextLoaderDelegate, MergedContextConfiguration parent) {

	super(testClass, locations, classes, contextInitializerClasses, activeProfiles, propertySourceLocations,
		propertySourceProperties, contextLoader, cacheAwareContextLoaderDelegate, parent);

	this.resourceBasePath = !StringUtils.hasText(resourceBasePath) ? "" : resourceBasePath;
}
 

/**
 * Get the {@link CacheAwareContextLoaderDelegate} to use for transparent
 * interaction with the {@code ContextCache}.
 * <p>The default implementation simply delegates to
 * {@code getBootstrapContext().getCacheAwareContextLoaderDelegate()}.
 * <p>Concrete subclasses may choose to override this method to return a custom
 * {@code CacheAwareContextLoaderDelegate} implementation with custom
 * {@link org.springframework.test.context.cache.ContextCache ContextCache} support.
 * @return the context loader delegate (never {@code null})
 */
protected CacheAwareContextLoaderDelegate getCacheAwareContextLoaderDelegate() {
	return getBootstrapContext().getCacheAwareContextLoaderDelegate();
}
 

/**
 * Get the {@link CacheAwareContextLoaderDelegate} to use for transparent
 * interaction with the {@code ContextCache}.
 * <p>The default implementation simply delegates to
 * {@code getBootstrapContext().getCacheAwareContextLoaderDelegate()}.
 * <p>Concrete subclasses may choose to override this method to return a custom
 * {@code CacheAwareContextLoaderDelegate} implementation with custom
 * {@link org.springframework.test.context.cache.ContextCache ContextCache} support.
 * @return the context loader delegate (never {@code null})
 */
protected CacheAwareContextLoaderDelegate getCacheAwareContextLoaderDelegate() {
	return getBootstrapContext().getCacheAwareContextLoaderDelegate();
}
 

/**
 * Get the {@link CacheAwareContextLoaderDelegate} to use for transparent
 * interaction with the {@code ContextCache}.
 * <p>The default implementation simply delegates to
 * {@code getBootstrapContext().getCacheAwareContextLoaderDelegate()}.
 * <p>Concrete subclasses may choose to override this method to return a custom
 * {@code CacheAwareContextLoaderDelegate} implementation with custom
 * {@link org.springframework.test.context.cache.ContextCache ContextCache} support.
 * @return the context loader delegate (never {@code null})
 */
protected CacheAwareContextLoaderDelegate getCacheAwareContextLoaderDelegate() {
	return getBootstrapContext().getCacheAwareContextLoaderDelegate();
}