Merge branch 'gh-9875'

Closes gh-9875

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/data/neo4j/MixedNeo4jRepositoriesAutoConfigurationTests.java

@@ -93,7 +93,7 @@ public class MixedNeo4jRepositoriesAutoConfigurationTests {
 
 	private void load(Class<?> config, String... environment) {
 		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
-		TestPropertyValues.of(environment).and("spring.datasource.initialize", "false")
+		TestPropertyValues.of(environment).and("spring.datasource.initialize=false")
 				.applyTo(context);
 		context.register(config);
 		context.register(DataSourceAutoConfiguration.class,

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/data/neo4j/Neo4jDataAutoConfigurationTests.java

@@ -29,7 +29,7 @@ import org.springframework.boot.autoconfigure.data.neo4j.city.City;
 import org.springframework.boot.autoconfigure.data.neo4j.country.Country;
 import org.springframework.boot.autoconfigure.domain.EntityScan;
 import org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration;
-import org.springframework.boot.test.context.WebApplicationContextTester;
+import org.springframework.boot.test.context.runner.WebApplicationContextRunner;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -54,30 +54,31 @@ import static org.mockito.Mockito.verify;
  */
 public class Neo4jDataAutoConfigurationTests {
 
-	private WebApplicationContextTester context = new WebApplicationContextTester()
+	private WebApplicationContextRunner contextRunner = new WebApplicationContextRunner()
 			.withUserConfiguration(TestConfiguration.class)
 			.withConfiguration(AutoConfigurations.of(Neo4jDataAutoConfiguration.class,
 					TransactionAutoConfiguration.class));
 
 	@Test
 	public void defaultConfiguration() {
-		this.context.withPropertyValues("spring.data.neo4j.uri=http://localhost:8989")
-				.run((loaded) -> {
-					assertThat(loaded)
+		this.contextRunner
+				.withPropertyValues("spring.data.neo4j.uri=http://localhost:8989")
+				.run((context) -> {
+					assertThat(context)
 							.hasSingleBean(org.neo4j.ogm.config.Configuration.class);
-					assertThat(loaded).hasSingleBean(SessionFactory.class);
-					assertThat(loaded).hasSingleBean(Neo4jTransactionManager.class);
-					assertThat(loaded).hasSingleBean(OpenSessionInViewInterceptor.class);
+					assertThat(context).hasSingleBean(SessionFactory.class);
+					assertThat(context).hasSingleBean(Neo4jTransactionManager.class);
+					assertThat(context).hasSingleBean(OpenSessionInViewInterceptor.class);
 				});
 	}
 
 	@Test
 	public void customNeo4jTransactionManagerUsingProperties() {
-		this.context
+		this.contextRunner
 				.withPropertyValues("spring.transaction.default-timeout=30",
 						"spring.transaction.rollback-on-commit-failure:true")
-				.run((loaded) -> {
-					Neo4jTransactionManager transactionManager = loaded
+				.run((context) -> {
+					Neo4jTransactionManager transactionManager = context
 							.getBean(Neo4jTransactionManager.class);
 					assertThat(transactionManager.getDefaultTimeout()).isEqualTo(30);
 					assertThat(transactionManager.isRollbackOnCommitFailure()).isTrue();
@@ -86,20 +87,24 @@ public class Neo4jDataAutoConfigurationTests {
 
 	@Test
 	public void customSessionFactory() {
-		this.context.withUserConfiguration(CustomSessionFactory.class).run((loaded) -> {
-			assertThat(loaded).doesNotHaveBean(org.neo4j.ogm.config.Configuration.class);
-			assertThat(loaded).hasSingleBean(SessionFactory.class);
-		});
+		this.contextRunner.withUserConfiguration(CustomSessionFactory.class)
+				.run((context) -> {
+					assertThat(context)
+							.doesNotHaveBean(org.neo4j.ogm.config.Configuration.class);
+					assertThat(context).hasSingleBean(SessionFactory.class);
+				});
 	}
 
 	@Test
 	public void customConfiguration() {
-		this.context.withUserConfiguration(CustomConfiguration.class).run((loaded) -> {
-			assertThat(loaded.getBean(org.neo4j.ogm.config.Configuration.class))
-					.isSameAs(loaded.getBean("myConfiguration"));
-			assertThat(loaded).hasSingleBean(SessionFactory.class);
-			assertThat(loaded).hasSingleBean(org.neo4j.ogm.config.Configuration.class);
-		});
+		this.contextRunner.withUserConfiguration(CustomConfiguration.class)
+				.run((context) -> {
+					assertThat(context.getBean(org.neo4j.ogm.config.Configuration.class))
+							.isSameAs(context.getBean("myConfiguration"));
+					assertThat(context).hasSingleBean(SessionFactory.class);
+					assertThat(context)
+							.hasSingleBean(org.neo4j.ogm.config.Configuration.class);
+				});
 
 	}
 
@@ -122,21 +127,21 @@ public class Neo4jDataAutoConfigurationTests {
 
 	@Test
 	public void openSessionInViewInterceptorCanBeDisabled() {
-		this.context.withPropertyValues("spring.data.neo4j.open-in-view:false")
-				.run((loaded) -> assertThat(loaded)
+		this.contextRunner.withPropertyValues("spring.data.neo4j.open-in-view:false")
+				.run((context) -> assertThat(context)
 						.doesNotHaveBean(OpenSessionInViewInterceptor.class));
 	}
 
 	@Test
 	public void eventListenersAreAutoRegistered() {
-		this.context.withUserConfiguration(EventListenerConfiguration.class)
-				.run((loaded) -> {
-					Session session = loaded.getBean(SessionFactory.class).openSession();
+		this.contextRunner.withUserConfiguration(EventListenerConfiguration.class)
+				.run((context) -> {
+					Session session = context.getBean(SessionFactory.class).openSession();
 					session.notifyListeners(
 							new PersistenceEvent(null, Event.TYPE.PRE_SAVE));
-					verify(loaded.getBean("eventListenerOne", EventListener.class))
+					verify(context.getBean("eventListenerOne", EventListener.class))
 							.onPreSave(any(Event.class));
-					verify(loaded.getBean("eventListenerTwo", EventListener.class))
+					verify(context.getBean("eventListenerTwo", EventListener.class))
 							.onPreSave(any(Event.class));
 				});
 	}

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/hazelcast/HazelcastAutoConfigurationClientTests.java

@@ -30,7 +30,7 @@ import org.junit.Test;
 
 import org.springframework.beans.factory.BeanCreationException;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
-import org.springframework.boot.test.context.ApplicationContextTester;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
@@ -61,17 +61,17 @@ public class HazelcastAutoConfigurationClientTests {
 		}
 	}
 
-	private final ApplicationContextTester context = new ApplicationContextTester()
+	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
 			.withConfiguration(AutoConfigurations.of(HazelcastAutoConfiguration.class));
 
 	@Test
 	public void systemProperty() throws IOException {
-		this.context
+		this.contextRunner
 				.withSystemProperties(HazelcastClientConfiguration.CONFIG_SYSTEM_PROPERTY
 						+ "=classpath:org/springframework/boot/autoconfigure/hazelcast/"
 						+ "hazelcast-client-specific.xml")
-				.run((loaded) -> {
-					assertThat(loaded).getBean(HazelcastInstance.class)
+				.run((context) -> {
+					assertThat(context).getBean(HazelcastInstance.class)
 							.isInstanceOf(HazelcastInstance.class)
 							.has(nameStartingWith("hz.client_"));
 				});
@@ -79,12 +79,12 @@ public class HazelcastAutoConfigurationClientTests {
 
 	@Test
 	public void explicitConfigFile() throws IOException {
-		this.context
+		this.contextRunner
 				.withPropertyValues(
 						"spring.hazelcast.config=org/springframework/boot/autoconfigure/"
 								+ "hazelcast/hazelcast-client-specific.xml")
-				.run((loaded) -> {
-					assertThat(loaded).getBean(HazelcastInstance.class)
+				.run((context) -> {
+					assertThat(context).getBean(HazelcastInstance.class)
 							.isInstanceOf(HazelcastClientProxy.class)
 							.has(nameStartingWith("hz.client_"));
 				});
@@ -92,11 +92,11 @@ public class HazelcastAutoConfigurationClientTests {
 
 	@Test
 	public void explicitConfigUrl() throws IOException {
-		this.context
+		this.contextRunner
 				.withPropertyValues(
 						"spring.hazelcast.config=hazelcast-client-default.xml")
-				.run((loaded) -> {
-					assertThat(loaded).getBean(HazelcastInstance.class)
+				.run((context) -> {
+					assertThat(context).getBean(HazelcastInstance.class)
 							.isInstanceOf(HazelcastClientProxy.class)
 							.has(nameStartingWith("hz.client_"));
 				});
@@ -104,9 +104,10 @@ public class HazelcastAutoConfigurationClientTests {
 
 	@Test
 	public void unknownConfigFile() {
-		this.context.withPropertyValues("spring.hazelcast.config=foo/bar/unknown.xml")
-				.run((loaded) -> {
-					assertThat(loaded).getFailure()
+		this.contextRunner
+				.withPropertyValues("spring.hazelcast.config=foo/bar/unknown.xml")
+				.run((context) -> {
+					assertThat(context).getFailure()
 							.isInstanceOf(BeanCreationException.class)
 							.hasMessageContaining("foo/bar/unknown.xml");
 				});
@@ -114,10 +115,10 @@ public class HazelcastAutoConfigurationClientTests {
 
 	@Test
 	public void clientConfigTakesPrecedence() {
-		this.context.withUserConfiguration(HazelcastServerAndClientConfig.class)
+		this.contextRunner.withUserConfiguration(HazelcastServerAndClientConfig.class)
 				.withPropertyValues("spring.hazelcast.config=this-is-ignored.xml")
-				.run((loaded) -> {
-					assertThat(loaded).getBean(HazelcastInstance.class)
+				.run((context) -> {
+					assertThat(context).getBean(HazelcastInstance.class)
 							.isInstanceOf(HazelcastClientProxy.class);
 				});
 	}

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/hazelcast/HazelcastAutoConfigurationServerTests.java

@@ -28,7 +28,7 @@ import org.junit.runner.RunWith;
 
 import org.springframework.beans.factory.BeanCreationException;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
-import org.springframework.boot.test.context.ApplicationContextTester;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
 import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
 import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
 import org.springframework.context.annotation.Bean;
@@ -46,14 +46,14 @@ import static org.assertj.core.api.Assertions.assertThat;
 @ClassPathExclusions("hazelcast-client-*.jar")
 public class HazelcastAutoConfigurationServerTests {
 
-	private final ApplicationContextTester context = new ApplicationContextTester()
+	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
 			.withConfiguration(AutoConfigurations.of(HazelcastAutoConfiguration.class));
 
 	@Test
 	public void defaultConfigFile() throws IOException {
 		// hazelcast.xml present in root classpath
-		this.context.run((loaded) -> {
-			Config config = loaded.getBean(HazelcastInstance.class).getConfig();
+		this.contextRunner.run((context) -> {
+			Config config = context.getBean(HazelcastInstance.class).getConfig();
 			assertThat(config.getConfigurationUrl())
 					.isEqualTo(new ClassPathResource("hazelcast.xml").getURL());
 		});
@@ -61,22 +61,22 @@ public class HazelcastAutoConfigurationServerTests {
 
 	@Test
 	public void systemProperty() throws IOException {
-		this.context
+		this.contextRunner
 				.withSystemProperties(HazelcastServerConfiguration.CONFIG_SYSTEM_PROPERTY
 						+ "=classpath:org/springframework/boot/autoconfigure/hazelcast/hazelcast-specific.xml")
-				.run((loaded) -> {
-					Config config = loaded.getBean(HazelcastInstance.class).getConfig();
+				.run((context) -> {
+					Config config = context.getBean(HazelcastInstance.class).getConfig();
 					assertThat(config.getQueueConfigs().keySet()).containsOnly("foobar");
 				});
 	}
 
 	@Test
 	public void explicitConfigFile() throws IOException {
-		this.context.withPropertyValues(
+		this.contextRunner.withPropertyValues(
 				"spring.hazelcast.config=org/springframework/boot/autoconfigure/hazelcast/"
 						+ "hazelcast-specific.xml")
-				.run((loaded) -> {
-					Config config = loaded.getBean(HazelcastInstance.class).getConfig();
+				.run((context) -> {
+					Config config = context.getBean(HazelcastInstance.class).getConfig();
 					assertThat(config.getConfigurationFile())
 							.isEqualTo(new ClassPathResource(
 									"org/springframework/boot/autoconfigure/hazelcast"
@@ -86,9 +86,10 @@ public class HazelcastAutoConfigurationServerTests {
 
 	@Test
 	public void explicitConfigUrl() throws IOException {
-		this.context.withPropertyValues("spring.hazelcast.config=hazelcast-default.xml")
-				.run((loaded) -> {
-					Config config = loaded.getBean(HazelcastInstance.class).getConfig();
+		this.contextRunner
+				.withPropertyValues("spring.hazelcast.config=hazelcast-default.xml")
+				.run((context) -> {
+					Config config = context.getBean(HazelcastInstance.class).getConfig();
 					assertThat(config.getConfigurationUrl()).isEqualTo(
 							new ClassPathResource("hazelcast-default.xml").getURL());
 				});
@@ -96,9 +97,10 @@ public class HazelcastAutoConfigurationServerTests {
 
 	@Test
 	public void unknownConfigFile() {
-		this.context.withPropertyValues("spring.hazelcast.config=foo/bar/unknown.xml")
-				.run((loaded) -> {
-					assertThat(loaded).getFailure()
+		this.contextRunner
+				.withPropertyValues("spring.hazelcast.config=foo/bar/unknown.xml")
+				.run((context) -> {
+					assertThat(context).getFailure()
 							.isInstanceOf(BeanCreationException.class)
 							.hasMessageContaining("foo/bar/unknown.xml");
 				});
@@ -109,10 +111,10 @@ public class HazelcastAutoConfigurationServerTests {
 		Config config = new Config("my-test-instance");
 		HazelcastInstance existing = Hazelcast.newHazelcastInstance(config);
 		try {
-			this.context.withUserConfiguration(HazelcastConfigWithName.class)
+			this.contextRunner.withUserConfiguration(HazelcastConfigWithName.class)
 					.withPropertyValues("spring.hazelcast.config=this-is-ignored.xml")
-					.run(loaded -> {
-						HazelcastInstance hazelcast = (loaded)
+					.run((context) -> {
+						HazelcastInstance hazelcast = context
 								.getBean(HazelcastInstance.class);
 						assertThat(hazelcast.getConfig().getInstanceName())
 								.isEqualTo("my-test-instance");
@@ -127,10 +129,10 @@ public class HazelcastAutoConfigurationServerTests {
 
 	@Test
 	public void configInstanceWithoutName() {
-		this.context.withUserConfiguration(HazelcastConfigNoName.class)
+		this.contextRunner.withUserConfiguration(HazelcastConfigNoName.class)
 				.withPropertyValues("spring.hazelcast.config=this-is-ignored.xml")
-				.run((loaded) -> {
-					Config config = loaded.getBean(HazelcastInstance.class).getConfig();
+				.run((context) -> {
+					Config config = context.getBean(HazelcastInstance.class).getConfig();
 					Map<String, QueueConfig> queueConfigs = config.getQueueConfigs();
 					assertThat(queueConfigs.keySet()).containsOnly("another-queue");
 				});

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/hazelcast/HazelcastAutoConfigurationTests.java

@@ -23,7 +23,7 @@ import com.hazelcast.core.HazelcastInstance;
 import org.junit.Test;
 
 import org.springframework.boot.autoconfigure.AutoConfigurations;
-import org.springframework.boot.test.context.ApplicationContextTester;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
 import org.springframework.core.io.ClassPathResource;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -35,14 +35,14 @@ import static org.assertj.core.api.Assertions.assertThat;
  */
 public class HazelcastAutoConfigurationTests {
 
-	private final ApplicationContextTester context = new ApplicationContextTester()
+	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
 			.withConfiguration(AutoConfigurations.of(HazelcastAutoConfiguration.class));
 
 	@Test
 	public void defaultConfigFile() throws IOException {
 		// no hazelcast-client.xml and hazelcast.xml is present in root classpath
-		this.context.run((loaded) -> {
-			Config config = loaded.getBean(HazelcastInstance.class).getConfig();
+		this.contextRunner.run((context) -> {
+			Config config = context.getBean(HazelcastInstance.class).getConfig();
 			assertThat(config.getConfigurationUrl())
 					.isEqualTo(new ClassPathResource("hazelcast.xml").getURL());
 		});

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/influx/InfluxDbAutoConfigurationTests.java

@@ -25,8 +25,8 @@ import retrofit2.Retrofit;
 
 import org.springframework.beans.DirectFieldAccessor;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
-import org.springframework.boot.test.context.ApplicationContextTester;
-import org.springframework.boot.test.context.AssertableApplicationContext;
+import org.springframework.boot.test.context.assertj.AssertableApplicationContext;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
@@ -41,59 +41,60 @@ import static org.assertj.core.api.Assertions.assertThat;
  */
 public class InfluxDbAutoConfigurationTests {
 
-	private final ApplicationContextTester context = new ApplicationContextTester()
+	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
 			.withConfiguration(AutoConfigurations.of(InfluxDbAutoConfiguration.class));
 
 	@Test
 	public void influxDbRequiresUrl() {
-		this.context.run(
-				(loaded) -> assertThat(loaded.getBeansOfType(InfluxDB.class)).isEmpty());
+		this.contextRunner
+				.run((context) -> assertThat(context.getBeansOfType(InfluxDB.class))
+						.isEmpty());
 	}
 
 	@Test
 	public void influxDbCanBeCustomized() {
-		this.context
+		this.contextRunner
 				.withPropertyValues("spring.influx.url=http://localhost",
 						"spring.influx.password:password", "spring.influx.user:user")
-				.run((loaded -> assertThat(loaded.getBeansOfType(InfluxDB.class))
+				.run(((context) -> assertThat(context.getBeansOfType(InfluxDB.class))
 						.hasSize(1)));
 	}
 
 	@Test
 	public void influxDbCanBeCreatedWithoutCredentials() {
-		this.context.withPropertyValues("spring.influx.url=http://localhost")
-				.run((loaded) -> {
-					assertThat(loaded.getBeansOfType(InfluxDB.class)).hasSize(1);
-					int readTimeout = getReadTimeoutProperty(loaded);
+		this.contextRunner.withPropertyValues("spring.influx.url=http://localhost")
+				.run((context) -> {
+					assertThat(context.getBeansOfType(InfluxDB.class)).hasSize(1);
+					int readTimeout = getReadTimeoutProperty(context);
 					assertThat(readTimeout).isEqualTo(10_000);
 				});
 	}
 
 	@Test
 	public void influxDbWithoutCredentialsAndOkHttpClientBuilder() {
-		this.context.withUserConfiguration(CustomOkHttpClientBuilderConfig.class)
+		this.contextRunner.withUserConfiguration(CustomOkHttpClientBuilderConfig.class)
 				.withPropertyValues("spring.influx.url=http://localhost")
-				.run((loaded) -> {
-					assertThat(loaded.getBeansOfType(InfluxDB.class)).hasSize(1);
-					int readTimeout = getReadTimeoutProperty(loaded);
+				.run((context) -> {
+					assertThat(context.getBeansOfType(InfluxDB.class)).hasSize(1);
+					int readTimeout = getReadTimeoutProperty(context);
 					assertThat(readTimeout).isEqualTo(30_000);
 				});
 	}
 
 	@Test
 	public void influxDbWithOkHttpClientBuilder() {
-		this.context.withUserConfiguration(CustomOkHttpClientBuilderConfig.class)
+		this.contextRunner.withUserConfiguration(CustomOkHttpClientBuilderConfig.class)
 				.withPropertyValues("spring.influx.url=http://localhost",
 						"spring.influx.password:password", "spring.influx.user:user")
-				.run((loaded) -> {
-					assertThat(loaded.getBeansOfType(InfluxDB.class)).hasSize(1);
-					int readTimeout = getReadTimeoutProperty(loaded);
+				.run((context) -> {
+					assertThat(context.getBeansOfType(InfluxDB.class)).hasSize(1);
+					int readTimeout = getReadTimeoutProperty(context);
 					assertThat(readTimeout).isEqualTo(30_000);
 				});
 	}
 
-	private int getReadTimeoutProperty(AssertableApplicationContext loaded) {
-		InfluxDB influxDB = loaded.getBean(InfluxDB.class);
+	private int getReadTimeoutProperty(AssertableApplicationContext context) {
+		InfluxDB influxDB = context.getBean(InfluxDB.class);
 		Retrofit retrofit = (Retrofit) new DirectFieldAccessor(influxDB)
 				.getPropertyValue("retrofit");
 		OkHttpClient callFactory = (OkHttpClient) new DirectFieldAccessor(retrofit)

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfigurationTests.java

@@ -39,9 +39,9 @@ import org.springframework.beans.factory.BeanCreationException;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 import org.springframework.boot.jdbc.DatabaseDriver;
-import org.springframework.boot.test.context.ApplicationContextTester;
-import org.springframework.boot.test.context.AssertableApplicationContext;
 import org.springframework.boot.test.context.HidePackagesClassLoader;
+import org.springframework.boot.test.context.assertj.AssertableApplicationContext;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.jdbc.core.JdbcTemplate;
@@ -58,7 +58,7 @@ import static org.mockito.Mockito.mock;
  */
 public class DataSourceAutoConfigurationTests {
 
-	private final ApplicationContextTester context = new ApplicationContextTester()
+	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
 			.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class))
 			.withPropertyValues("spring.datasource.initialize=false",
 					"spring.datasource.url:jdbc:hsqldb:mem:testdb-"
@@ -66,13 +66,14 @@ public class DataSourceAutoConfigurationTests {
 
 	@Test
 	public void testDefaultDataSourceExists() throws Exception {
-		this.context.run((loaded) -> assertThat(loaded).hasSingleBean(DataSource.class));
+		this.contextRunner
+				.run((context) -> assertThat(context).hasSingleBean(DataSource.class));
 	}
 
 	@Test
 	public void testDataSourceHasEmbeddedDefault() throws Exception {
-		this.context.run((loaded) -> {
-			HikariDataSource dataSource = loaded.getBean(HikariDataSource.class);
+		this.contextRunner.run((context) -> {
+			HikariDataSource dataSource = context.getBean(HikariDataSource.class);
 			assertThat(dataSource.getJdbcUrl()).isNotNull();
 			assertThat(dataSource.getDriverClassName()).isNotNull();
 		});
@@ -82,10 +83,10 @@ public class DataSourceAutoConfigurationTests {
 	public void testBadUrl() throws Exception {
 		try {
 			EmbeddedDatabaseConnection.override = EmbeddedDatabaseConnection.NONE;
-			this.context
+			this.contextRunner
 					.withPropertyValues("spring.datasource.url:jdbc:not-going-to-work")
-					.run((loaded) -> {
-						assertThat(loaded).getFailure()
+					.run((context) -> {
+						assertThat(context).getFailure()
 								.isInstanceOf(BeanCreationException.class);
 					});
 		}
@@ -96,11 +97,11 @@ public class DataSourceAutoConfigurationTests {
 
 	@Test
 	public void testBadDriverClass() throws Exception {
-		this.context
+		this.contextRunner
 				.withPropertyValues(
 						"spring.datasource.driverClassName:org.none.jdbcDriver")
-				.run((loaded) -> {
-					assertThat(loaded).getFailure()
+				.run((context) -> {
+					assertThat(context).getFailure()
 							.isInstanceOf(BeanCreationException.class)
 							.hasMessageContaining("org.none.jdbcDriver");
 				});
@@ -153,10 +154,10 @@ public class DataSourceAutoConfigurationTests {
 	@Test
 	@SuppressWarnings("resource")
 	public void testEmbeddedTypeDefaultsUsername() throws Exception {
-		this.context.withPropertyValues(
+		this.contextRunner.withPropertyValues(
 				"spring.datasource.driverClassName:org.hsqldb.jdbcDriver",
-				"spring.datasource.url:jdbc:hsqldb:mem:testdb").run((loaded) -> {
-					DataSource bean = loaded.getBean(DataSource.class);
+				"spring.datasource.url:jdbc:hsqldb:mem:testdb").run((context) -> {
+					DataSource bean = context.getBean(DataSource.class);
 					HikariDataSource pool = (HikariDataSource) bean;
 					assertThat(pool.getDriverClassName())
 							.isEqualTo("org.hsqldb.jdbcDriver");
@@ -170,7 +171,7 @@ public class DataSourceAutoConfigurationTests {
 	 */
 	@Test
 	public void explicitTypeNoSupportedDataSource() {
-		this.context
+		this.contextRunner
 				.withClassLoader(new HidePackagesClassLoader("org.apache.tomcat",
 						"com.zaxxer.hikari", "org.apache.commons.dbcp",
 						"org.apache.commons.dbcp2"))
@@ -184,7 +185,7 @@ public class DataSourceAutoConfigurationTests {
 
 	@Test
 	public void explicitTypeSupportedDataSource() {
-		this.context
+		this.contextRunner
 				.withPropertyValues(
 						"spring.datasource.driverClassName:org.hsqldb.jdbcDriver",
 						"spring.datasource.url:jdbc:hsqldb:mem:testdb",
@@ -193,19 +194,20 @@ public class DataSourceAutoConfigurationTests {
 				.run(this::containsOnlySimpleDriverDataSource);
 	}
 
-	private void containsOnlySimpleDriverDataSource(AssertableApplicationContext loaded) {
-		assertThat(loaded).hasSingleBean(DataSource.class);
-		assertThat(loaded).getBean(DataSource.class)
+	private void containsOnlySimpleDriverDataSource(
+			AssertableApplicationContext context) {
+		assertThat(context).hasSingleBean(DataSource.class);
+		assertThat(context).getBean(DataSource.class)
 				.isExactlyInstanceOf(SimpleDriverDataSource.class);
 	}
 
 	@Test
 	public void testExplicitDriverClassClearsUsername() throws Exception {
-		this.context.withPropertyValues(
+		this.contextRunner.withPropertyValues(
 				"spring.datasource.driverClassName:" + DatabaseTestDriver.class.getName(),
-				"spring.datasource.url:jdbc:foo://localhost").run((loaded) -> {
-					assertThat(loaded).hasSingleBean(DataSource.class);
-					HikariDataSource dataSource = loaded.getBean(HikariDataSource.class);
+				"spring.datasource.url:jdbc:foo://localhost").run((context) -> {
+					assertThat(context).hasSingleBean(DataSource.class);
+					HikariDataSource dataSource = context.getBean(HikariDataSource.class);
 					assertThat(dataSource.getDriverClassName())
 							.isEqualTo(DatabaseTestDriver.class.getName());
 					assertThat(dataSource.getUsername()).isNull();
@@ -214,18 +216,19 @@ public class DataSourceAutoConfigurationTests {
 
 	@Test
 	public void testDefaultDataSourceCanBeOverridden() throws Exception {
-		this.context.withUserConfiguration(TestDataSourceConfiguration.class)
-				.run((loaded) -> {
-					assertThat(loaded).getBean(DataSource.class)
+		this.contextRunner.withUserConfiguration(TestDataSourceConfiguration.class)
+				.run((context) -> {
+					assertThat(context).getBean(DataSource.class)
 							.isInstanceOf(BasicDataSource.class);
 				});
 	}
 
 	@Test
 	public void testDataSourceIsInitializedEarly() {
-		this.context.withUserConfiguration(TestInitializedDataSourceConfiguration.class)
+		this.contextRunner
+				.withUserConfiguration(TestInitializedDataSourceConfiguration.class)
 				.withPropertyValues("spring.datasource.initialize=true")
-				.run((loaded) -> assertThat(loaded
+				.run((context) -> assertThat(context
 						.getBean(TestInitializedDataSourceConfiguration.class).called)
 								.isTrue());
 	}
@@ -234,8 +237,8 @@ public class DataSourceAutoConfigurationTests {
 			List<String> hiddenPackages, Consumer<T> consumer) {
 		HidePackagesClassLoader classLoader = new HidePackagesClassLoader(
 				hiddenPackages.toArray(new String[hiddenPackages.size()]));
-		this.context.withClassLoader(classLoader).run((loaded) -> {
-			DataSource bean = loaded.getBean(DataSource.class);
+		this.contextRunner.withClassLoader(classLoader).run((context) -> {
+			DataSource bean = context.getBean(DataSource.class);
 			assertThat(bean).isInstanceOf(expectedType);
 			consumer.accept(expectedType.cast(bean));
 		});

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceJmxConfigurationTests.java

@@ -130,7 +130,7 @@ public class DataSourceJmxConfigurationTests {
 	private void load(Class<?> config, String... environment) {
 		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
 		String jdbcUrl = "jdbc:hsqldb:mem:test-" + UUID.randomUUID().toString();
-		TestPropertyValues.of(environment).and("spring.datasource.url", jdbcUrl)
+		TestPropertyValues.of(environment).and("spring.datasource.url=" + jdbcUrl)
 				.applyTo(context);
 		if (config != null) {
 			context.register(config);

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/HikariDataSourceConfigurationTests.java

@@ -104,8 +104,8 @@ public class HikariDataSourceConfigurationTests {
 
 	private void load(String... environment) {
 		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-		TestPropertyValues.of(environment).and("spring.datasource.initialize", "false")
-				.and("spring.datasource.type", HikariDataSource.class.getName())
+		TestPropertyValues.of(environment).and("spring.datasource.initialize=false")
+				.and("spring.datasource.type=" + HikariDataSource.class.getName())
 				.applyTo(ctx);
 		ctx.register(DataSourceAutoConfiguration.class);
 		ctx.refresh();

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jms/activemq/ActiveMQAutoConfigurationTests.java

@@ -25,7 +25,7 @@ import org.junit.Test;
 
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 import org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration;
-import org.springframework.boot.test.context.ApplicationContextTester;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
@@ -42,36 +42,39 @@ import static org.mockito.Mockito.mockingDetails;
  */
 public class ActiveMQAutoConfigurationTests {
 
-	private final ApplicationContextTester context = new ApplicationContextTester()
+	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
 			.withConfiguration(AutoConfigurations.of(ActiveMQAutoConfiguration.class,
 					JmsAutoConfiguration.class));
 
 	@Test
 	public void brokerIsEmbeddedByDefault() {
-		this.context.withUserConfiguration(EmptyConfiguration.class).run((loaded) -> {
-			assertThat(loaded).getBean(ConnectionFactory.class)
-					.isInstanceOf(ActiveMQConnectionFactory.class);
-			assertThat(loaded.getBean(ActiveMQConnectionFactory.class).getBrokerURL())
-					.isEqualTo("vm://localhost?broker.persistent=false");
-		});
+		this.contextRunner.withUserConfiguration(EmptyConfiguration.class)
+				.run((context) -> {
+					assertThat(context).getBean(ConnectionFactory.class)
+							.isInstanceOf(ActiveMQConnectionFactory.class);
+					assertThat(context.getBean(ActiveMQConnectionFactory.class)
+							.getBrokerURL())
+									.isEqualTo("vm://localhost?broker.persistent=false");
+				});
 	}
 
 	@Test
 	public void configurationBacksOffWhenCustomConnectionFactoryExists() {
-		this.context.withUserConfiguration(CustomConnectionFactoryConfiguration.class)
-				.run((loaded) -> assertThat(
-						mockingDetails(loaded.getBean(ConnectionFactory.class)).isMock())
+		this.contextRunner
+				.withUserConfiguration(CustomConnectionFactoryConfiguration.class)
+				.run((context) -> assertThat(
+						mockingDetails(context.getBean(ConnectionFactory.class)).isMock())
 								.isTrue());
 	}
 
 	@Test
 	public void defaultsConnectionFactoryAreApplied() {
-		this.context.withUserConfiguration(EmptyConfiguration.class)
+		this.contextRunner.withUserConfiguration(EmptyConfiguration.class)
 				.withPropertyValues("spring.activemq.pool.enabled=false")
-				.run((loaded) -> {
-					assertThat(loaded.getBeansOfType(ActiveMQConnectionFactory.class))
+				.run((context) -> {
+					assertThat(context.getBeansOfType(ActiveMQConnectionFactory.class))
 							.hasSize(1);
-					ActiveMQConnectionFactory connectionFactory = loaded
+					ActiveMQConnectionFactory connectionFactory = context
 							.getBean(ActiveMQConnectionFactory.class);
 					ActiveMQConnectionFactory defaultFactory = new ActiveMQConnectionFactory(
 							"vm://localhost?broker.persistent=false");
@@ -94,7 +97,7 @@ public class ActiveMQAutoConfigurationTests {
 
 	@Test
 	public void customConnectionFactoryAreApplied() {
-		this.context.withUserConfiguration(EmptyConfiguration.class)
+		this.contextRunner.withUserConfiguration(EmptyConfiguration.class)
 				.withPropertyValues("spring.activemq.pool.enabled=false",
 						"spring.activemq.brokerUrl=vm://localhost?useJmx=false&broker.persistent=false",
 						"spring.activemq.user=foo", "spring.activemq.password=bar",
@@ -103,10 +106,10 @@ public class ActiveMQAutoConfigurationTests {
 						"spring.activemq.sendTimeout=1000",
 						"spring.activemq.packages.trust-all=false",
 						"spring.activemq.packages.trusted=com.example.acme")
-				.run((loaded) -> {
-					assertThat(loaded.getBeansOfType(ActiveMQConnectionFactory.class))
+				.run((context) -> {
+					assertThat(context.getBeansOfType(ActiveMQConnectionFactory.class))
 							.hasSize(1);
-					ActiveMQConnectionFactory connectionFactory = loaded
+					ActiveMQConnectionFactory connectionFactory = context
 							.getBean(ActiveMQConnectionFactory.class);
 					assertThat(connectionFactory.getUserName()).isEqualTo("foo");
 					assertThat(connectionFactory.getPassword()).isEqualTo("bar");
@@ -122,11 +125,12 @@ public class ActiveMQAutoConfigurationTests {
 
 	@Test
 	public void defaultsPooledConnectionFactoryAreApplied() {
-		this.context.withUserConfiguration(EmptyConfiguration.class)
-				.withPropertyValues("spring.activemq.pool.enabled=true").run((loaded) -> {
-					assertThat(loaded.getBeansOfType(PooledConnectionFactory.class))
+		this.contextRunner.withUserConfiguration(EmptyConfiguration.class)
+				.withPropertyValues("spring.activemq.pool.enabled=true")
+				.run((context) -> {
+					assertThat(context.getBeansOfType(PooledConnectionFactory.class))
 							.hasSize(1);
-					PooledConnectionFactory connectionFactory = loaded
+					PooledConnectionFactory connectionFactory = context
 							.getBean(PooledConnectionFactory.class);
 					PooledConnectionFactory defaultFactory = new PooledConnectionFactory();
 					assertThat(connectionFactory.isBlockIfSessionPoolIsFull())
@@ -157,7 +161,7 @@ public class ActiveMQAutoConfigurationTests {
 
 	@Test
 	public void customPooledConnectionFactoryAreApplied() {
-		this.context.withUserConfiguration(EmptyConfiguration.class)
+		this.contextRunner.withUserConfiguration(EmptyConfiguration.class)
 				.withPropertyValues("spring.activemq.pool.enabled=true",
 						"spring.activemq.pool.blockIfFull=false",
 						"spring.activemq.pool.blockIfFullTimeout=64",
@@ -169,10 +173,10 @@ public class ActiveMQAutoConfigurationTests {
 						"spring.activemq.pool.reconnectOnException=false",
 						"spring.activemq.pool.timeBetweenExpirationCheck=2048",
 						"spring.activemq.pool.useAnonymousProducers=false")
-				.run((loaded) -> {
-					assertThat(loaded.getBeansOfType(PooledConnectionFactory.class))
+				.run((context) -> {
+					assertThat(context.getBeansOfType(PooledConnectionFactory.class))
 							.hasSize(1);
-					PooledConnectionFactory connectionFactory = loaded
+					PooledConnectionFactory connectionFactory = context
 							.getBean(PooledConnectionFactory.class);
 					assertThat(connectionFactory.isBlockIfSessionPoolIsFull())
 							.isEqualTo(false);
@@ -196,11 +200,12 @@ public class ActiveMQAutoConfigurationTests {
 
 	@Test
 	public void pooledConnectionFactoryConfiguration() throws JMSException {
-		this.context.withUserConfiguration(EmptyConfiguration.class)
-				.withPropertyValues("spring.activemq.pool.enabled:true").run((loaded) -> {
-					ConnectionFactory factory = loaded.getBean(ConnectionFactory.class);
+		this.contextRunner.withUserConfiguration(EmptyConfiguration.class)
+				.withPropertyValues("spring.activemq.pool.enabled:true")
+				.run((context) -> {
+					ConnectionFactory factory = context.getBean(ConnectionFactory.class);
 					assertThat(factory).isInstanceOf(PooledConnectionFactory.class);
-					loaded.getSourceApplicationContext().close();
+					context.getSourceApplicationContext().close();
 					assertThat(factory.createConnection()).isNull();
 				});
 	}

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/AbstractJpaAutoConfigurationTests.java

@@ -213,7 +213,7 @@ public abstract class AbstractJpaAutoConfigurationTests {
 			ctx.setClassLoader(classLoader);
 		}
 		TestPropertyValues.of(environment)
-				.and("spring.datasource.generate-unique-name", "true").applyTo(ctx);
+				.and("spring.datasource.generate-unique-name=true").applyTo(ctx);
 		ctx.register(TestConfiguration.class);
 		if (!ObjectUtils.isEmpty(configs)) {
 			ctx.register(configs);

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/web/reactive/HttpHandlerAutoConfigurationTests.java

@@ -19,7 +19,7 @@ package org.springframework.boot.autoconfigure.web.reactive;
 import org.junit.Test;
 
 import org.springframework.boot.autoconfigure.AutoConfigurations;
-import org.springframework.boot.test.context.ReactiveWebApplicationContextTester;
+import org.springframework.boot.test.context.runner.ReactiveWebApplicationContextRunner;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.http.server.reactive.HttpHandler;
@@ -39,24 +39,25 @@ import static org.assertj.core.api.Assertions.assertThat;
  */
 public class HttpHandlerAutoConfigurationTests {
 
-	private final ReactiveWebApplicationContextTester context = new ReactiveWebApplicationContextTester()
+	private final ReactiveWebApplicationContextRunner contextRunner = new ReactiveWebApplicationContextRunner()
 			.withConfiguration(AutoConfigurations.of(HttpHandlerAutoConfiguration.class));
 
 	@Test
 	public void shouldNotProcessIfExistingHttpHandler() {
-		this.context.withUserConfiguration(CustomHttpHandler.class).run((loaded) -> {
-			assertThat(loaded).hasSingleBean(HttpHandler.class);
-			assertThat(loaded).getBean(HttpHandler.class)
-					.isSameAs(loaded.getBean("customHttpHandler"));
-		});
+		this.contextRunner.withUserConfiguration(CustomHttpHandler.class)
+				.run((context) -> {
+					assertThat(context).hasSingleBean(HttpHandler.class);
+					assertThat(context).getBean(HttpHandler.class)
+							.isSameAs(context.getBean("customHttpHandler"));
+				});
 	}
 
 	@Test
 	public void shouldConfigureHttpHandlerAnnotation() {
-		this.context
+		this.contextRunner
 				.withConfiguration(AutoConfigurations.of(WebFluxAutoConfiguration.class))
-				.run((loaded) -> {
-					assertThat(loaded).hasSingleBean(HttpHandler.class);
+				.run((context) -> {
+					assertThat(context).hasSingleBean(HttpHandler.class);
 				});
 	}
 

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/webservices/WebServicesAutoConfigurationTests.java

@@ -24,7 +24,7 @@ import org.junit.rules.ExpectedException;
 
 import org.springframework.beans.factory.BeanCreationException;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
-import org.springframework.boot.test.context.WebApplicationContextTester;
+import org.springframework.boot.test.context.runner.WebApplicationContextRunner;
 import org.springframework.boot.web.servlet.ServletRegistrationBean;
 import org.springframework.context.ApplicationContext;
 import org.springframework.test.util.ReflectionTestUtils;
@@ -40,7 +40,7 @@ import static org.assertj.core.api.Assertions.assertThat;
  */
 public class WebServicesAutoConfigurationTests {
 
-	private final WebApplicationContextTester context = new WebApplicationContextTester()
+	private final WebApplicationContextRunner contextRunner = new WebApplicationContextRunner()
 			.withConfiguration(AutoConfigurations.of(WebServicesAutoConfiguration.class));
 
 	@Rule
@@ -48,15 +48,15 @@ public class WebServicesAutoConfigurationTests {
 
 	@Test
 	public void defaultConfiguration() {
-		this.context.run((loaded) -> assertThat(loaded)
+		this.contextRunner.run((context) -> assertThat(context)
 				.hasSingleBean(ServletRegistrationBean.class));
 	}
 
 	@Test
 	public void customPathMustBeginWithASlash() {
-		this.context.withPropertyValues("spring.webservices.path=invalid")
-				.run((loaded) -> {
-					assertThat(loaded).getFailure()
+		this.contextRunner.withPropertyValues("spring.webservices.path=invalid")
+				.run((context) -> {
+					assertThat(context).getFailure()
 							.isInstanceOf(BeanCreationException.class)
 							.hasMessageContaining(
 									"Failed to bind properties under 'spring.webservices'");
@@ -65,21 +65,22 @@ public class WebServicesAutoConfigurationTests {
 
 	@Test
 	public void customPath() {
-		this.context.withPropertyValues("spring.webservices.path=/valid")
-				.run((loaded) -> assertThat(getUrlMappings(loaded)).contains("/valid/*"));
+		this.contextRunner.withPropertyValues("spring.webservices.path=/valid").run(
+				(context) -> assertThat(getUrlMappings(context)).contains("/valid/*"));
 	}
 
 	@Test
 	public void customPathWithTrailingSlash() {
-		this.context.withPropertyValues("spring.webservices.path=/valid/")
-				.run((loaded) -> assertThat(getUrlMappings(loaded)).contains("/valid/*"));
+		this.contextRunner.withPropertyValues("spring.webservices.path=/valid/").run(
+				(context) -> assertThat(getUrlMappings(context)).contains("/valid/*"));
 	}
 
 	@Test
 	public void customLoadOnStartup() {
-		this.context.withPropertyValues("spring.webservices.servlet.load-on-startup=1")
-				.run((loaded) -> {
-					ServletRegistrationBean<?> registrationBean = loaded
+		this.contextRunner
+				.withPropertyValues("spring.webservices.servlet.load-on-startup=1")
+				.run((context) -> {
+					ServletRegistrationBean<?> registrationBean = context
 							.getBean(ServletRegistrationBean.class);
 					assertThat(ReflectionTestUtils.getField(registrationBean,
 							"loadOnStartup")).isEqualTo(1);
@@ -88,17 +89,17 @@ public class WebServicesAutoConfigurationTests {
 
 	@Test
 	public void customInitParameters() {
-		this.context
+		this.contextRunner
 				.withPropertyValues("spring.webservices.servlet.init.key1=value1",
 						"spring.webservices.servlet.init.key2=value2")
-				.run(loaded -> assertThat(
-						getServletRegistrationBean(loaded).getInitParameters())
+				.run((context) -> assertThat(
+						getServletRegistrationBean(context).getInitParameters())
 								.containsEntry("key1", "value1")
 								.containsEntry("key2", "value2"));
 	}
 
-	private Collection<String> getUrlMappings(ApplicationContext loaded) {
-		return getServletRegistrationBean(loaded).getUrlMappings();
+	private Collection<String> getUrlMappings(ApplicationContext context) {
+		return getServletRegistrationBean(context).getUrlMappings();
 	}
 
 	private ServletRegistrationBean<?> getServletRegistrationBean(

spring-boot-test-autoconfigure/src/test/java/org/springframework/boot/test/autoconfigure/jdbc/TestDatabaseAutoConfigurationTests.java

@@ -21,7 +21,7 @@ import javax.sql.DataSource;
 import org.junit.Test;
 
 import org.springframework.boot.autoconfigure.AutoConfigurations;
-import org.springframework.boot.test.context.ApplicationContextTester;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.jdbc.core.JdbcTemplate;
@@ -38,24 +38,26 @@ import static org.assertj.core.api.Assertions.assertThat;
  */
 public class TestDatabaseAutoConfigurationTests {
 
-	private final ApplicationContextTester context = new ApplicationContextTester()
+	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
 			.withConfiguration(
 					AutoConfigurations.of(TestDatabaseAutoConfiguration.class));
 
 	@Test
 	public void replaceWithNoDataSourceAvailable() {
-		this.context
-				.run((loaded) -> assertThat(loaded).doesNotHaveBean(DataSource.class));
+		this.contextRunner
+				.run((context) -> assertThat(context).doesNotHaveBean(DataSource.class));
 	}
 
 	@Test
 	public void replaceWithUniqueDatabase() {
-		this.context.withUserConfiguration(ExistingDataSourceConfiguration.class)
-				.run((loaded) -> {
-					DataSource datasource = loaded.getBean(DataSource.class);
+		this.contextRunner.withUserConfiguration(ExistingDataSourceConfiguration.class)
+				.run((context) -> {
+					DataSource datasource = context.getBean(DataSource.class);
 					JdbcTemplate jdbcTemplate = new JdbcTemplate(datasource);
 					jdbcTemplate.execute("create table example (id int, name varchar);");
-					this.context.run((secondContext) -> {
+					this.contextRunner
+							.withUserConfiguration(ExistingDataSourceConfiguration.class)
+							.run((secondContext) -> {
 						DataSource anotherDatasource = secondContext
 								.getBean(DataSource.class);
 						JdbcTemplate anotherJdbcTemplate = new JdbcTemplate(

spring-boot-test-autoconfigure/src/test/java/org/springframework/boot/test/autoconfigure/orm/jpa/TestDatabaseAutoConfigurationNoEmbeddedTests.java

@@ -24,7 +24,7 @@ import org.junit.runner.RunWith;
 import org.springframework.beans.factory.BeanCreationException;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 import org.springframework.boot.test.autoconfigure.jdbc.TestDatabaseAutoConfiguration;
-import org.springframework.boot.test.context.ApplicationContextTester;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
 import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
 import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
 import org.springframework.context.annotation.Bean;
@@ -44,15 +44,15 @@ import static org.mockito.Mockito.mock;
 @ClassPathExclusions({ "h2-*.jar", "hsqldb-*.jar", "derby-*.jar" })
 public class TestDatabaseAutoConfigurationNoEmbeddedTests {
 
-	private final ApplicationContextTester context = new ApplicationContextTester()
+	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
 			.withUserConfiguration(ExistingDataSourceConfiguration.class)
 			.withConfiguration(
 					AutoConfigurations.of(TestDatabaseAutoConfiguration.class));
 
 	@Test
 	public void applyAnyReplace() {
-		this.context.run((loaded) -> {
-			assertThat(loaded).getFailure().isInstanceOf(BeanCreationException.class)
+		this.contextRunner.run((context) -> {
+			assertThat(context).getFailure().isInstanceOf(BeanCreationException.class)
 					.hasMessageContaining(
 							"Failed to replace DataSource with an embedded database for tests.")
 					.hasMessageContaining(
@@ -64,11 +64,11 @@ public class TestDatabaseAutoConfigurationNoEmbeddedTests {
 
 	@Test
 	public void applyNoReplace() {
-		this.context.withPropertyValues("spring.test.database.replace=NONE")
-				.run((loaded) -> {
-					assertThat(loaded).hasSingleBean(DataSource.class);
-					assertThat(loaded).getBean(DataSource.class)
-							.isSameAs(loaded.getBean("myCustomDataSource"));
+		this.contextRunner.withPropertyValues("spring.test.database.replace=NONE")
+				.run((context) -> {
+					assertThat(context).hasSingleBean(DataSource.class);
+					assertThat(context).getBean(DataSource.class)
+							.isSameAs(context.getBean("myCustomDataSource"));
 				});
 	}
 

spring-boot-test/src/main/java/org/springframework/boot/test/context/ApplicationContextAssert.java → spring-boot-test/src/main/java/org/springframework/boot/test/context/assertj/ApplicationContextAssert.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.boot.test.context;
+package org.springframework.boot.test.context.assertj;
 
 import org.assertj.core.api.AbstractAssert;
 import org.assertj.core.api.AbstractObjectArrayAssert;
@@ -25,19 +25,20 @@ import org.assertj.core.api.MapAssert;
 import org.assertj.core.error.BasicErrorMessageFactory;
 
 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
 import org.springframework.context.ApplicationContext;
 import org.springframework.util.Assert;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 /**
- * AspectJ {@link org.assertj.core.api.Assert assertions} that can be applied to an
+ * AssertJ {@link org.assertj.core.api.Assert assertions} that can be applied to an
  * {@link ApplicationContext}.
  *
  * @param <C> The application context type
  * @author Phillip Webb
  * @since 2.0.0
- * @see ApplicationContextTester
+ * @see ApplicationContextRunner
  * @see AssertableApplicationContext
  */
 public class ApplicationContextAssert<C extends ApplicationContext>

spring-boot-test/src/main/java/org/springframework/boot/test/context/AssertProviderApplicationContext.java → spring-boot-test/src/main/java/org/springframework/boot/test/context/assertj/ApplicationContextAssertProvider.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.boot.test.context;
+package org.springframework.boot.test.context.assertj;
 
 import java.io.Closeable;
 import java.lang.reflect.Proxy;
@@ -48,7 +48,7 @@ import org.springframework.util.Assert;
  * @see AssertableReactiveWebApplicationContext
  * @see ApplicationContextAssert
  */
-interface AssertProviderApplicationContext<C extends ApplicationContext> extends
+public interface ApplicationContextAssertProvider<C extends ApplicationContext> extends
 		ApplicationContext, AssertProvider<ApplicationContextAssert<C>>, Closeable {
 
 	/**
@@ -88,19 +88,19 @@ interface AssertProviderApplicationContext<C extends ApplicationContext> extends
 	void close();
 
 	/**
-	 * Factory method to create a new {@link AssertProviderApplicationContext} instance.
+	 * Factory method to create a new {@link ApplicationContextAssertProvider} instance.
 	 * @param <T> the assert provider type
 	 * @param <C> the context type
-	 * @param type the type of {@link AssertProviderApplicationContext} required (must be
+	 * @param type the type of {@link ApplicationContextAssertProvider} required (must be
 	 * an interface)
 	 * @param contextType the type of {@link ApplicationContext} being managed (must be an
 	 * interface)
 	 * @param contextSupplier a supplier that will either return a fully configured
 	 * {@link ApplicationContext} or throw an exception if the context fails to start.
-	 * @return a {@link AssertProviderApplicationContext} instance
+	 * @return a {@link ApplicationContextAssertProvider} instance
 	 */
 	@SuppressWarnings("unchecked")
-	static <T extends AssertProviderApplicationContext<C>, C extends ApplicationContext> T get(
+	static <T extends ApplicationContextAssertProvider<C>, C extends ApplicationContext> T get(
 			Class<T> type, Class<? extends C> contextType,
 			Supplier<? extends C> contextSupplier) {
 		Assert.notNull(type, "Type must not be null");

spring-boot-test/src/main/java/org/springframework/boot/test/context/AssertProviderApplicationContextInvocationHandler.java → spring-boot-test/src/main/java/org/springframework/boot/test/context/assertj/AssertProviderApplicationContextInvocationHandler.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.boot.test.context;
+package org.springframework.boot.test.context.assertj;
 
 import java.io.Closeable;
 import java.io.IOException;
@@ -31,7 +31,7 @@ import org.springframework.util.Assert;
 import org.springframework.util.ObjectUtils;
 
 /**
- * {@link InvocationHandler} used by {@link AssertProviderApplicationContext} generated
+ * {@link InvocationHandler} used by {@link ApplicationContextAssertProvider} generated
  * proxies.
  *
  * @author Phillip Webb

spring-boot-test/src/main/java/org/springframework/boot/test/context/AssertableApplicationContext.java → spring-boot-test/src/main/java/org/springframework/boot/test/context/assertj/AssertableApplicationContext.java

@@ -14,10 +14,11 @@
  * limitations under the License.
  */
 
-package org.springframework.boot.test.context;
+package org.springframework.boot.test.context.assertj;
 
 import java.util.function.Supplier;
 
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ConfigurableApplicationContext;
 
@@ -26,15 +27,15 @@ import org.springframework.context.ConfigurableApplicationContext;
  * be used to decorate and existing application context or an application context that
  * failed to start.
  * <p>
- * See {@link AssertProviderApplicationContext} for more details.
+ * See {@link ApplicationContextAssertProvider} for more details.
  *
  * @author Phillip Webb
  * @since 2.0.0
- * @see ApplicationContextTester
+ * @see ApplicationContextRunner
  * @see ApplicationContext
  */
 public interface AssertableApplicationContext
-		extends AssertProviderApplicationContext<ConfigurableApplicationContext> {
+		extends ApplicationContextAssertProvider<ConfigurableApplicationContext> {
 
 	/**
 	 * Factory method to create a new {@link AssertableApplicationContext} instance.
@@ -45,7 +46,7 @@ public interface AssertableApplicationContext
 	 */
 	static AssertableApplicationContext get(
 			Supplier<? extends ConfigurableApplicationContext> contextSupplier) {
-		return AssertProviderApplicationContext.get(AssertableApplicationContext.class,
+		return ApplicationContextAssertProvider.get(AssertableApplicationContext.class,
 				ConfigurableApplicationContext.class, contextSupplier);
 	}
 

spring-boot-test/src/main/java/org/springframework/boot/test/context/AssertableReactiveWebApplicationContext.java → spring-boot-test/src/main/java/org/springframework/boot/test/context/assertj/AssertableReactiveWebApplicationContext.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.boot.test.context;
+package org.springframework.boot.test.context.assertj;
 
 import java.util.function.Supplier;
 
@@ -26,7 +26,7 @@ import org.springframework.boot.web.reactive.context.ReactiveWebApplicationConte
  * assertions. Can be used to decorate and existing reactive web application context or an
  * application context that failed to start.
  * <p>
- * See {@link AssertProviderApplicationContext} for more details.
+ * See {@link ApplicationContextAssertProvider} for more details.
  *
  * @author Phillip Webb
  * @since 2.0.0
@@ -34,7 +34,7 @@ import org.springframework.boot.web.reactive.context.ReactiveWebApplicationConte
  * @see ReactiveWebApplicationContext
  */
 public interface AssertableReactiveWebApplicationContext extends
-		AssertProviderApplicationContext<ConfigurableReactiveWebApplicationContext>,
+		ApplicationContextAssertProvider<ConfigurableReactiveWebApplicationContext>,
 		ReactiveWebApplicationContext {
 
 	/**
@@ -47,7 +47,7 @@ public interface AssertableReactiveWebApplicationContext extends
 	 */
 	static AssertableReactiveWebApplicationContext get(
 			Supplier<? extends ConfigurableReactiveWebApplicationContext> contextSupplier) {
-		return AssertProviderApplicationContext.get(
+		return ApplicationContextAssertProvider.get(
 				AssertableReactiveWebApplicationContext.class,
 				ConfigurableReactiveWebApplicationContext.class, contextSupplier);
 	}

spring-boot-test/src/main/java/org/springframework/boot/test/context/AssertableWebApplicationContext.java → spring-boot-test/src/main/java/org/springframework/boot/test/context/assertj/AssertableWebApplicationContext.java

@@ -14,10 +14,11 @@
  * limitations under the License.
  */
 
-package org.springframework.boot.test.context;
+package org.springframework.boot.test.context.assertj;
 
 import java.util.function.Supplier;
 
+import org.springframework.boot.test.context.runner.WebApplicationContextRunner;
 import org.springframework.web.context.ConfigurableWebApplicationContext;
 import org.springframework.web.context.WebApplicationContext;
 
@@ -26,15 +27,15 @@ import org.springframework.web.context.WebApplicationContext;
  * Can be used to decorate and existing servlet web application context or an application
  * context that failed to start.
  * <p>
- * See {@link AssertProviderApplicationContext} for more details.
+ * See {@link ApplicationContextAssertProvider} for more details.
  *
  * @author Phillip Webb
  * @since 2.0.0
- * @see WebApplicationContextTester
+ * @see WebApplicationContextRunner
  * @see WebApplicationContext
  */
 public interface AssertableWebApplicationContext
-		extends AssertProviderApplicationContext<ConfigurableWebApplicationContext>,
+		extends ApplicationContextAssertProvider<ConfigurableWebApplicationContext>,
 		WebApplicationContext {
 
 	/**
@@ -46,7 +47,7 @@ public interface AssertableWebApplicationContext
 	 */
 	static AssertableWebApplicationContext get(
 			Supplier<? extends ConfigurableWebApplicationContext> contextSupplier) {
-		return AssertProviderApplicationContext.get(AssertableWebApplicationContext.class,
+		return ApplicationContextAssertProvider.get(AssertableWebApplicationContext.class,
 				ConfigurableWebApplicationContext.class, contextSupplier);
 	}
 

spring-boot-test/src/main/java/org/springframework/boot/test/context/assertj/package-info.java

+/*
+ * Copyright 2012-2017 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.
+ */
+
+/**
+ * AssertJ support for ApplicationContexts.
+ */
+package org.springframework.boot.test.context.assertj;

spring-boot-test/src/main/java/org/springframework/boot/test/context/ApplicationContextTester.java → spring-boot-test/src/main/java/org/springframework/boot/test/context/runner/ApplicationContextRunner.java

@@ -14,43 +14,67 @@
  * limitations under the License.
  */
 
-package org.springframework.boot.test.context;
+package org.springframework.boot.test.context.runner;
 
+import java.util.List;
 import java.util.function.Supplier;
 
+import org.springframework.boot.context.annotation.Configurations;
+import org.springframework.boot.test.context.assertj.AssertableApplicationContext;
+import org.springframework.boot.test.util.TestPropertyValues;
+import org.springframework.context.ApplicationContext;
 import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
 /**
- * A {@link AbstractApplicationContextTester ApplicationContext tester} for a standard,
+ * A {@link AbstractApplicationContextRunner ApplicationContext runner} for a standard,
  * non-web environment {@link ConfigurableApplicationContext}.
  * <p>
- * See {@link AbstractApplicationContextTester} for details.
+ * See {@link AbstractApplicationContextRunner} for details.
  *
  * @author Stephane Nicoll
  * @author Andy Wilkinson
  * @author Phillip Webb
  * @since 2.0.0
  */
-public class ApplicationContextTester extends
-		AbstractApplicationContextTester<ApplicationContextTester, ConfigurableApplicationContext, AssertableApplicationContext> {
+public class ApplicationContextRunner extends
+		AbstractApplicationContextRunner<ApplicationContextRunner, ConfigurableApplicationContext, AssertableApplicationContext> {
 
 	/**
-	 * Create a new {@link ApplicationContextTester} instance using an
+	 * Create a new {@link ApplicationContextRunner} instance using an
 	 * {@link AnnotationConfigApplicationContext} as the underlying source.
 	 */
-	public ApplicationContextTester() {
+	public ApplicationContextRunner() {
 		this(AnnotationConfigApplicationContext::new);
 	}
 
 	/**
-	 * Create a new {@link ApplicationContextTester} instance using the specified
+	 * Create a new {@link ApplicationContextRunner} instance using the specified
 	 * {@code contextFactory} as the underlying source.
 	 * @param contextFactory a supplier that returns a new instance on each call
 	 */
-	public ApplicationContextTester(
+	public ApplicationContextRunner(
 			Supplier<ConfigurableApplicationContext> contextFactory) {
 		super(contextFactory);
 	}
 
+	private ApplicationContextRunner(
+			Supplier<ConfigurableApplicationContext> contextFactory,
+			TestPropertyValues environmentProperties, TestPropertyValues systemProperties,
+			ClassLoader classLoader, ApplicationContext parent,
+			List<Configurations> configurations) {
+		super(contextFactory, environmentProperties, systemProperties, classLoader,
+				parent, configurations);
+	}
+
+	@Override
+	protected ApplicationContextRunner newInstance(
+			Supplier<ConfigurableApplicationContext> contextFactory,
+			TestPropertyValues environmentProperties, TestPropertyValues systemProperties,
+			ClassLoader classLoader, ApplicationContext parent,
+			List<Configurations> configurations) {
+		return new ApplicationContextRunner(contextFactory, environmentProperties,
+				systemProperties, classLoader, parent, configurations);
+	}
+
 }

spring-boot-test/src/main/java/org/springframework/boot/test/context/ContextConsumer.java → spring-boot-test/src/main/java/org/springframework/boot/test/context/runner/ContextConsumer.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.boot.test.context;
+package org.springframework.boot.test.context.runner;
 
 import org.springframework.context.ApplicationContext;
 
@@ -26,7 +26,7 @@ import org.springframework.context.ApplicationContext;
  * @author Andy Wilkinson
  * @param <C> The application context type
  * @since 2.0.0
- * @see AbstractApplicationContextTester
+ * @see AbstractApplicationContextRunner
  */
 @FunctionalInterface
 public interface ContextConsumer<C extends ApplicationContext> {

spring-boot-test/src/main/java/org/springframework/boot/test/context/ReactiveWebApplicationContextTester.java → spring-boot-test/src/main/java/org/springframework/boot/test/context/runner/ReactiveWebApplicationContextRunner.java

@@ -14,43 +14,68 @@
  * limitations under the License.
  */
 
-package org.springframework.boot.test.context;
+package org.springframework.boot.test.context.runner;
 
+import java.util.List;
 import java.util.function.Supplier;
 
+import org.springframework.boot.context.annotation.Configurations;
+import org.springframework.boot.test.context.assertj.AssertableReactiveWebApplicationContext;
+import org.springframework.boot.test.util.TestPropertyValues;
 import org.springframework.boot.web.reactive.context.ConfigurableReactiveWebApplicationContext;
 import org.springframework.boot.web.reactive.context.GenericReactiveWebApplicationContext;
+import org.springframework.context.ApplicationContext;
 
 /**
- * A {@link AbstractApplicationContextTester ApplicationContext tester} for a
+ * A {@link AbstractApplicationContextRunner ApplicationContext runner} for a
  * {@link ConfigurableReactiveWebApplicationContext}.
  * <p>
- * See {@link AbstractApplicationContextTester} for details.
+ * See {@link AbstractApplicationContextRunner} for details.
  *
  * @author Andy Wilkinson
  * @author Stephane Nicoll
  * @author Phillip Webb
  * @since 2.0.0
  */
-public final class ReactiveWebApplicationContextTester extends
-		AbstractApplicationContextTester<ReactiveWebApplicationContextTester, ConfigurableReactiveWebApplicationContext, AssertableReactiveWebApplicationContext> {
+public final class ReactiveWebApplicationContextRunner extends
+		AbstractApplicationContextRunner<ReactiveWebApplicationContextRunner, ConfigurableReactiveWebApplicationContext, AssertableReactiveWebApplicationContext> {
 
 	/**
-	 * Create a new {@link ReactiveWebApplicationContextTester} instance using a
+	 * Create a new {@link ReactiveWebApplicationContextRunner} instance using a
 	 * {@link GenericReactiveWebApplicationContext} as the underlying source.
 	 */
-	public ReactiveWebApplicationContextTester() {
+	public ReactiveWebApplicationContextRunner() {
 		this(GenericReactiveWebApplicationContext::new);
 	}
 
 	/**
-	 * Create a new {@link ApplicationContextTester} instance using the specified
+	 * Create a new {@link ApplicationContextRunner} instance using the specified
 	 * {@code contextFactory} as the underlying source.
 	 * @param contextFactory a supplier that returns a new instance on each call
 	 */
-	public ReactiveWebApplicationContextTester(
+	public ReactiveWebApplicationContextRunner(
 			Supplier<ConfigurableReactiveWebApplicationContext> contextFactory) {
 		super(contextFactory);
 	}
 
+	private ReactiveWebApplicationContextRunner(
+			Supplier<ConfigurableReactiveWebApplicationContext> contextFactory,
+			TestPropertyValues environmentProperties, TestPropertyValues systemProperties,
+			ClassLoader classLoader, ApplicationContext parent,
+			List<Configurations> configurations) {
+		super(contextFactory, environmentProperties, systemProperties, classLoader,
+				parent, configurations);
+	}
+
+	@Override
+	protected ReactiveWebApplicationContextRunner newInstance(
+			Supplier<ConfigurableReactiveWebApplicationContext> contextFactory,
+			TestPropertyValues environmentProperties, TestPropertyValues systemProperties,
+			ClassLoader classLoader, ApplicationContext parent,
+			List<Configurations> configurations) {
+		return new ReactiveWebApplicationContextRunner(contextFactory,
+				environmentProperties, systemProperties, classLoader, parent,
+				configurations);
+	}
+
 }

spring-boot-test/src/main/java/org/springframework/boot/test/context/WebApplicationContextTester.java → spring-boot-test/src/main/java/org/springframework/boot/test/context/runner/WebApplicationContextRunner.java

@@ -14,49 +14,73 @@
  * limitations under the License.
  */
 
-package org.springframework.boot.test.context;
+package org.springframework.boot.test.context.runner;
 
+import java.util.List;
 import java.util.function.Supplier;
 
+import org.springframework.boot.context.annotation.Configurations;
+import org.springframework.boot.test.context.assertj.AssertableWebApplicationContext;
+import org.springframework.boot.test.util.TestPropertyValues;
+import org.springframework.context.ApplicationContext;
 import org.springframework.mock.web.MockServletContext;
 import org.springframework.web.context.ConfigurableWebApplicationContext;
 import org.springframework.web.context.WebApplicationContext;
 import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
 
 /**
- * A {@link AbstractApplicationContextTester ApplicationContext tester} for a Servlet
+ * A {@link AbstractApplicationContextRunner ApplicationContext runner} for a Servlet
  * based {@link ConfigurableWebApplicationContext}.
  * <p>
- * See {@link AbstractApplicationContextTester} for details.
+ * See {@link AbstractApplicationContextRunner} for details.
  *
  * @author Andy Wilkinson
  * @author Stephane Nicoll
  * @author Phillip Webb
  * @since 2.0.0
  */
-public final class WebApplicationContextTester extends
-		AbstractApplicationContextTester<WebApplicationContextTester, ConfigurableWebApplicationContext, AssertableWebApplicationContext> {
+public final class WebApplicationContextRunner extends
+		AbstractApplicationContextRunner<WebApplicationContextRunner, ConfigurableWebApplicationContext, AssertableWebApplicationContext> {
 
 	/**
-	 * Create a new {@link WebApplicationContextTester} instance using an
+	 * Create a new {@link WebApplicationContextRunner} instance using an
 	 * {@link AnnotationConfigWebApplicationContext} with a {@link MockServletContext} as
 	 * the underlying source.
 	 * @see #withMockServletContext(Supplier)
 	 */
-	public WebApplicationContextTester() {
+	public WebApplicationContextRunner() {
 		this(withMockServletContext(AnnotationConfigWebApplicationContext::new));
 	}
 
 	/**
-	 * Create a new {@link WebApplicationContextTester} instance using the specified
+	 * Create a new {@link WebApplicationContextRunner} instance using the specified
 	 * {@code contextFactory} as the underlying source.
 	 * @param contextFactory a supplier that returns a new instance on each call
 	 */
-	public WebApplicationContextTester(
+	public WebApplicationContextRunner(
 			Supplier<ConfigurableWebApplicationContext> contextFactory) {
 		super(contextFactory);
 	}
 
+	private WebApplicationContextRunner(
+			Supplier<ConfigurableWebApplicationContext> contextFactory,
+			TestPropertyValues environmentProperties, TestPropertyValues systemProperties,
+			ClassLoader classLoader, ApplicationContext parent,
+			List<Configurations> configurations) {
+		super(contextFactory, environmentProperties, systemProperties, classLoader,
+				parent, configurations);
+	}
+
+	@Override
+	protected WebApplicationContextRunner newInstance(
+			Supplier<ConfigurableWebApplicationContext> contextFactory,
+			TestPropertyValues environmentProperties, TestPropertyValues systemProperties,
+			ClassLoader classLoader, ApplicationContext parent,
+			List<Configurations> configurations) {
+		return new WebApplicationContextRunner(contextFactory, environmentProperties,
+				systemProperties, classLoader, parent, configurations);
+	}
+
 	/**
 	 * Decorate the specified {@code contextFactory} to set a {@link MockServletContext}
 	 * on each newly created {@link WebApplicationContext}.

spring-boot-test/src/main/java/org/springframework/boot/test/context/runner/package-info.java

+/*
+ * Copyright 2012-2017 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.
+ */
+
+/**
+ * Test utilities to run application contexts for testing.
+ */
+package org.springframework.boot.test.context.runner;

spring-boot-test/src/main/java/org/springframework/boot/test/util/TestPropertyValues.java

@@ -17,9 +17,13 @@
 package org.springframework.boot.test.util;
 
 import java.io.Closeable;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.Objects;
 import java.util.concurrent.Callable;
+import java.util.stream.Stream;
 
 import com.google.common.collect.Streams;
 
@@ -45,56 +49,28 @@ import org.springframework.util.StringUtils;
  */
 public final class TestPropertyValues {
 
-	private final Map<String, Object> properties = new LinkedHashMap<>();
+	private static final TestPropertyValues EMPTY = new TestPropertyValues(
+			Collections.emptyMap());
 
-	private TestPropertyValues(String[] pairs) {
-		addProperties(pairs);
-	}
+	private final Map<String, Object> properties;
 
-	private void addProperties(String[] pairs) {
-		for (String pair : pairs) {
-			and(pair);
-		}
+	private TestPropertyValues(Map<String, Object> properties) {
+		this.properties = Collections.unmodifiableMap(properties);
 	}
 
 	/**
-	 * Builder method to append another property pair the underlying map of properties.
-	 * @param pair The property pair to add
-	 * @return the existing instance of {@link TestPropertyValues}
+	 * Builder method to add more properties.
+	 * @param pairs The property pairs to add
+	 * @return a new {@link TestPropertyValues} instance
 	 */
-	public TestPropertyValues and(String pair) {
-		int index = getSeparatorIndex(pair);
-		String key = pair.substring(0, index > 0 ? index : pair.length());
-		String value = index > 0 ? pair.substring(index + 1) : "";
-		and(key.trim(), value.trim());
-		return this;
+	public TestPropertyValues and(String... pairs) {
+		return and(Arrays.stream(pairs).map(Pair::parse));
 	}
 
-	private int getSeparatorIndex(String pair) {
-		int colonIndex = pair.indexOf(":");
-		int equalIndex = pair.indexOf("=");
-		if (colonIndex == -1) {
-			return equalIndex;
-		}
-		if (equalIndex == -1) {
-			return colonIndex;
-		}
-		return Math.min(colonIndex, equalIndex);
-	}
-
-	/**
-	 * Builder method to append another property to the underlying map of properties.
-	 * @param name The property name
-	 * @param value The property value
-	 * @return the existing instance of {@link TestPropertyValues}
-	 */
-	public TestPropertyValues and(String name, String value) {
-		if (StringUtils.isEmpty(name) && StringUtils.isEmpty(value)) {
-			return this;
-		}
-		Assert.hasLength(name, "Name must not be empty");
-		this.properties.put(name, value);
-		return this;
+	private TestPropertyValues and(Stream<Pair> pairs) {
+		Map<String, Object> properties = new LinkedHashMap<>(this.properties);
+		pairs.filter(Objects::nonNull).forEach((pair) -> pair.addTo(properties));
+		return new TestPropertyValues(properties);
 	}
 
 	/**
@@ -170,30 +146,21 @@ public final class TestPropertyValues {
 				return;
 			}
 		}
-		MapPropertySource source = (type.equals(Type.MAP)
-				? new MapPropertySource(name, this.properties)
-				: new SystemEnvironmentPropertySource(name, this.properties));
-		sources.addFirst(source);
-	}
-
-	/**
-	 * Return a new empty {@link TestPropertyValues} instance.
-	 * @return an empty instance
-	 */
-	public static TestPropertyValues empty() {
-		return of();
+		Map<String, Object> source = new LinkedHashMap<>(this.properties);
+		sources.addFirst((type.equals(Type.MAP) ? new MapPropertySource(name, source)
+				: new SystemEnvironmentPropertySource(name, source)));
 	}
 
 	/**
 	 * Return a new {@link TestPropertyValues} with the underlying map populated with the
-	 * given property pair.
-	 * @param name the property name
-	 * @param value the property value
+	 * given property pairs. Name-value pairs can be specified with colon (":") or equals
+	 * ("=") separators.
+	 * @param pairs The key value pairs for properties that need to be added to the
+	 * environment
 	 * @return the new instance
 	 */
-
-	public static TestPropertyValues ofPair(String name, String value) {
-		return of().and(name, value);
+	public static TestPropertyValues of(String... pairs) {
+		return of(Stream.of(pairs));
 	}
 
 	/**
@@ -206,9 +173,9 @@ public final class TestPropertyValues {
 	 */
 	public static TestPropertyValues of(Iterable<String> pairs) {
 		if (pairs == null) {
-			return of();
+			return empty();
 		}
-		return of(Streams.stream(pairs).toArray(String[]::new));
+		return of(Streams.stream(pairs));
 	}
 
 	/**
@@ -219,8 +186,19 @@ public final class TestPropertyValues {
 	 * environment
 	 * @return the new instance
 	 */
-	public static TestPropertyValues of(String... pairs) {
-		return new TestPropertyValues(pairs);
+	public static TestPropertyValues of(Stream<String> pairs) {
+		if (pairs == null) {
+			return empty();
+		}
+		return empty().and(pairs.map(Pair::parse));
+	}
+
+	/**
+	 * Return a new empty {@link TestPropertyValues} instance.
+	 * @return an empty instance
+	 */
+	public static TestPropertyValues empty() {
+		return EMPTY;
 	}
 
 	/**
@@ -250,6 +228,53 @@ public final class TestPropertyValues {
 
 	}
 
+	/**
+	 * A single name value pair.
+	 */
+	public static class Pair {
+
+		private String name;
+
+		private String value;
+
+		public Pair(String name, String value) {
+			Assert.hasLength(name, "Name must not be empty");
+			this.name = name;
+			this.value = value;
+		}
+
+		public void addTo(Map<String, Object> properties) {
+			properties.put(this.name, this.value);
+		}
+
+		public static Pair parse(String pair) {
+			int index = getSeparatorIndex(pair);
+			String key = pair.substring(0, index > 0 ? index : pair.length());
+			String value = index > 0 ? pair.substring(index + 1) : "";
+			return of(key.trim(), value.trim());
+		}
+
+		private static int getSeparatorIndex(String pair) {
+			int colonIndex = pair.indexOf(":");
+			int equalIndex = pair.indexOf("=");
+			if (colonIndex == -1) {
+				return equalIndex;
+			}
+			if (equalIndex == -1) {
+				return colonIndex;
+			}
+			return Math.min(colonIndex, equalIndex);
+		}
+
+		private static Pair of(String name, String value) {
+			if (StringUtils.isEmpty(name) && StringUtils.isEmpty(value)) {
+				return null;
+			}
+			return new Pair(name, value);
+		}
+
+	}
+
 	/**
 	 * Handler to apply and restore system properties.
 	 */
@@ -278,7 +303,7 @@ public final class TestPropertyValues {
 
 		private String setOrClear(String name, String value) {
 			Assert.notNull(name, "Name must not be null");
-			if (value == null) {
+			if (StringUtils.isEmpty(value)) {
 				return (String) System.getProperties().remove(name);
 			}
 			return (String) System.getProperties().setProperty(name, value);

spring-boot-test/src/test/java/org/springframework/boot/test/context/AssertProviderApplicationContextTests.java → spring-boot-test/src/test/java/org/springframework/boot/test/context/assertj/ApplicationContextAssertProviderTests.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.boot.test.context;
+package org.springframework.boot.test.context.assertj;
 
 import java.util.function.Supplier;
 
@@ -34,12 +34,12 @@ import static org.hamcrest.Matchers.equalTo;
 import static org.mockito.Mockito.verify;
 
 /**
- * Tests for {@link AssertProviderApplicationContext} and
+ * Tests for {@link ApplicationContextAssertProvider} and
  * {@link AssertProviderApplicationContextInvocationHandler}.
  *
  * @author Phillip Webb
  */
-public class AssertProviderApplicationContextTests {
+public class ApplicationContextAssertProviderTests {
 
 	@Rule
 	public ExpectedException thrown = ExpectedException.none();
@@ -67,7 +67,7 @@ public class AssertProviderApplicationContextTests {
 	public void getWhenTypeIsNullShouldThrowException() throws Exception {
 		this.thrown.expect(IllegalArgumentException.class);
 		this.thrown.expectMessage("Type must not be null");
-		AssertProviderApplicationContext.get(null, ApplicationContext.class,
+		ApplicationContextAssertProvider.get(null, ApplicationContext.class,
 				this.mockContextSupplier);
 	}
 
@@ -75,7 +75,7 @@ public class AssertProviderApplicationContextTests {
 	public void getWhenTypeIsClassShouldThrowException() throws Exception {
 		this.thrown.expect(IllegalArgumentException.class);
 		this.thrown.expectMessage("Type must not be null");
-		AssertProviderApplicationContext.get(null, ApplicationContext.class,
+		ApplicationContextAssertProvider.get(null, ApplicationContext.class,
 				this.mockContextSupplier);
 	}
 
@@ -83,7 +83,7 @@ public class AssertProviderApplicationContextTests {
 	public void getWhenContextTypeIsNullShouldThrowException() throws Exception {
 		this.thrown.expect(IllegalArgumentException.class);
 		this.thrown.expectMessage("Type must be an interface");
-		AssertProviderApplicationContext.get(
+		ApplicationContextAssertProvider.get(
 				TestAssertProviderApplicationContextClass.class, ApplicationContext.class,
 				this.mockContextSupplier);
 	}
@@ -92,7 +92,7 @@ public class AssertProviderApplicationContextTests {
 	public void getWhenContextTypeIsClassShouldThrowException() throws Exception {
 		this.thrown.expect(IllegalArgumentException.class);
 		this.thrown.expectMessage("ContextType must not be null");
-		AssertProviderApplicationContext.get(TestAssertProviderApplicationContext.class,
+		ApplicationContextAssertProvider.get(TestAssertProviderApplicationContext.class,
 				null, this.mockContextSupplier);
 	}
 
@@ -100,14 +100,14 @@ public class AssertProviderApplicationContextTests {
 	public void getWhenSupplierIsNullShouldThrowException() throws Exception {
 		this.thrown.expect(IllegalArgumentException.class);
 		this.thrown.expectMessage("ContextType must be an interface");
-		AssertProviderApplicationContext.get(TestAssertProviderApplicationContext.class,
+		ApplicationContextAssertProvider.get(TestAssertProviderApplicationContext.class,
 				StaticApplicationContext.class, this.mockContextSupplier);
 	}
 
 	@Test
 	public void getWhenContextStartsShouldReturnProxyThatCallsRealMethods()
 			throws Exception {
-		AssertProviderApplicationContext<ApplicationContext> context = get(
+		ApplicationContextAssertProvider<ApplicationContext> context = get(
 				this.mockContextSupplier);
 		assertThat((Object) context).isNotNull();
 		context.getBean("foo");
@@ -117,7 +117,7 @@ public class AssertProviderApplicationContextTests {
 	@Test
 	public void getWhenContextFailsShouldReturnProxyThatThrowsExceptions()
 			throws Exception {
-		AssertProviderApplicationContext<ApplicationContext> context = get(
+		ApplicationContextAssertProvider<ApplicationContext> context = get(
 				this.startupFailureSupplier);
 		assertThat((Object) context).isNotNull();
 		expectStartupFailure();
@@ -127,14 +127,14 @@ public class AssertProviderApplicationContextTests {
 	@Test
 	public void getSourceContextWhenContextStartsShouldReturnSourceContext()
 			throws Exception {
-		AssertProviderApplicationContext<ApplicationContext> context = get(
+		ApplicationContextAssertProvider<ApplicationContext> context = get(
 				this.mockContextSupplier);
 		assertThat(context.getSourceApplicationContext()).isSameAs(this.mockContext);
 	}
 
 	@Test
 	public void getSourceContextWhenContextFailsShouldThrowException() throws Exception {
-		AssertProviderApplicationContext<ApplicationContext> context = get(
+		ApplicationContextAssertProvider<ApplicationContext> context = get(
 				this.startupFailureSupplier);
 		expectStartupFailure();
 		context.getSourceApplicationContext();
@@ -143,7 +143,7 @@ public class AssertProviderApplicationContextTests {
 	@Test
 	public void getSourceContextOfTypeWhenContextStartsShouldReturnSourceContext()
 			throws Exception {
-		AssertProviderApplicationContext<ApplicationContext> context = get(
+		ApplicationContextAssertProvider<ApplicationContext> context = get(
 				this.mockContextSupplier);
 		assertThat(context.getSourceApplicationContext(ApplicationContext.class))
 				.isSameAs(this.mockContext);
@@ -152,7 +152,7 @@ public class AssertProviderApplicationContextTests {
 	@Test
 	public void getSourceContextOfTypeWhenContextFailsToStartShouldThrowException()
 			throws Exception {
-		AssertProviderApplicationContext<ApplicationContext> context = get(
+		ApplicationContextAssertProvider<ApplicationContext> context = get(
 				this.startupFailureSupplier);
 		expectStartupFailure();
 		context.getSourceApplicationContext(ApplicationContext.class);
@@ -160,7 +160,7 @@ public class AssertProviderApplicationContextTests {
 
 	@Test
 	public void getStartupFailureWhenContextStartsShouldReturnNull() throws Exception {
-		AssertProviderApplicationContext<ApplicationContext> context = get(
+		ApplicationContextAssertProvider<ApplicationContext> context = get(
 				this.mockContextSupplier);
 		assertThat(context.getStartupFailure()).isNull();
 	}
@@ -168,14 +168,14 @@ public class AssertProviderApplicationContextTests {
 	@Test
 	public void getStartupFailureWhenContextFailsToStartShouldReturnException()
 			throws Exception {
-		AssertProviderApplicationContext<ApplicationContext> context = get(
+		ApplicationContextAssertProvider<ApplicationContext> context = get(
 				this.startupFailureSupplier);
 		assertThat(context.getStartupFailure()).isEqualTo(this.startupFailure);
 	}
 
 	@Test
 	public void assertThatWhenContextStartsShouldReturnAssertions() throws Exception {
-		AssertProviderApplicationContext<ApplicationContext> context = get(
+		ApplicationContextAssertProvider<ApplicationContext> context = get(
 				this.mockContextSupplier);
 		ApplicationContextAssert<ApplicationContext> contextAssert = assertThat(context);
 		assertThat(contextAssert.getApplicationContext()).isSameAs(context);
@@ -184,7 +184,7 @@ public class AssertProviderApplicationContextTests {
 
 	@Test
 	public void assertThatWhenContextFailsShouldReturnAssertions() throws Exception {
-		AssertProviderApplicationContext<ApplicationContext> context = get(
+		ApplicationContextAssertProvider<ApplicationContext> context = get(
 				this.startupFailureSupplier);
 		ApplicationContextAssert<ApplicationContext> contextAssert = assertThat(context);
 		assertThat(contextAssert.getApplicationContext()).isSameAs(context);
@@ -193,7 +193,7 @@ public class AssertProviderApplicationContextTests {
 
 	@Test
 	public void toStringWhenContextStartsShouldReturnSimpleString() throws Exception {
-		AssertProviderApplicationContext<ApplicationContext> context = get(
+		ApplicationContextAssertProvider<ApplicationContext> context = get(
 				this.mockContextSupplier);
 		assertThat(context.toString())
 				.startsWith(
@@ -204,7 +204,7 @@ public class AssertProviderApplicationContextTests {
 	@Test
 	public void toStringWhenContextFailsToStartShouldReturnSimpleString()
 			throws Exception {
-		AssertProviderApplicationContext<ApplicationContext> context = get(
+		ApplicationContextAssertProvider<ApplicationContext> context = get(
 				this.startupFailureSupplier);
 		assertThat(context.toString()).isEqualTo("Unstarted application context "
 				+ "org.springframework.context.ApplicationContext"
@@ -213,7 +213,7 @@ public class AssertProviderApplicationContextTests {
 
 	@Test
 	public void closeShouldCloseContext() throws Exception {
-		AssertProviderApplicationContext<ApplicationContext> context = get(
+		ApplicationContextAssertProvider<ApplicationContext> context = get(
 				this.mockContextSupplier);
 		context.close();
 		verify(this.mockContext).close();
@@ -225,15 +225,15 @@ public class AssertProviderApplicationContextTests {
 		this.thrown.expectCause(equalTo(this.startupFailure));
 	}
 
-	private AssertProviderApplicationContext<ApplicationContext> get(
+	private ApplicationContextAssertProvider<ApplicationContext> get(
 			Supplier<ApplicationContext> contextSupplier) {
-		return AssertProviderApplicationContext.get(
+		return ApplicationContextAssertProvider.get(
 				TestAssertProviderApplicationContext.class, ApplicationContext.class,
 				contextSupplier);
 	}
 
 	private interface TestAssertProviderApplicationContext
-			extends AssertProviderApplicationContext<ApplicationContext> {
+			extends ApplicationContextAssertProvider<ApplicationContext> {
 
 	}
 

spring-boot-test/src/test/java/org/springframework/boot/test/context/ApplicationContextAssertTests.java → spring-boot-test/src/test/java/org/springframework/boot/test/context/assertj/ApplicationContextAssertTests.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.boot.test.context;
+package org.springframework.boot.test.context.assertj;
 
 import org.junit.Rule;
 import org.junit.Test;

spring-boot-test/src/test/java/org/springframework/boot/test/context/AssertableApplicationContextTests.java → spring-boot-test/src/test/java/org/springframework/boot/test/context/assertj/AssertableApplicationContextTests.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.boot.test.context;
+package org.springframework.boot.test.context.assertj;
 
 import org.junit.Test;
 
@@ -27,7 +27,7 @@ import static org.mockito.Mockito.mock;
  * Tests for {@link AssertableApplicationContext}.
  *
  * @author Phillip Webb
- * @see AssertProviderApplicationContextTests
+ * @see ApplicationContextAssertProviderTests
  */
 public class AssertableApplicationContextTests {
 

spring-boot-test/src/test/java/org/springframework/boot/test/context/AssertableReactiveWebApplicationContextTests.java → spring-boot-test/src/test/java/org/springframework/boot/test/context/assertj/AssertableReactiveWebApplicationContextTests.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.boot.test.context;
+package org.springframework.boot.test.context.assertj;
 
 import org.junit.Test;
 
@@ -27,7 +27,7 @@ import static org.mockito.Mockito.mock;
  * Tests for {@link AssertableReactiveWebApplicationContext}.
  *
  * @author Phillip Webb
- * @see AssertProviderApplicationContextTests
+ * @see ApplicationContextAssertProviderTests
  */
 public class AssertableReactiveWebApplicationContextTests {
 

spring-boot-test/src/test/java/org/springframework/boot/test/context/AssertableWebApplicationContextTests.java → spring-boot-test/src/test/java/org/springframework/boot/test/context/assertj/AssertableWebApplicationContextTests.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.boot.test.context;
+package org.springframework.boot.test.context.assertj;
 
 import org.junit.Test;
 
@@ -27,7 +27,7 @@ import static org.mockito.Mockito.mock;
  * Tests for {@link AssertableWebApplicationContext}.
  *
  * @author Phillip Webb
- * @see AssertProviderApplicationContextTests
+ * @see ApplicationContextAssertProviderTests
  */
 public class AssertableWebApplicationContextTests {
 

spring-boot-test/src/test/java/org/springframework/boot/test/context/AbstractApplicationContextTesterTests.java → spring-boot-test/src/test/java/org/springframework/boot/test/context/runner/AbstractApplicationContextRunnerTests.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.boot.test.context;
+package org.springframework.boot.test.context.runner;
 
 import java.util.UUID;
 
@@ -24,6 +24,8 @@ import org.junit.Test;
 import org.junit.rules.ExpectedException;
 
 import org.springframework.boot.context.annotation.UserConfigurations;
+import org.springframework.boot.test.context.HidePackagesClassLoader;
+import org.springframework.boot.test.context.assertj.ApplicationContextAssertProvider;
 import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -34,18 +36,18 @@ import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.fail;
 
 /**
- * Abstract tests for {@link AbstractApplicationContextTester} implementations.
+ * Abstract tests for {@link AbstractApplicationContextRunner} implementations.
  *
- * @param <T> The tester type
+ * @param <T> The runner type
  * @param <C> the context type
  * @param <A> the assertable context type
  * @author Stephane Nicoll
  * @author Phillip Webb
  */
-public abstract class AbstractApplicationContextTesterTests<T extends AbstractApplicationContextTester<T, C, A>, C extends ConfigurableApplicationContext, A extends AssertProviderApplicationContext<C>> {
+public abstract class AbstractApplicationContextRunnerTests<T extends AbstractApplicationContextRunner<T, C, A>, C extends ConfigurableApplicationContext, A extends ApplicationContextAssertProvider<C>> {
 
 	@Rule
-	public final ExpectedException thrown = ExpectedException.none();
+	public ExpectedException thrown = ExpectedException.none();
 
 	@Test
 	public void runWithSystemPropertiesShouldSetAndRemoveProperties() {
@@ -93,7 +95,7 @@ public abstract class AbstractApplicationContextTesterTests<T extends AbstractAp
 		System.setProperty(key, "value");
 		try {
 			assertThat(System.getProperties().getProperty(key)).isEqualTo("value");
-			get().withSystemProperty(key, null).run((loaded) -> {
+			get().withSystemProperties(key + "=").run((loaded) -> {
 				assertThat(System.getProperties()).doesNotContainKey(key);
 			});
 			assertThat(System.getProperties().getProperty(key)).isEqualTo("value");

spring-boot-test/src/test/java/org/springframework/boot/test/context/ApplicationContextTesterTests.java → spring-boot-test/src/test/java/org/springframework/boot/test/context/runner/ApplicationContextRunnerTests.java

@@ -14,22 +14,23 @@
  * limitations under the License.
  */
 
-package org.springframework.boot.test.context;
+package org.springframework.boot.test.context.runner;
 
+import org.springframework.boot.test.context.assertj.AssertableApplicationContext;
 import org.springframework.context.ConfigurableApplicationContext;
 
 /**
- * Tests for {@link ApplicationContextTester}.
+ * Tests for {@link ApplicationContextRunner}.
  *
  * @author Stephane Nicoll
  * @author Phillip Webb
  */
-public class ApplicationContextTesterTests extends
-		AbstractApplicationContextTesterTests<ApplicationContextTester, ConfigurableApplicationContext, AssertableApplicationContext> {
+public class ApplicationContextRunnerTests extends
+		AbstractApplicationContextRunnerTests<ApplicationContextRunner, ConfigurableApplicationContext, AssertableApplicationContext> {
 
 	@Override
-	protected ApplicationContextTester get() {
-		return new ApplicationContextTester();
+	protected ApplicationContextRunner get() {
+		return new ApplicationContextRunner();
 	}
 
 }

spring-boot-test/src/test/java/org/springframework/boot/test/context/ReactiveWebApplicationContextTesterTests.java → spring-boot-test/src/test/java/org/springframework/boot/test/context/runner/ReactiveWebApplicationContextRunnerTests.java

@@ -14,22 +14,23 @@
  * limitations under the License.
  */
 
-package org.springframework.boot.test.context;
+package org.springframework.boot.test.context.runner;
 
+import org.springframework.boot.test.context.assertj.AssertableReactiveWebApplicationContext;
 import org.springframework.boot.web.reactive.context.ConfigurableReactiveWebApplicationContext;
 
 /**
- * Tests for {@link ReactiveWebApplicationContextTester}.
+ * Tests for {@link ReactiveWebApplicationContextRunner}.
  *
  * @author Stephane Nicoll
  * @author Phillip Webb
  */
-public class ReactiveWebApplicationContextTesterTests extends
-		AbstractApplicationContextTesterTests<ReactiveWebApplicationContextTester, ConfigurableReactiveWebApplicationContext, AssertableReactiveWebApplicationContext> {
+public class ReactiveWebApplicationContextRunnerTests extends
+		AbstractApplicationContextRunnerTests<ReactiveWebApplicationContextRunner, ConfigurableReactiveWebApplicationContext, AssertableReactiveWebApplicationContext> {
 
 	@Override
-	protected ReactiveWebApplicationContextTester get() {
-		return new ReactiveWebApplicationContextTester();
+	protected ReactiveWebApplicationContextRunner get() {
+		return new ReactiveWebApplicationContextRunner();
 	}
 
 }

spring-boot-test/src/test/java/org/springframework/boot/test/context/WebApplicationContextTesterTests.java → spring-boot-test/src/test/java/org/springframework/boot/test/context/runner/WebApplicationContextRunnerTests.java

@@ -14,23 +14,24 @@
  * limitations under the License.
  */
 
-package org.springframework.boot.test.context;
+package org.springframework.boot.test.context.runner;
 
 import org.junit.Test;
 
+import org.springframework.boot.test.context.assertj.AssertableWebApplicationContext;
 import org.springframework.mock.web.MockServletContext;
 import org.springframework.web.context.ConfigurableWebApplicationContext;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 /**
- * Tests for {@link WebApplicationContextTester}.
+ * Tests for {@link WebApplicationContextRunner}.
  *
  * @author Stephane Nicoll
  * @author Phillip Webb
  */
-public class WebApplicationContextTesterTests extends
-		AbstractApplicationContextTesterTests<WebApplicationContextTester, ConfigurableWebApplicationContext, AssertableWebApplicationContext> {
+public class WebApplicationContextRunnerTests extends
+		AbstractApplicationContextRunnerTests<WebApplicationContextRunner, ConfigurableWebApplicationContext, AssertableWebApplicationContext> {
 
 	@Test
 	public void contextShouldHaveMockServletContext() throws Exception {
@@ -39,8 +40,8 @@ public class WebApplicationContextTesterTests extends
 	}
 
 	@Override
-	protected WebApplicationContextTester get() {
-		return new WebApplicationContextTester();
+	protected WebApplicationContextRunner get() {
+		return new WebApplicationContextRunner();
 	}
 
 }

spring-boot-test/src/test/java/org/springframework/boot/test/util/TestPropertyValuesTests.java

@@ -89,8 +89,8 @@ public class TestPropertyValuesTests {
 
 	@Test
 	public void andShouldChainAndAddSingleKeyValue() throws Exception {
-		TestPropertyValues.of("foo.bar=baz").and("hello.world", "hi")
-				.and("bling.blah", "bing").applyTo(this.environment, Type.MAP);
+		TestPropertyValues.of("foo.bar=baz").and("hello.world=hi").and("bling.blah=bing")
+				.applyTo(this.environment, Type.MAP);
 		assertThat(this.environment.getProperty("foo.bar")).isEqualTo("baz");
 		assertThat(this.environment.getProperty("hello.world")).isEqualTo("hi");
 		assertThat(this.environment.getProperty("bling.blah")).isEqualTo("bing");
@@ -127,7 +127,7 @@ public class TestPropertyValuesTests {
 			throws Exception {
 		System.setProperty("foo", "bar1");
 		try {
-			TestPropertyValues.ofPair("foo", null).applyToSystemProperties(() -> {
+			TestPropertyValues.of("foo").applyToSystemProperties(() -> {
 				assertThat(System.getProperties()).doesNotContainKey("foo");
 				return null;
 			});