Polish

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/admin/SpringApplicationAdminJmxAutoConfigurationTests.java

@@ -59,7 +59,7 @@ public class SpringApplicationAdminJmxAutoConfigurationTests {
 	@Rule
 	public final ExpectedException thrown = ExpectedException.none();
 
-	private final MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
+	private final MBeanServer server = ManagementFactory.getPlatformMBeanServer();
 
 	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
 			.withConfiguration(AutoConfigurations.of(JmxAutoConfiguration.class,
@@ -70,7 +70,7 @@ public class SpringApplicationAdminJmxAutoConfigurationTests {
 			throws MalformedObjectNameException, InstanceNotFoundException {
 		this.contextRunner.run((context) -> {
 			this.thrown.expect(InstanceNotFoundException.class);
-			this.mBeanServer.getObjectInstance(createDefaultObjectName());
+			this.server.getObjectInstance(createDefaultObjectName());
 		});
 	}
 
@@ -78,7 +78,7 @@ public class SpringApplicationAdminJmxAutoConfigurationTests {
 	public void registeredWithProperty() throws Exception {
 		this.contextRunner.withPropertyValues(ENABLE_ADMIN_PROP).run((context) -> {
 			ObjectName objectName = createDefaultObjectName();
-			ObjectInstance objectInstance = this.mBeanServer.getObjectInstance(objectName);
+			ObjectInstance objectInstance = this.server.getObjectInstance(objectName);
 			assertThat(objectInstance).as("Lifecycle bean should have been registered")
 					.isNotNull();
 		});
@@ -87,17 +87,19 @@ public class SpringApplicationAdminJmxAutoConfigurationTests {
 	@Test
 	public void registerWithCustomJmxName() throws InstanceNotFoundException {
 		String customJmxName = "org.acme:name=FooBar";
-		this.contextRunner.withSystemProperties(
+		this.contextRunner
+				.withSystemProperties(
 						"spring.application.admin.jmx-name=" + customJmxName)
 				.withPropertyValues(ENABLE_ADMIN_PROP).run((context) -> {
 					try {
-				this.mBeanServer.getObjectInstance(createObjectName(customJmxName));
+						this.server.getObjectInstance(createObjectName(customJmxName));
 					}
 					catch (InstanceNotFoundException ex) {
 						fail("Admin MBean should have been exposed with custom name");
 					}
-			this.thrown.expect(InstanceNotFoundException.class); // Should not be exposed
-			this.mBeanServer.getObjectInstance(createDefaultObjectName());
+					this.thrown.expect(InstanceNotFoundException.class); // Should not be
+																			// exposed
+					this.server.getObjectInstance(createDefaultObjectName());
 				});
 	}
 
@@ -110,7 +112,7 @@ public class SpringApplicationAdminJmxAutoConfigurationTests {
 						SpringApplicationAdminJmxAutoConfiguration.class)
 				.run("--" + ENABLE_ADMIN_PROP, "--server.port=0")) {
 			assertThat(context).isInstanceOf(ServletWebServerApplicationContext.class);
-			assertThat(this.mBeanServer.getAttribute(createDefaultObjectName(),
+			assertThat(this.server.getAttribute(createDefaultObjectName(),
 					"EmbeddedWebApplication")).isEqualTo(Boolean.TRUE);
 			int expected = ((ServletWebServerApplicationContext) context).getWebServer()
 					.getPort();
@@ -128,7 +130,6 @@ public class SpringApplicationAdminJmxAutoConfigurationTests {
 				.child(JmxAutoConfiguration.class,
 						SpringApplicationAdminJmxAutoConfiguration.class)
 				.web(WebApplicationType.NONE);
-
 		try (ConfigurableApplicationContext parent = parentBuilder
 				.run("--" + ENABLE_ADMIN_PROP);
 				ConfigurableApplicationContext child = childBuilder
@@ -155,7 +156,7 @@ public class SpringApplicationAdminJmxAutoConfigurationTests {
 	}
 
 	private String getProperty(ObjectName objectName, String key) throws Exception {
-		return (String) this.mBeanServer.invoke(objectName, "getProperty",
+		return (String) this.server.invoke(objectName, "getProperty",
 				new Object[] { key }, new String[] { String.class.getName() });
 	}
 

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/amqp/RabbitAutoConfigurationTests.java

@@ -77,8 +77,8 @@ public class RabbitAutoConfigurationTests {
 
 	@Test
 	public void testDefaultRabbitConfiguration() {
-		this.contextRunner
-				.withUserConfiguration(TestConfiguration.class).run((context) -> {
+		this.contextRunner.withUserConfiguration(TestConfiguration.class)
+				.run((context) -> {
 					RabbitTemplate rabbitTemplate = context.getBean(RabbitTemplate.class);
 					RabbitMessagingTemplate messagingTemplate = context
 							.getBean(RabbitMessagingTemplate.class);
@@ -86,15 +86,19 @@ public class RabbitAutoConfigurationTests {
 							.getBean(CachingConnectionFactory.class);
 					DirectFieldAccessor dfa = new DirectFieldAccessor(connectionFactory);
 					RabbitAdmin amqpAdmin = context.getBean(RabbitAdmin.class);
-			assertThat(rabbitTemplate.getConnectionFactory()).isEqualTo(connectionFactory);
+					assertThat(rabbitTemplate.getConnectionFactory())
+							.isEqualTo(connectionFactory);
 					assertThat(getMandatory(rabbitTemplate)).isFalse();
-			assertThat(messagingTemplate.getRabbitTemplate()).isEqualTo(rabbitTemplate);
+					assertThat(messagingTemplate.getRabbitTemplate())
+							.isEqualTo(rabbitTemplate);
 					assertThat(amqpAdmin).isNotNull();
 					assertThat(connectionFactory.getHost()).isEqualTo("localhost");
-			assertThat(dfa.getPropertyValue("publisherConfirms")).isEqualTo(false);
+					assertThat(dfa.getPropertyValue("publisherConfirms"))
+							.isEqualTo(false);
 					assertThat(dfa.getPropertyValue("publisherReturns")).isEqualTo(false);
 					assertThat(context.containsBean("rabbitListenerContainerFactory"))
-					.as("Listener container factory should be created by default").isTrue();
+							.as("Listener container factory should be created by default")
+							.isTrue();
 				});
 	}
 
@@ -105,7 +109,8 @@ public class RabbitAutoConfigurationTests {
 						"spring.rabbitmq.port:9000", "spring.rabbitmq.username:alice",
 						"spring.rabbitmq.password:secret",
 						"spring.rabbitmq.virtual_host:/vhost",
-						"spring.rabbitmq.connection-timeout:123").run((context) -> {
+						"spring.rabbitmq.connection-timeout:123")
+				.run((context) -> {
 					CachingConnectionFactory connectionFactory = context
 							.getBean(CachingConnectionFactory.class);
 					assertThat(connectionFactory.getHost()).isEqualTo("remote-server");
@@ -164,7 +169,8 @@ public class RabbitAutoConfigurationTests {
 	public void testConnectionFactoryPublisherSettings() {
 		this.contextRunner.withUserConfiguration(TestConfiguration.class)
 				.withPropertyValues("spring.rabbitmq.publisher-confirms=true",
-						"spring.rabbitmq.publisher-returns=true").run(context -> {
+						"spring.rabbitmq.publisher-returns=true")
+				.run(context -> {
 					CachingConnectionFactory connectionFactory = context
 							.getBean(CachingConnectionFactory.class);
 					RabbitTemplate rabbitTemplate = context.getBean(RabbitTemplate.class);
@@ -177,8 +183,8 @@ public class RabbitAutoConfigurationTests {
 
 	@Test
 	public void testRabbitTemplateMessageConverters() {
-		this.contextRunner.withUserConfiguration(
-				MessageConvertersConfiguration.class).run((context) -> {
+		this.contextRunner.withUserConfiguration(MessageConvertersConfiguration.class)
+				.run((context) -> {
 					RabbitTemplate rabbitTemplate = context.getBean(RabbitTemplate.class);
 					assertThat(rabbitTemplate.getMessageConverter())
 							.isSameAs(context.getBean("myMessageConverter"));
@@ -196,8 +202,8 @@ public class RabbitAutoConfigurationTests {
 						"spring.rabbitmq.template.retry.multiplier:1.5",
 						"spring.rabbitmq.template.retry.maxInterval:5000",
 						"spring.rabbitmq.template.receiveTimeout:123",
-						"spring.rabbitmq.template.replyTimeout:456"
-				).run((context) -> {
+						"spring.rabbitmq.template.replyTimeout:456")
+				.run((context) -> {
 					RabbitTemplate rabbitTemplate = context.getBean(RabbitTemplate.class);
 					DirectFieldAccessor dfa = new DirectFieldAccessor(rabbitTemplate);
 					assertThat(dfa.getPropertyValue("receiveTimeout")).isEqualTo(123L);
@@ -240,12 +246,13 @@ public class RabbitAutoConfigurationTests {
 
 	@Test
 	public void testConnectionFactoryBackOff() {
-		this.contextRunner.withUserConfiguration(
-				TestConfiguration2.class).run((context) -> {
+		this.contextRunner.withUserConfiguration(TestConfiguration2.class)
+				.run((context) -> {
 					RabbitTemplate rabbitTemplate = context.getBean(RabbitTemplate.class);
 					CachingConnectionFactory connectionFactory = context
 							.getBean(CachingConnectionFactory.class);
-			assertThat(connectionFactory).isEqualTo(rabbitTemplate.getConnectionFactory());
+					assertThat(connectionFactory)
+							.isEqualTo(rabbitTemplate.getConnectionFactory());
 					assertThat(connectionFactory.getHost()).isEqualTo("otherserver");
 					assertThat(connectionFactory.getPort()).isEqualTo(8001);
 				});
@@ -257,14 +264,17 @@ public class RabbitAutoConfigurationTests {
 				.withPropertyValues("spring.rabbitmq.cache.channel.size=23",
 						"spring.rabbitmq.cache.channel.checkoutTimeout=1000",
 						"spring.rabbitmq.cache.connection.mode=CONNECTION",
-						"spring.rabbitmq.cache.connection.size=2").run((context) -> {
+						"spring.rabbitmq.cache.connection.size=2")
+				.run((context) -> {
 					CachingConnectionFactory connectionFactory = context
 							.getBean(CachingConnectionFactory.class);
 					DirectFieldAccessor dfa = new DirectFieldAccessor(connectionFactory);
 					assertThat(dfa.getPropertyValue("channelCacheSize")).isEqualTo(23);
-			assertThat(dfa.getPropertyValue("cacheMode")).isEqualTo(CacheMode.CONNECTION);
+					assertThat(dfa.getPropertyValue("cacheMode"))
+							.isEqualTo(CacheMode.CONNECTION);
 					assertThat(dfa.getPropertyValue("connectionCacheSize")).isEqualTo(2);
-			assertThat(dfa.getPropertyValue("channelCheckoutTimeout")).isEqualTo(1000L);
+					assertThat(dfa.getPropertyValue("channelCheckoutTimeout"))
+							.isEqualTo(1000L);
 				});
 	}
 
@@ -280,11 +290,12 @@ public class RabbitAutoConfigurationTests {
 
 	@Test
 	public void testRabbitMessagingTemplateBackOff() {
-		this.contextRunner.withUserConfiguration(
-				TestConfiguration4.class).run((context) -> {
+		this.contextRunner.withUserConfiguration(TestConfiguration4.class)
+				.run((context) -> {
 					RabbitMessagingTemplate messagingTemplate = context
 							.getBean(RabbitMessagingTemplate.class);
-			assertThat(messagingTemplate.getDefaultDestination()).isEqualTo("fooBar");
+					assertThat(messagingTemplate.getDefaultDestination())
+							.isEqualTo("fooBar");
 				});
 	}
 
@@ -292,7 +303,8 @@ public class RabbitAutoConfigurationTests {
 	public void testStaticQueues() {
 		this.contextRunner.withUserConfiguration(TestConfiguration.class)
 				.withPropertyValues("spring.rabbitmq.dynamic:false").run((context) -> {
-			// There should NOT be an AmqpAdmin bean when dynamic is switch to false
+					// There should NOT be an AmqpAdmin bean when dynamic is switch to
+					// false
 					this.thrown.expect(NoSuchBeanDefinitionException.class);
 					this.thrown.expectMessage("No qualifying bean of type");
 					this.thrown.expectMessage(AmqpAdmin.class.getName());
@@ -302,8 +314,8 @@ public class RabbitAutoConfigurationTests {
 
 	@Test
 	public void testEnableRabbitCreateDefaultContainerFactory() {
-		this.contextRunner.withUserConfiguration(
-				EnableRabbitConfiguration.class).run((context) -> {
+		this.contextRunner.withUserConfiguration(EnableRabbitConfiguration.class)
+				.run((context) -> {
 					RabbitListenerContainerFactory<?> rabbitListenerContainerFactory = context
 							.getBean("rabbitListenerContainerFactory",
 									RabbitListenerContainerFactory.class);
@@ -314,14 +326,15 @@ public class RabbitAutoConfigurationTests {
 
 	@Test
 	public void testRabbitListenerContainerFactoryBackOff() {
-		this.contextRunner.withUserConfiguration(
-				TestConfiguration5.class).run((context) -> {
+		this.contextRunner.withUserConfiguration(TestConfiguration5.class)
+				.run((context) -> {
 					SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory = context
 							.getBean("rabbitListenerContainerFactory",
 									SimpleRabbitListenerContainerFactory.class);
 					rabbitListenerContainerFactory.setTxSize(10);
 					verify(rabbitListenerContainerFactory).setTxSize(10);
-			DirectFieldAccessor dfa = new DirectFieldAccessor(rabbitListenerContainerFactory);
+					DirectFieldAccessor dfa = new DirectFieldAccessor(
+							rabbitListenerContainerFactory);
 					Advice[] adviceChain = (Advice[]) dfa.getPropertyValue("adviceChain");
 					assertThat(adviceChain).isNull();
 				});
@@ -329,9 +342,10 @@ public class RabbitAutoConfigurationTests {
 
 	@Test
 	public void testSimpleRabbitListenerContainerFactoryWithCustomSettings() {
-		this.contextRunner.withUserConfiguration(MessageConvertersConfiguration.class,
-				MessageRecoverersConfiguration.class).withPropertyValues(
-				"spring.rabbitmq.listener.simple.retry.enabled:true",
+		this.contextRunner
+				.withUserConfiguration(MessageConvertersConfiguration.class,
+						MessageRecoverersConfiguration.class)
+				.withPropertyValues("spring.rabbitmq.listener.simple.retry.enabled:true",
 						"spring.rabbitmq.listener.simple.retry.maxAttempts:4",
 						"spring.rabbitmq.listener.simple.retry.initialInterval:2000",
 						"spring.rabbitmq.listener.simple.retry.multiplier:1.5",
@@ -343,13 +357,16 @@ public class RabbitAutoConfigurationTests {
 						"spring.rabbitmq.listener.simple.prefetch:40",
 						"spring.rabbitmq.listener.simple.defaultRequeueRejected:false",
 						"spring.rabbitmq.listener.simple.idleEventInterval:5",
-				"spring.rabbitmq.listener.simple.transactionSize:20").run((context) -> {
+						"spring.rabbitmq.listener.simple.transactionSize:20")
+				.run((context) -> {
 					SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory = context
 							.getBean("rabbitListenerContainerFactory",
 									SimpleRabbitListenerContainerFactory.class);
-			DirectFieldAccessor dfa = new DirectFieldAccessor(rabbitListenerContainerFactory);
+					DirectFieldAccessor dfa = new DirectFieldAccessor(
+							rabbitListenerContainerFactory);
 					assertThat(dfa.getPropertyValue("concurrentConsumers")).isEqualTo(5);
-			assertThat(dfa.getPropertyValue("maxConcurrentConsumers")).isEqualTo(10);
+					assertThat(dfa.getPropertyValue("maxConcurrentConsumers"))
+							.isEqualTo(10);
 					assertThat(dfa.getPropertyValue("txSize")).isEqualTo(20);
 					checkCommonProps(context, dfa);
 				});
@@ -357,9 +374,10 @@ public class RabbitAutoConfigurationTests {
 
 	@Test
 	public void testDirectRabbitListenerContainerFactoryWithCustomSettings() {
-		this.contextRunner.withUserConfiguration(MessageConvertersConfiguration.class,
-				MessageRecoverersConfiguration.class).withPropertyValues(
-				"spring.rabbitmq.listener.type:direct",
+		this.contextRunner
+				.withUserConfiguration(MessageConvertersConfiguration.class,
+						MessageRecoverersConfiguration.class)
+				.withPropertyValues("spring.rabbitmq.listener.type:direct",
 						"spring.rabbitmq.listener.direct.retry.enabled:true",
 						"spring.rabbitmq.listener.direct.retry.maxAttempts:4",
 						"spring.rabbitmq.listener.direct.retry.initialInterval:2000",
@@ -370,11 +388,13 @@ public class RabbitAutoConfigurationTests {
 						"spring.rabbitmq.listener.direct.consumers-per-queue:5",
 						"spring.rabbitmq.listener.direct.prefetch:40",
 						"spring.rabbitmq.listener.direct.defaultRequeueRejected:false",
-				"spring.rabbitmq.listener.direct.idleEventInterval:5").run((context) -> {
+						"spring.rabbitmq.listener.direct.idleEventInterval:5")
+				.run((context) -> {
 					DirectRabbitListenerContainerFactory rabbitListenerContainerFactory = context
 							.getBean("rabbitListenerContainerFactory",
 									DirectRabbitListenerContainerFactory.class);
-			DirectFieldAccessor dfa = new DirectFieldAccessor(rabbitListenerContainerFactory);
+					DirectFieldAccessor dfa = new DirectFieldAccessor(
+							rabbitListenerContainerFactory);
 					assertThat(dfa.getPropertyValue("consumersPerQueue")).isEqualTo(5);
 					checkCommonProps(context, dfa);
 				});
@@ -387,7 +407,8 @@ public class RabbitAutoConfigurationTests {
 						"spring.rabbitmq.listener.simple.maxConcurrency:10",
 						"spring.rabbitmq.listener.simple.prefetch:40",
 						"spring.rabbitmq.listener.direct.consumers-per-queue:5",
-						"spring.rabbitmq.listener.direct.prefetch:40").run((context) -> {
+						"spring.rabbitmq.listener.direct.prefetch:40")
+				.run((context) -> {
 					assertThat(context).hasSingleBean(
 							SimpleRabbitListenerContainerFactoryConfigurer.class);
 					assertThat(context).hasSingleBean(
@@ -401,9 +422,11 @@ public class RabbitAutoConfigurationTests {
 				.withPropertyValues("spring.rabbitmq.listener.type:direct",
 						"spring.rabbitmq.listener.simple.concurrency:5",
 						"spring.rabbitmq.listener.simple.maxConcurrency:10",
-						"spring.rabbitmq.listener.simple.prefetch:40").run((context) -> {
+						"spring.rabbitmq.listener.simple.prefetch:40")
+				.run((context) -> {
 					SimpleRabbitListenerContainerFactoryConfigurer configurer = context
-					.getBean(SimpleRabbitListenerContainerFactoryConfigurer.class);
+							.getBean(
+									SimpleRabbitListenerContainerFactoryConfigurer.class);
 					SimpleRabbitListenerContainerFactory factory = mock(
 							SimpleRabbitListenerContainerFactory.class);
 					configurer.configure(factory, mock(ConnectionFactory.class));
@@ -418,9 +441,11 @@ public class RabbitAutoConfigurationTests {
 		this.contextRunner.withUserConfiguration(TestConfiguration.class)
 				.withPropertyValues("spring.rabbitmq.listener.type:simple",
 						"spring.rabbitmq.listener.direct.consumers-per-queue:5",
-						"spring.rabbitmq.listener.direct.prefetch:40").run((context) -> {
+						"spring.rabbitmq.listener.direct.prefetch:40")
+				.run((context) -> {
 					DirectRabbitListenerContainerFactoryConfigurer configurer = context
-					.getBean(DirectRabbitListenerContainerFactoryConfigurer.class);
+							.getBean(
+									DirectRabbitListenerContainerFactoryConfigurer.class);
 					DirectRabbitListenerContainerFactory factory = mock(
 							DirectRabbitListenerContainerFactory.class);
 					configurer.configure(factory, mock(ConnectionFactory.class));
@@ -468,8 +493,8 @@ public class RabbitAutoConfigurationTests {
 
 	@Test
 	public void enableRabbitAutomatically() throws Exception {
-		this.contextRunner.withUserConfiguration(
-				NoEnableRabbitConfiguration.class).run((context) -> {
+		this.contextRunner.withUserConfiguration(NoEnableRabbitConfiguration.class)
+				.run((context) -> {
 					assertThat(context).hasBean(
 							RabbitListenerConfigUtils.RABBIT_LISTENER_ANNOTATION_PROCESSOR_BEAN_NAME);
 					assertThat(context).hasBean(
@@ -482,7 +507,8 @@ public class RabbitAutoConfigurationTests {
 		this.contextRunner.withUserConfiguration(TestConfiguration.class)
 				.withPropertyValues("spring.rabbitmq.requestedHeartbeat:20")
 				.run((context) -> {
-					com.rabbitmq.client.ConnectionFactory rabbitConnectionFactory = getTargetConnectionFactory(context);
+					com.rabbitmq.client.ConnectionFactory rabbitConnectionFactory = getTargetConnectionFactory(
+							context);
 					assertThat(rabbitConnectionFactory.getRequestedHeartbeat())
 							.isEqualTo(20);
 				});
@@ -490,9 +516,10 @@ public class RabbitAutoConfigurationTests {
 
 	@Test
 	public void noSslByDefault() {
-		this.contextRunner.withUserConfiguration(
-				TestConfiguration.class).run((context) -> {
-			com.rabbitmq.client.ConnectionFactory rabbitConnectionFactory = getTargetConnectionFactory(context);
+		this.contextRunner.withUserConfiguration(TestConfiguration.class)
+				.run((context) -> {
+					com.rabbitmq.client.ConnectionFactory rabbitConnectionFactory = getTargetConnectionFactory(
+							context);
 					assertThat(rabbitConnectionFactory.getSocketFactory())
 							.as("Must use default SocketFactory")
 							.isEqualTo(SocketFactory.getDefault());
@@ -503,9 +530,11 @@ public class RabbitAutoConfigurationTests {
 	public void enableSsl() {
 		this.contextRunner.withUserConfiguration(TestConfiguration.class)
 				.withPropertyValues("spring.rabbitmq.ssl.enabled:true").run((context) -> {
-			com.rabbitmq.client.ConnectionFactory rabbitConnectionFactory = getTargetConnectionFactory(context);
+					com.rabbitmq.client.ConnectionFactory rabbitConnectionFactory = getTargetConnectionFactory(
+							context);
 					assertThat(rabbitConnectionFactory.getSocketFactory())
-					.as("SocketFactory must use SSL").isInstanceOf(SSLSocketFactory.class);
+							.as("SocketFactory must use SSL")
+							.isInstanceOf(SSLSocketFactory.class);
 				});
 	}
 
@@ -517,10 +546,12 @@ public class RabbitAutoConfigurationTests {
 						"spring.rabbitmq.ssl.keyStore=foo",
 						"spring.rabbitmq.ssl.keyStorePassword=secret",
 						"spring.rabbitmq.ssl.trustStore=bar",
-						"spring.rabbitmq.ssl.trustStorePassword=secret").run((context) -> {
+						"spring.rabbitmq.ssl.trustStorePassword=secret")
+				.run((context) -> {
 					assertThat(context).hasFailed();
 					assertThat(context).getFailure().hasMessageContaining("foo");
-			assertThat(context).getFailure().hasMessageContaining("does not exist");
+					assertThat(context).getFailure()
+							.hasMessageContaining("does not exist");
 				});
 	}
 

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/batch/BatchAutoConfigurationTests.java

@@ -86,8 +86,8 @@ public class BatchAutoConfigurationTests {
 				EmbeddedDataSourceConfiguration.class).run((context) -> {
 					assertThat(context).hasSingleBean(JobLauncher.class);
 					assertThat(context).hasSingleBean(JobExplorer.class);
-			assertThat(context.getBean(BatchProperties.class)
-					.getInitializer().isEnabled()).isTrue();
+					assertThat(context.getBean(BatchProperties.class).getInitializer()
+							.isEnabled()).isTrue();
 					assertThat(new JdbcTemplate(context.getBean(DataSource.class))
 							.queryForList("select * from BATCH_JOB_EXECUTION")).isEmpty();
 				});
@@ -95,8 +95,8 @@ public class BatchAutoConfigurationTests {
 
 	@Test
 	public void testNoDatabase() throws Exception {
-		this.contextRunner.withUserConfiguration(
-				TestCustomConfiguration.class).run((context) -> {
+		this.contextRunner.withUserConfiguration(TestCustomConfiguration.class)
+				.run((context) -> {
 					assertThat(context).hasSingleBean(JobLauncher.class);
 					JobExplorer explorer = context.getBean(JobExplorer.class);
 					assertThat(explorer.getJobInstances("job", 0, 100)).isEmpty();
@@ -118,17 +118,18 @@ public class BatchAutoConfigurationTests {
 				EmbeddedDataSourceConfiguration.class).run((context) -> {
 					assertThat(context).hasSingleBean(JobLauncher.class);
 					context.getBean(JobLauncherCommandLineRunner.class).run();
-			assertThat(context.getBean(JobRepository.class).getLastJobExecution("job",
-					new JobParameters())).isNotNull();
+					assertThat(context.getBean(JobRepository.class)
+							.getLastJobExecution("job", new JobParameters())).isNotNull();
 				});
 	}
 
 	@Test
 	public void testDefinesAndLaunchesNamedJob() throws Exception {
-		this.contextRunner.withUserConfiguration(
-				NamedJobConfigurationWithRegisteredJob.class,
-				EmbeddedDataSourceConfiguration.class).withPropertyValues(
-				"spring.batch.job.names:discreteRegisteredJob").run((context) -> {
+		this.contextRunner
+				.withUserConfiguration(NamedJobConfigurationWithRegisteredJob.class,
+						EmbeddedDataSourceConfiguration.class)
+				.withPropertyValues("spring.batch.job.names:discreteRegisteredJob")
+				.run((context) -> {
 					assertThat(context).hasSingleBean(JobLauncher.class);
 					context.getBean(JobLauncherCommandLineRunner.class).run();
 					assertThat(context.getBean(JobRepository.class).getLastJobExecution(
@@ -138,21 +139,25 @@ public class BatchAutoConfigurationTests {
 
 	@Test
 	public void testDefinesAndLaunchesLocalJob() throws Exception {
-		this.contextRunner.withUserConfiguration(NamedJobConfigurationWithLocalJob.class,
-				EmbeddedDataSourceConfiguration.class).withPropertyValues(
-				"spring.batch.job.names:discreteLocalJob").run((context) -> {
+		this.contextRunner
+				.withUserConfiguration(NamedJobConfigurationWithLocalJob.class,
+						EmbeddedDataSourceConfiguration.class)
+				.withPropertyValues("spring.batch.job.names:discreteLocalJob")
+				.run((context) -> {
 					assertThat(context).hasSingleBean(JobLauncher.class);
 					context.getBean(JobLauncherCommandLineRunner.class).run();
-			assertThat(context.getBean(JobRepository.class).getLastJobExecution(
-					"discreteLocalJob", new JobParameters())).isNotNull();
+					assertThat(context.getBean(JobRepository.class)
+							.getLastJobExecution("discreteLocalJob", new JobParameters()))
+									.isNotNull();
 				});
 	}
 
 	@Test
 	public void testDisableLaunchesJob() throws Exception {
-		this.contextRunner.withUserConfiguration(JobConfiguration.class,
-				EmbeddedDataSourceConfiguration.class).withPropertyValues(
-				"spring.batch.job.enabled:false").run((context) -> {
+		this.contextRunner
+				.withUserConfiguration(JobConfiguration.class,
+						EmbeddedDataSourceConfiguration.class)
+				.withPropertyValues("spring.batch.job.enabled:false").run((context) -> {
 					assertThat(context).hasSingleBean(JobLauncher.class);
 					assertThat(context).doesNotHaveBean(CommandLineRunner.class);
 				});
@@ -160,16 +165,18 @@ public class BatchAutoConfigurationTests {
 
 	@Test
 	public void testDisableSchemaLoader() throws Exception {
-		this.contextRunner.withUserConfiguration(TestConfiguration.class,
-				EmbeddedDataSourceConfiguration.class).withPropertyValues(
-				"spring.datasource.generate-unique-name=true",
-				"spring.batch.initializer.enabled:false").run((context) -> {
+		this.contextRunner
+				.withUserConfiguration(TestConfiguration.class,
+						EmbeddedDataSourceConfiguration.class)
+				.withPropertyValues("spring.datasource.generate-unique-name=true",
+						"spring.batch.initializer.enabled:false")
+				.run((context) -> {
 					assertThat(context).hasSingleBean(JobLauncher.class);
 					assertThat(context.getBean(BatchProperties.class).getInitializer()
 							.isEnabled()).isFalse();
 					this.expected.expect(BadSqlGrammarException.class);
-			new JdbcTemplate(context.getBean(DataSource.class)).queryForList(
-					"select * from BATCH_JOB_EXECUTION");
+					new JdbcTemplate(context.getBean(DataSource.class))
+							.queryForList("select * from BATCH_JOB_EXECUTION");
 				});
 	}
 
@@ -180,65 +187,74 @@ public class BatchAutoConfigurationTests {
 				HibernateJpaAutoConfiguration.class).run((context) -> {
 					PlatformTransactionManager transactionManager = context
 							.getBean(PlatformTransactionManager.class);
-			// It's a lazy proxy, but it does render its target if you ask for toString():
-			assertThat(transactionManager.toString().contains("JpaTransactionManager"))
-					.isTrue();
+					// It's a lazy proxy, but it does render its target if you ask for
+					// toString():
+					assertThat(transactionManager.toString()
+							.contains("JpaTransactionManager")).isTrue();
 					assertThat(context).hasSingleBean(EntityManagerFactory.class);
-			// Ensure the JobRepository can be used (no problem with isolation level)
-			assertThat(context.getBean(JobRepository.class).getLastJobExecution("job",
-					new JobParameters())).isNull();
+					// Ensure the JobRepository can be used (no problem with isolation
+					// level)
+					assertThat(context.getBean(JobRepository.class)
+							.getLastJobExecution("job", new JobParameters())).isNull();
 				});
 	}
 
-
 	@Test
 	public void testRenamePrefix() throws Exception {
-		this.contextRunner.withUserConfiguration(TestConfiguration.class,
+		this.contextRunner
+				.withUserConfiguration(TestConfiguration.class,
 						EmbeddedDataSourceConfiguration.class,
-				HibernateJpaAutoConfiguration.class).withPropertyValues(
-				"spring.datasource.generate-unique-name=true",
+						HibernateJpaAutoConfiguration.class)
+				.withPropertyValues("spring.datasource.generate-unique-name=true",
 						"spring.batch.schema:classpath:batch/custom-schema-hsql.sql",
-				"spring.batch.tablePrefix:PREFIX_").run((context) -> {
+						"spring.batch.tablePrefix:PREFIX_")
+				.run((context) -> {
 					assertThat(context).hasSingleBean(JobLauncher.class);
 					assertThat(context.getBean(BatchProperties.class).getInitializer()
 							.isEnabled()).isTrue();
 					assertThat(new JdbcTemplate(context.getBean(DataSource.class))
-					.queryForList("select * from PREFIX_JOB_EXECUTION")).isEmpty();
+							.queryForList("select * from PREFIX_JOB_EXECUTION"))
+									.isEmpty();
 					JobExplorer jobExplorer = context.getBean(JobExplorer.class);
 					assertThat(jobExplorer.findRunningJobExecutions("test")).isEmpty();
 					JobRepository jobRepository = context.getBean(JobRepository.class);
-			assertThat(jobRepository.getLastJobExecution("test", new JobParameters()))
-					.isNull();
+					assertThat(jobRepository.getLastJobExecution("test",
+							new JobParameters())).isNull();
 				});
 	}
 
 	@Test
 	public void testCustomTablePrefixWithDefaultSchemaDisablesInitializer()
 			throws Exception {
-		this.contextRunner.withUserConfiguration(TestConfiguration.class,
+		this.contextRunner
+				.withUserConfiguration(TestConfiguration.class,
 						EmbeddedDataSourceConfiguration.class,
-				HibernateJpaAutoConfiguration.class).withPropertyValues(
-				"spring.datasource.generate-unique-name=true",
-				"spring.batch.tablePrefix:PREFIX_").run((context) -> {
+						HibernateJpaAutoConfiguration.class)
+				.withPropertyValues("spring.datasource.generate-unique-name=true",
+						"spring.batch.tablePrefix:PREFIX_")
+				.run((context) -> {
 					assertThat(context).hasSingleBean(JobLauncher.class);
 					assertThat(context.getBean(BatchProperties.class).getInitializer()
 							.isEnabled()).isFalse();
 					this.expected.expect(BadSqlGrammarException.class);
-			new JdbcTemplate(context.getBean(DataSource.class)).queryForList(
-					"select * from BATCH_JOB_EXECUTION");
+					new JdbcTemplate(context.getBean(DataSource.class))
+							.queryForList("select * from BATCH_JOB_EXECUTION");
 				});
 	}
 
 	@Test
 	public void testCustomizeJpaTransactionManagerUsingProperties() throws Exception {
-		this.contextRunner.withUserConfiguration(TestConfiguration.class,
+		this.contextRunner
+				.withUserConfiguration(TestConfiguration.class,
 						EmbeddedDataSourceConfiguration.class,
-				HibernateJpaAutoConfiguration.class).withPropertyValues(
-				"spring.transaction.default-timeout:30",
-				"spring.transaction.rollback-on-commit-failure:true").run((context) -> {
+						HibernateJpaAutoConfiguration.class)
+				.withPropertyValues("spring.transaction.default-timeout:30",
+						"spring.transaction.rollback-on-commit-failure:true")
+				.run((context) -> {
 					assertThat(context).hasSingleBean(BatchConfigurer.class);
-			JpaTransactionManager transactionManager = JpaTransactionManager.class.cast(
-					context.getBean(BatchConfigurer.class).getTransactionManager());
+					JpaTransactionManager transactionManager = JpaTransactionManager.class
+							.cast(context.getBean(BatchConfigurer.class)
+									.getTransactionManager());
 					assertThat(transactionManager.getDefaultTimeout()).isEqualTo(30);
 					assertThat(transactionManager.isRollbackOnCommitFailure()).isTrue();
 				});
@@ -247,13 +263,16 @@ public class BatchAutoConfigurationTests {
 	@Test
 	public void testCustomizeDataSourceTransactionManagerUsingProperties()
 			throws Exception {
-		this.contextRunner.withUserConfiguration(TestConfiguration.class,
-				EmbeddedDataSourceConfiguration.class).withPropertyValues(
-				"spring.transaction.default-timeout:30",
-				"spring.transaction.rollback-on-commit-failure:true").run((context) -> {
+		this.contextRunner
+				.withUserConfiguration(TestConfiguration.class,
+						EmbeddedDataSourceConfiguration.class)
+				.withPropertyValues("spring.transaction.default-timeout:30",
+						"spring.transaction.rollback-on-commit-failure:true")
+				.run((context) -> {
 					assertThat(context).hasSingleBean(BatchConfigurer.class);
 					DataSourceTransactionManager transactionManager = DataSourceTransactionManager.class
-					.cast(context.getBean(BatchConfigurer.class).getTransactionManager());
+							.cast(context.getBean(BatchConfigurer.class)
+									.getTransactionManager());
 					assertThat(transactionManager.getDefaultTimeout()).isEqualTo(30);
 					assertThat(transactionManager.isRollbackOnCommitFailure()).isTrue();
 				});

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/batch/BatchAutoConfigurationWithoutJpaTests.java

@@ -54,42 +54,45 @@ public class BatchAutoConfigurationWithoutJpaTests {
 
 	@Test
 	public void jdbcWithDefaultSettings() throws Exception {
-		this.contextRunner.withUserConfiguration(DefaultConfiguration.class,
-				EmbeddedDataSourceConfiguration.class).withPropertyValues(
-				"spring.datasource.generate-unique-name=true").run((context) -> {
+		this.contextRunner
+				.withUserConfiguration(DefaultConfiguration.class,
+						EmbeddedDataSourceConfiguration.class)
+				.withPropertyValues("spring.datasource.generate-unique-name=true")
+				.run((context) -> {
 					assertThat(context).hasSingleBean(JobLauncher.class);
 					assertThat(context).hasSingleBean(JobExplorer.class);
 					assertThat(context).hasSingleBean(JobRepository.class);
 					assertThat(context).hasSingleBean(PlatformTransactionManager.class);
-			assertThat(context.getBean(PlatformTransactionManager.class).toString())
-					.contains("DataSourceTransactionManager");
 					assertThat(
-					context.getBean(BatchProperties.class).getInitializer().isEnabled())
-					.isTrue();
+							context.getBean(PlatformTransactionManager.class).toString())
+									.contains("DataSourceTransactionManager");
+					assertThat(context.getBean(BatchProperties.class).getInitializer()
+							.isEnabled()).isTrue();
 					assertThat(new JdbcTemplate(context.getBean(DataSource.class))
 							.queryForList("select * from BATCH_JOB_EXECUTION")).isEmpty();
-			assertThat(
-					context.getBean(JobExplorer.class).findRunningJobExecutions("test"))
-					.isEmpty();
-			assertThat(context.getBean(JobRepository.class).getLastJobExecution("test",
-					new JobParameters())).isNull();
+					assertThat(context.getBean(JobExplorer.class)
+							.findRunningJobExecutions("test")).isEmpty();
+					assertThat(context.getBean(JobRepository.class)
+							.getLastJobExecution("test", new JobParameters())).isNull();
 				});
 	}
 
 	@Test
 	public void jdbcWithCustomPrefix() throws Exception {
-		this.contextRunner.withUserConfiguration(DefaultConfiguration.class,
-				EmbeddedDataSourceConfiguration.class).withPropertyValues(
-				"spring.datasource.generate-unique-name=true",
+		this.contextRunner
+				.withUserConfiguration(DefaultConfiguration.class,
+						EmbeddedDataSourceConfiguration.class)
+				.withPropertyValues("spring.datasource.generate-unique-name=true",
 						"spring.batch.schema:classpath:batch/custom-schema-hsql.sql",
-				"spring.batch.tablePrefix:PREFIX_").run((context) -> {
+						"spring.batch.tablePrefix:PREFIX_")
+				.run((context) -> {
 					assertThat(new JdbcTemplate(context.getBean(DataSource.class))
-					.queryForList("select * from PREFIX_JOB_EXECUTION")).isEmpty();
-			assertThat(
-					context.getBean(JobExplorer.class).findRunningJobExecutions("test"))
+							.queryForList("select * from PREFIX_JOB_EXECUTION"))
 									.isEmpty();
-			assertThat(context.getBean(JobRepository.class).getLastJobExecution("test",
-					new JobParameters())).isNull();
+					assertThat(context.getBean(JobExplorer.class)
+							.findRunningJobExecutions("test")).isEmpty();
+					assertThat(context.getBean(JobRepository.class)
+							.getLastJobExecution("test", new JobParameters())).isNull();
 				});
 	}
 

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/batch/JobLauncherCommandLineRunnerTests.java

@@ -80,8 +80,7 @@ public class JobLauncherCommandLineRunnerTests {
 		this.step = this.steps.get("step").tasklet(tasklet).build();
 		this.job = this.jobs.get("job").start(this.step).build();
 		this.jobExplorer = this.context.getBean(JobExplorer.class);
-		this.runner = new JobLauncherCommandLineRunner(jobLauncher,
-				this.jobExplorer);
+		this.runner = new JobLauncherCommandLineRunner(jobLauncher, this.jobExplorer);
 		this.context.getBean(BatchConfiguration.class).clear();
 	}
 

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/cassandra/CassandraAutoConfigurationTests.java

@@ -50,8 +50,9 @@ public class CassandraAutoConfigurationTests {
 
 	@Test
 	public void createClusterWithOverrides() {
-		this.contextRunner.withPropertyValues(
-				"spring.data.cassandra.cluster-name=testcluster").run((context) -> {
+		this.contextRunner
+				.withPropertyValues("spring.data.cassandra.cluster-name=testcluster")
+				.run((context) -> {
 					assertThat(context).hasSingleBean(Cluster.class);
 					assertThat(context.getBean(Cluster.class).getClusterName())
 							.isEqualTo("testcluster");
@@ -60,8 +61,8 @@ public class CassandraAutoConfigurationTests {
 
 	@Test
 	public void createCustomizeCluster() {
-		this.contextRunner.withUserConfiguration(
-				MockCustomizerConfig.class).run((context) -> {
+		this.contextRunner.withUserConfiguration(MockCustomizerConfig.class)
+				.run((context) -> {
 					assertThat(context).hasSingleBean(Cluster.class);
 					assertThat(context).hasSingleBean(ClusterBuilderCustomizer.class);
 				});
@@ -70,7 +71,8 @@ public class CassandraAutoConfigurationTests {
 	@Test
 	public void customizerOverridesAutoConfig() {
 		this.contextRunner.withUserConfiguration(SimpleCustomizerConfig.class)
-				.withPropertyValues("spring.data.cassandra.cluster-name=testcluster").run((context) -> {
+				.withPropertyValues("spring.data.cassandra.cluster-name=testcluster")
+				.run((context) -> {
 					assertThat(context).hasSingleBean(Cluster.class);
 					assertThat(context.getBean(Cluster.class).getClusterName())
 							.isEqualTo("overridden-name");
@@ -96,22 +98,23 @@ public class CassandraAutoConfigurationTests {
 
 	@Test
 	public void customizePoolOptions() {
-		this.contextRunner.withPropertyValues(
-				"spring.data.cassandra.pool.idle-timeout=42",
+		this.contextRunner
+				.withPropertyValues("spring.data.cassandra.pool.idle-timeout=42",
 						"spring.data.cassandra.pool.pool-timeout=52",
 						"spring.data.cassandra.pool.heartbeat-interval=62",
-				"spring.data.cassandra.pool.max-queue-size=72").run((context) -> {
+						"spring.data.cassandra.pool.max-queue-size=72")
+				.run((context) -> {
 					assertThat(context).hasSingleBean(Cluster.class);
 					PoolingOptions poolingOptions = context.getBean(Cluster.class)
 							.getConfiguration().getPoolingOptions();
 					assertThat(poolingOptions.getIdleTimeoutSeconds()).isEqualTo(42);
 					assertThat(poolingOptions.getPoolTimeoutMillis()).isEqualTo(52);
-			assertThat(poolingOptions.getHeartbeatIntervalSeconds()).isEqualTo(62);
+					assertThat(poolingOptions.getHeartbeatIntervalSeconds())
+							.isEqualTo(62);
 					assertThat(poolingOptions.getMaxQueueSize()).isEqualTo(72);
 				});
 	}
 
-
 	@Configuration
 	static class MockCustomizerConfig {
 

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/condition/ConditionalOnBeanTests.java

@@ -30,7 +30,6 @@ import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.beans.factory.support.RootBeanDefinition;
 import org.springframework.boot.test.context.assertj.AssertableApplicationContext;
 import org.springframework.boot.test.context.runner.ApplicationContextRunner;
-import org.springframework.boot.test.context.runner.ContextConsumer;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
@@ -55,40 +54,42 @@ public class ConditionalOnBeanTests {
 	@Test
 	public void testNameOnBeanCondition() {
 		this.contextRunner.withUserConfiguration(FooConfiguration.class,
-				OnBeanNameConfiguration.class).run(hasBarBean());
+				OnBeanNameConfiguration.class).run(this::hasBarBean);
 	}
 
 	@Test
 	public void testNameAndTypeOnBeanCondition() {
-		this.contextRunner.withUserConfiguration(FooConfiguration.class,
-				OnBeanNameAndTypeConfiguration.class).run((context) ->
-				assertThat(context).doesNotHaveBean("bar"));
+		this.contextRunner
+				.withUserConfiguration(FooConfiguration.class,
+						OnBeanNameAndTypeConfiguration.class)
+				.run((context) -> assertThat(context).doesNotHaveBean("bar"));
 	}
 
 	@Test
 	public void testNameOnBeanConditionReverseOrder() {
 		// Ideally this should be true
-		this.contextRunner.withUserConfiguration(OnBeanNameConfiguration.class,
-				FooConfiguration.class).run((context) ->
-				assertThat(context).doesNotHaveBean("bar"));
+		this.contextRunner
+				.withUserConfiguration(OnBeanNameConfiguration.class,
+						FooConfiguration.class)
+				.run((context) -> assertThat(context).doesNotHaveBean("bar"));
 	}
 
 	@Test
 	public void testClassOnBeanCondition() {
 		this.contextRunner.withUserConfiguration(FooConfiguration.class,
-				OnBeanClassConfiguration.class).run(hasBarBean());
+				OnBeanClassConfiguration.class).run(this::hasBarBean);
 	}
 
 	@Test
 	public void testClassOnBeanClassNameCondition() {
 		this.contextRunner.withUserConfiguration(FooConfiguration.class,
-				OnBeanClassNameConfiguration.class).run(hasBarBean());
+				OnBeanClassNameConfiguration.class).run(this::hasBarBean);
 	}
 
 	@Test
 	public void testOnBeanConditionWithXml() {
 		this.contextRunner.withUserConfiguration(XmlConfiguration.class,
-				OnBeanNameConfiguration.class).run(hasBarBean());
+				OnBeanNameConfiguration.class).run(this::hasBarBean);
 	}
 
 	@Test
@@ -101,20 +102,21 @@ public class ConditionalOnBeanTests {
 	@Test
 	public void testAnnotationOnBeanCondition() {
 		this.contextRunner.withUserConfiguration(FooConfiguration.class,
-				OnAnnotationConfiguration.class).run(hasBarBean());
+				OnAnnotationConfiguration.class).run(this::hasBarBean);
 	}
 
 	@Test
 	public void testOnMissingBeanType() throws Exception {
-		this.contextRunner.withUserConfiguration(FooConfiguration.class,
-				OnBeanMissingClassConfiguration.class).run((context) ->
-				assertThat(context).doesNotHaveBean("bar"));
+		this.contextRunner
+				.withUserConfiguration(FooConfiguration.class,
+						OnBeanMissingClassConfiguration.class)
+				.run((context) -> assertThat(context).doesNotHaveBean("bar"));
 	}
 
 	@Test
 	public void withPropertyPlaceholderClassName() throws Exception {
-		this.contextRunner.withUserConfiguration(
-				PropertySourcesPlaceholderConfigurer.class,
+		this.contextRunner
+				.withUserConfiguration(PropertySourcesPlaceholderConfigurer.class,
 						WithPropertyPlaceholderClassName.class,
 						OnBeanClassConfiguration.class)
 				.withPropertyValues("mybeanclass=java.lang.String")
@@ -130,14 +132,11 @@ public class ConditionalOnBeanTests {
 				});
 	}
 
-	private ContextConsumer<AssertableApplicationContext> hasBarBean() {
-		return (context) -> {
+	private void hasBarBean(AssertableApplicationContext context) {
 		assertThat(context).hasBean("bar");
 		assertThat(context.getBean("bar")).isEqualTo("bar");
-		};
 	}
 
-
 	@Configuration
 	@ConditionalOnBean(name = "foo")
 	protected static class OnBeanNameConfiguration {

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/condition/ConditionalOnClassTests.java

 /*
- * Copyright 2012-2016 the original author or authors.
+ * 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.
@@ -20,7 +20,6 @@ import org.junit.Test;
 
 import org.springframework.boot.test.context.assertj.AssertableApplicationContext;
 import org.springframework.boot.test.context.runner.ApplicationContextRunner;
-import org.springframework.boot.test.context.runner.ContextConsumer;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
@@ -40,38 +39,38 @@ public class ConditionalOnClassTests {
 
 	@Test
 	public void testVanillaOnClassCondition() {
-		this.contextRunner.withUserConfiguration(BasicConfiguration.class,
-				FooConfiguration.class).run(hasBarBean());
+		this.contextRunner
+				.withUserConfiguration(BasicConfiguration.class, FooConfiguration.class)
+				.run(this::hasBarBean);
 	}
 
 	@Test
 	public void testMissingOnClassCondition() {
-		this.contextRunner.withUserConfiguration(MissingConfiguration.class,
-				FooConfiguration.class).run((context) -> {
+		this.contextRunner
+				.withUserConfiguration(MissingConfiguration.class, FooConfiguration.class)
+				.run((context) -> {
 					assertThat(context).doesNotHaveBean("bar");
 					assertThat(context).hasBean("foo");
 					assertThat(context.getBean("foo")).isEqualTo("foo");
 				});
 	}
 
-
 	@Test
 	public void testOnClassConditionWithXml() {
-		this.contextRunner.withUserConfiguration(BasicConfiguration.class,
-				XmlConfiguration.class).run(hasBarBean());
+		this.contextRunner
+				.withUserConfiguration(BasicConfiguration.class, XmlConfiguration.class)
+				.run(this::hasBarBean);
 	}
 
 	@Test
 	public void testOnClassConditionWithCombinedXml() {
 		this.contextRunner.withUserConfiguration(CombinedXmlConfiguration.class)
-				.run(hasBarBean());
+				.run(this::hasBarBean);
 	}
 
-	private ContextConsumer<AssertableApplicationContext> hasBarBean() {
-		return (context) -> {
+	private void hasBarBean(AssertableApplicationContext context) {
 		assertThat(context).hasBean("bar");
 		assertThat(context.getBean("bar")).isEqualTo("bar");
-		};
 	}
 
 	@Configuration

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/condition/ConditionalOnCloudPlatformTests.java

@@ -19,9 +19,7 @@ package org.springframework.boot.autoconfigure.condition;
 import org.junit.Test;
 
 import org.springframework.boot.cloud.CloudPlatform;
-import org.springframework.boot.test.context.assertj.AssertableApplicationContext;
 import org.springframework.boot.test.context.runner.ApplicationContextRunner;
-import org.springframework.boot.test.context.runner.ContextConsumer;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
@@ -37,32 +35,21 @@ public class ConditionalOnCloudPlatformTests {
 	@Test
 	public void outcomeWhenCloudfoundryPlatformNotPresentShouldNotMatch() {
 		this.contextRunner.withUserConfiguration(CloudFoundryPlatformConfig.class)
-				.run(match(false));
+				.run((context) -> assertThat(context).doesNotHaveBean("foo"));
 	}
 
 	@Test
 	public void outcomeWhenCloudfoundryPlatformPresentShouldMatch() {
 		this.contextRunner.withUserConfiguration(CloudFoundryPlatformConfig.class)
 				.withPropertyValues("VCAP_APPLICATION:---")
-				.run(match(true));
+				.run((context) -> assertThat(context).hasBean("foo"));
 	}
 
 	@Test
 	public void outcomeWhenCloudfoundryPlatformPresentAndMethodTargetShouldMatch() {
 		this.contextRunner.withUserConfiguration(CloudFoundryPlatformOnMethodConfig.class)
 				.withPropertyValues("VCAP_APPLICATION:---")
-				.run(match(true));
-	}
-
-	private ContextConsumer<AssertableApplicationContext> match(boolean expected) {
-		return (context) -> {
-			if (expected) {
-				assertThat(context).hasBean("foo");
-			}
-			else {
-				assertThat(context).doesNotHaveBean("foo");
-			}
-		};
+				.run((context) -> assertThat(context).hasBean("foo"));
 	}
 
 	@Configuration

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/condition/ConditionalOnExpressionTests.java

@@ -18,9 +18,7 @@ package org.springframework.boot.autoconfigure.condition;
 
 import org.junit.Test;
 
-import org.springframework.boot.test.context.assertj.AssertableApplicationContext;
 import org.springframework.boot.test.context.runner.ApplicationContextRunner;
-import org.springframework.boot.test.context.runner.ContextConsumer;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
@@ -39,31 +37,19 @@ public class ConditionalOnExpressionTests {
 	@Test
 	public void expressionIsTrue() {
 		this.contextRunner.withUserConfiguration(BasicConfiguration.class)
-				.run(match(true));
+				.run((context) -> assertThat(context.getBean("foo")).isEqualTo("foo"));
 	}
 
 	@Test
 	public void expressionIsFalse() {
 		this.contextRunner.withUserConfiguration(MissingConfiguration.class)
-				.run(match(false));
+				.run((context) -> assertThat(context).doesNotHaveBean("foo"));
 	}
 
 	@Test
 	public void expressionIsNull() {
 		this.contextRunner.withUserConfiguration(NullConfiguration.class)
-				.run(match(false));
-	}
-
-	private ContextConsumer<AssertableApplicationContext> match(boolean expected) {
-		return (context) -> {
-			if (expected) {
-				assertThat(context).hasBean("foo");
-				assertThat(context.getBean("foo")).isEqualTo("foo");
-			}
-			else {
-				assertThat(context).doesNotHaveBean("foo");
-			}
-		};
+				.run((context) -> assertThat(context).doesNotHaveBean("foo"));
 	}
 
 	@Configuration

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/condition/ConditionalOnJavaTests.java

 /*
- * Copyright 2012-2016 the original author or authors.
+ * 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.
@@ -29,9 +29,7 @@ import org.junit.Test;
 
 import org.springframework.boot.autoconfigure.condition.ConditionalOnJava.JavaVersion;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnJava.Range;
-import org.springframework.boot.test.context.assertj.AssertableApplicationContext;
 import org.springframework.boot.test.context.runner.ApplicationContextRunner;
-import org.springframework.boot.test.context.runner.ContextConsumer;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.util.ReflectionUtils;
@@ -52,17 +50,20 @@ public class ConditionalOnJavaTests {
 
 	@Test
 	public void doesNotMatchIfBetterVersionIsRequired() {
-		this.contextRunner.withUserConfiguration(Java9Required.class).run(match(false));
+		this.contextRunner.withUserConfiguration(Java9Required.class)
+				.run((context) -> assertThat(context).doesNotHaveBean(String.class));
 	}
 
 	@Test
 	public void doesNotMatchIfLowerIsRequired() {
-		this.contextRunner.withUserConfiguration(Java7Required.class).run(match(false));
+		this.contextRunner.withUserConfiguration(Java7Required.class)
+				.run((context) -> assertThat(context).doesNotHaveBean(String.class));
 	}
 
 	@Test
 	public void matchesIfVersionIsInRange() {
-		this.contextRunner.withUserConfiguration(Java8Required.class).run(match(true));
+		this.contextRunner.withUserConfiguration(Java8Required.class)
+				.run((context) -> assertThat(context).hasSingleBean(String.class));
 	}
 
 	@Test
@@ -105,10 +106,8 @@ public class ConditionalOnJavaTests {
 	private String getJavaVersion(Class<?>... hiddenClasses) throws Exception {
 		URL[] urls = ((URLClassLoader) getClass().getClassLoader()).getURLs();
 		URLClassLoader classLoader = new ClassHidingClassLoader(urls, hiddenClasses);
-
 		Class<?> javaVersionClass = classLoader
 				.loadClass(ConditionalOnJava.JavaVersion.class.getName());
-
 		Method getJavaVersionMethod = ReflectionUtils.findMethod(javaVersionClass,
 				"getJavaVersion");
 		Object javaVersion = ReflectionUtils.invokeMethod(getJavaVersionMethod, null);
@@ -123,17 +122,6 @@ public class ConditionalOnJavaTests {
 		assertThat(outcome.isMatch()).as(outcome.getMessage()).isEqualTo(expected);
 	}
 
-	private ContextConsumer<AssertableApplicationContext> match(boolean expected) {
-		return (context) -> {
-			if (expected) {
-				assertThat(context).hasSingleBean(String.class);
-			}
-			else {
-				assertThat(context).doesNotHaveBean(String.class);
-			}
-		};
-	}
-
 	private final class ClassHidingClassLoader extends URLClassLoader {
 
 		private final List<Class<?>> hiddenClasses;

spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/condition/ConditionalOnJndiTests.java

@@ -27,9 +27,7 @@ import org.junit.Test;
 
 import org.springframework.boot.autoconfigure.jndi.JndiPropertiesHidingClassLoader;
 import org.springframework.boot.autoconfigure.jndi.TestableInitialContextFactory;
-import org.springframework.boot.test.context.assertj.AssertableApplicationContext;
 import org.springframework.boot.test.context.runner.ApplicationContextRunner;
-import org.springframework.boot.test.context.runner.ContextConsumer;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.type.AnnotatedTypeMetadata;
@@ -77,22 +75,26 @@ public class ConditionalOnJndiTests {
 
 	@Test
 	public void jndiNotAvailable() {
-		this.contextRunner.withUserConfiguration(JndiAvailableConfiguration.class,
-				JndiConditionConfiguration.class).run(match(false));
+		this.contextRunner
+				.withUserConfiguration(JndiAvailableConfiguration.class,
+						JndiConditionConfiguration.class)
+				.run((context) -> assertThat(context).doesNotHaveBean(String.class));
 	}
 
 	@Test
 	public void jndiAvailable() {
 		setupJndi();
-		this.contextRunner.withUserConfiguration(JndiAvailableConfiguration.class,
-				JndiConditionConfiguration.class).run(match(true));
+		this.contextRunner
+				.withUserConfiguration(JndiAvailableConfiguration.class,
+						JndiConditionConfiguration.class)
+				.run((context) -> assertThat(context).hasSingleBean(String.class));
 	}
 
 	@Test
 	public void jndiLocationNotBound() {
 		setupJndi();
 		this.contextRunner.withUserConfiguration(JndiConditionConfiguration.class)
-				.run(match(false));
+				.run((context) -> assertThat(context).doesNotHaveBean(String.class));
 	}
 
 	@Test
@@ -100,7 +102,7 @@ public class ConditionalOnJndiTests {
 		setupJndi();
 		TestableInitialContextFactory.bind("java:/FooManager", new Object());
 		this.contextRunner.withUserConfiguration(JndiConditionConfiguration.class)
-				.run(match(true));
+				.run((context) -> assertThat(context).hasSingleBean(String.class));
 	}
 
 	@Test
@@ -124,17 +126,6 @@ public class ConditionalOnJndiTests {
 				TestableInitialContextFactory.class.getName());
 	}
 
-	private ContextConsumer<AssertableApplicationContext> match(boolean expected) {
-		return (context) -> {
-			if (expected) {
-				assertThat(context).hasSingleBean(String.class);
-			}
-			else {
-				assertThat(context).doesNotHaveBean(String.class);
-			}
-		};
-	}
-
 	private AnnotatedTypeMetadata mockMetaData(String... value) {
 		AnnotatedTypeMetadata metadata = mock(AnnotatedTypeMetadata.class);
 		Map<String, Object> attributes = new HashMap<>();

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

@@ -292,20 +292,13 @@ abstract class AbstractApplicationContextRunner<SELF extends AbstractApplication
 			consumer.accept(context);
 		}
 		catch (Throwable ex) {
-			AnyThrow.throwUnchecked(ex);
+			rethrow(ex);
 		}
 	}
 
-	private static class AnyThrow {
-
-		static void throwUnchecked(Throwable e) {
-			AnyThrow.throwAny(e);
-		}
-
 	@SuppressWarnings("unchecked")
-		private static <E extends Throwable> void throwAny(Throwable e) throws E {
+	private <E extends Throwable> void rethrow(Throwable e) throws E {
 		throw (E) e;
 	}
-	}
 
 }

spring-boot-test/src/main/java/org/springframework/boot/test/json/JsonContent.java

 /*
- * Copyright 2012-2016 the original author or authors.
+ * 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.

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

@@ -130,11 +130,16 @@ public final class TestPropertyValues {
 			return call.call();
 		}
 		catch (Exception ex) {
-			AnyThrow.throwUnchecked(ex);
-			return null; // never reached
+			rethrow(ex);
+			throw new IllegalStateException("Original cause not rethrown", ex);
 		}
 	}
 
+	@SuppressWarnings("unchecked")
+	private <E extends Throwable> void rethrow(Throwable e) throws E {
+		throw (E) e;
+	}
+
 	@SuppressWarnings("unchecked")
 	private void addToSources(MutablePropertySources sources, Type type, String name) {
 		if (sources.contains(name)) {
@@ -310,16 +315,4 @@ public final class TestPropertyValues {
 
 	}
 
-	private static class AnyThrow {
-
-		static void throwUnchecked(Throwable e) {
-			AnyThrow.throwAny(e);
-		}
-
-		@SuppressWarnings("unchecked")
-		private static <E extends Throwable> void throwAny(Throwable e) throws E {
-			throw (E) e;
-		}
-	}
-
 }

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

@@ -153,7 +153,8 @@ public abstract class AbstractApplicationContextRunnerTests<T extends AbstractAp
 				new HidePackagesClassLoader(Gson.class.getPackage().getName()))
 				.run((context) -> {
 					try {
-						ClassUtils.forName(Gson.class.getName(), context.getClassLoader());
+						ClassUtils.forName(Gson.class.getName(),
+								context.getClassLoader());
 						fail("Should have thrown a ClassNotFoundException");
 					}
 					catch (ClassNotFoundException e) {