Migrate ModifiedClassPath tests to JUnit 5

Migrate the remaining JUnit 4 tests to JUnit 5, making use of the
new `ModifiedClassPathExtension`.

See gh-17491

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

@@ -16,8 +16,8 @@
 
 package org.springframework.boot.autoconfigure.batch;
 
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
 import org.springframework.batch.core.configuration.annotation.BatchConfigurer;
 import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
@@ -29,7 +29,7 @@ import org.springframework.boot.autoconfigure.AutoConfigurations;
 import org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration;
 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.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.transaction.PlatformTransactionManager;
 
@@ -41,7 +41,7 @@ import static org.mockito.Mockito.mock;
  *
  * @author Andy Wilkinson
  */
-@RunWith(ModifiedClassPathRunner.class)
+@ExtendWith(ModifiedClassPathExtension.class)
 @ClassPathExclusions("spring-jdbc-*.jar")
 class BatchAutoConfigurationWithoutJdbcTests {
 

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

@@ -18,8 +18,8 @@ package org.springframework.boot.autoconfigure.batch;
 
 import javax.sql.DataSource;
 
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
 import org.springframework.batch.core.JobParameters;
 import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
@@ -34,7 +34,7 @@ import org.springframework.boot.autoconfigure.transaction.TransactionAutoConfigu
 import org.springframework.boot.jdbc.DataSourceInitializationMode;
 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.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.transaction.PlatformTransactionManager;
 
@@ -45,15 +45,15 @@ import static org.assertj.core.api.Assertions.assertThat;
  *
  * @author Stephane Nicoll
  */
-@RunWith(ModifiedClassPathRunner.class)
+@ExtendWith(ModifiedClassPathExtension.class)
 @ClassPathExclusions("hibernate-jpa-*.jar")
-public class BatchAutoConfigurationWithoutJpaTests {
+class BatchAutoConfigurationWithoutJpaTests {
 
 	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
 			.withConfiguration(AutoConfigurations.of(BatchAutoConfiguration.class, TransactionAutoConfiguration.class));
 
 	@Test
-	public void jdbcWithDefaultSettings() {
+	void jdbcWithDefaultSettings() {
 		this.contextRunner.withUserConfiguration(DefaultConfiguration.class, EmbeddedDataSourceConfiguration.class)
 				.withPropertyValues("spring.datasource.generate-unique-name=true").run((context) -> {
 					assertThat(context).hasSingleBean(JobLauncher.class);
@@ -73,7 +73,7 @@ public class BatchAutoConfigurationWithoutJpaTests {
 	}
 
 	@Test
-	public void jdbcWithCustomPrefix() {
+	void jdbcWithCustomPrefix() {
 		this.contextRunner.withUserConfiguration(DefaultConfiguration.class, EmbeddedDataSourceConfiguration.class)
 				.withPropertyValues("spring.datasource.generate-unique-name=true",
 						"spring.batch.schema:classpath:batch/custom-schema-hsql.sql",

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/cache/CacheAutoConfigurationTests.java

@@ -40,8 +40,8 @@ import net.sf.ehcache.Status;
 import org.infinispan.configuration.cache.ConfigurationBuilder;
 import org.infinispan.jcache.embedded.JCachingProvider;
 import org.infinispan.spring.embedded.provider.SpringEmbeddedCacheManager;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
 import org.springframework.beans.factory.BeanCreationException;
 import org.springframework.beans.factory.config.BeanPostProcessor;
@@ -50,7 +50,7 @@ import org.springframework.boot.autoconfigure.cache.support.MockCachingProvider;
 import org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration;
 import org.springframework.boot.test.context.assertj.AssertableApplicationContext;
 import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
-import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
+import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
 import org.springframework.cache.Cache;
 import org.springframework.cache.CacheManager;
 import org.springframework.cache.annotation.CachingConfigurerSupport;
@@ -87,38 +87,38 @@ import static org.mockito.Mockito.verify;
  * @author Mark Paluch
  * @author Ryon Day
  */
-@RunWith(ModifiedClassPathRunner.class)
+@ExtendWith(ModifiedClassPathExtension.class)
 @ClassPathExclusions("hazelcast-client-*.jar")
-public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
+class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
 
 	@Test
-	public void noEnableCaching() {
+	void noEnableCaching() {
 		this.contextRunner.withUserConfiguration(EmptyConfiguration.class)
 				.run((context) -> assertThat(context).doesNotHaveBean(CacheManager.class));
 	}
 
 	@Test
-	public void cacheManagerBackOff() {
+	void cacheManagerBackOff() {
 		this.contextRunner.withUserConfiguration(CustomCacheManagerConfiguration.class)
 				.run((context) -> assertThat(getCacheManager(context, ConcurrentMapCacheManager.class).getCacheNames())
 						.containsOnly("custom1"));
 	}
 
 	@Test
-	public void cacheManagerFromSupportBackOff() {
+	void cacheManagerFromSupportBackOff() {
 		this.contextRunner.withUserConfiguration(CustomCacheManagerFromSupportConfiguration.class)
 				.run((context) -> assertThat(getCacheManager(context, ConcurrentMapCacheManager.class).getCacheNames())
 						.containsOnly("custom1"));
 	}
 
 	@Test
-	public void cacheResolverFromSupportBackOff() {
+	void cacheResolverFromSupportBackOff() {
 		this.contextRunner.withUserConfiguration(CustomCacheResolverFromSupportConfiguration.class)
 				.run((context) -> assertThat(context).doesNotHaveBean(CacheManager.class));
 	}
 
 	@Test
-	public void customCacheResolverCanBeDefined() {
+	void customCacheResolverCanBeDefined() {
 		this.contextRunner.withUserConfiguration(SpecificCacheResolverConfiguration.class)
 				.withPropertyValues("spring.cache.type=simple").run((context) -> {
 					getCacheManager(context, ConcurrentMapCacheManager.class);
@@ -127,7 +127,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void notSupportedCachingMode() {
+	void notSupportedCachingMode() {
 		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=foobar")
 				.run((context) -> assertThat(context).getFailure().isInstanceOf(BeanCreationException.class)
@@ -135,7 +135,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void simpleCacheExplicit() {
+	void simpleCacheExplicit() {
 		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=simple")
 				.run((context) -> assertThat(getCacheManager(context, ConcurrentMapCacheManager.class).getCacheNames())
@@ -143,14 +143,14 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void simpleCacheWithCustomizers() {
+	void simpleCacheWithCustomizers() {
 		this.contextRunner.withUserConfiguration(DefaultCacheAndCustomizersConfiguration.class)
 				.withPropertyValues("spring.cache.type=simple")
 				.run(verifyCustomizers("allCacheManagerCustomizer", "simpleCacheManagerCustomizer"));
 	}
 
 	@Test
-	public void simpleCacheExplicitWithCacheNames() {
+	void simpleCacheExplicitWithCacheNames() {
 		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=simple", "spring.cache.cacheNames[0]=foo",
 						"spring.cache.cacheNames[1]=bar")
@@ -161,7 +161,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void genericCacheWithCaches() {
+	void genericCacheWithCaches() {
 		this.contextRunner.withUserConfiguration(GenericCacheConfiguration.class).run((context) -> {
 			SimpleCacheManager cacheManager = getCacheManager(context, SimpleCacheManager.class);
 			assertThat(cacheManager.getCache("first")).isEqualTo(context.getBean("firstCache"));
@@ -171,7 +171,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void genericCacheExplicit() {
+	void genericCacheExplicit() {
 		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=generic")
 				.run((context) -> assertThat(context).getFailure().isInstanceOf(BeanCreationException.class)
@@ -180,14 +180,14 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void genericCacheWithCustomizers() {
+	void genericCacheWithCustomizers() {
 		this.contextRunner.withUserConfiguration(GenericCacheAndCustomizersConfiguration.class)
 				.withPropertyValues("spring.cache.type=generic")
 				.run(verifyCustomizers("allCacheManagerCustomizer", "genericCacheManagerCustomizer"));
 	}
 
 	@Test
-	public void genericCacheExplicitWithCaches() {
+	void genericCacheExplicitWithCaches() {
 		this.contextRunner.withUserConfiguration(GenericCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=generic").run((context) -> {
 					SimpleCacheManager cacheManager = getCacheManager(context, SimpleCacheManager.class);
@@ -198,7 +198,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void couchbaseCacheExplicit() {
+	void couchbaseCacheExplicit() {
 		this.contextRunner.withUserConfiguration(CouchbaseCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=couchbase").run((context) -> {
 					CouchbaseCacheManager cacheManager = getCacheManager(context, CouchbaseCacheManager.class);
@@ -207,14 +207,14 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void couchbaseCacheWithCustomizers() {
+	void couchbaseCacheWithCustomizers() {
 		this.contextRunner.withUserConfiguration(CouchbaseCacheAndCustomizersConfiguration.class)
 				.withPropertyValues("spring.cache.type=couchbase")
 				.run(verifyCustomizers("allCacheManagerCustomizer", "couchbaseCacheManagerCustomizer"));
 	}
 
 	@Test
-	public void couchbaseCacheExplicitWithCaches() {
+	void couchbaseCacheExplicitWithCaches() {
 		this.contextRunner.withUserConfiguration(CouchbaseCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=couchbase", "spring.cache.cacheNames[0]=foo",
 						"spring.cache.cacheNames[1]=bar")
@@ -229,7 +229,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void couchbaseCacheExplicitWithTtl() {
+	void couchbaseCacheExplicitWithTtl() {
 		this.contextRunner.withUserConfiguration(CouchbaseCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=couchbase", "spring.cache.cacheNames=foo,bar",
 						"spring.cache.couchbase.expiration=2000")
@@ -244,7 +244,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void redisCacheExplicit() {
+	void redisCacheExplicit() {
 		this.contextRunner.withUserConfiguration(RedisConfiguration.class)
 				.withPropertyValues("spring.cache.type=redis", "spring.cache.redis.time-to-live=15000",
 						"spring.cache.redis.cacheNullValues=false", "spring.cache.redis.keyPrefix=prefix",
@@ -261,7 +261,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void redisCacheWithRedisCacheConfiguration() {
+	void redisCacheWithRedisCacheConfiguration() {
 		this.contextRunner.withUserConfiguration(RedisWithCacheConfigurationConfiguration.class)
 				.withPropertyValues("spring.cache.type=redis", "spring.cache.redis.time-to-live=15000",
 						"spring.cache.redis.keyPrefix=foo")
@@ -275,7 +275,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void redisCacheWithRedisCacheManagerBuilderCustomizer() {
+	void redisCacheWithRedisCacheManagerBuilderCustomizer() {
 		this.contextRunner.withUserConfiguration(RedisWithRedisCacheManagerBuilderCustomizerConfiguration.class)
 				.withPropertyValues("spring.cache.type=redis", "spring.cache.redis.time-to-live=15000")
 				.run((context) -> {
@@ -286,14 +286,14 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void redisCacheWithCustomizers() {
+	void redisCacheWithCustomizers() {
 		this.contextRunner.withUserConfiguration(RedisWithCustomizersConfiguration.class)
 				.withPropertyValues("spring.cache.type=redis")
 				.run(verifyCustomizers("allCacheManagerCustomizer", "redisCacheManagerCustomizer"));
 	}
 
 	@Test
-	public void redisCacheExplicitWithCaches() {
+	void redisCacheExplicitWithCaches() {
 		this.contextRunner.withUserConfiguration(RedisConfiguration.class).withPropertyValues("spring.cache.type=redis",
 				"spring.cache.cacheNames[0]=foo", "spring.cache.cacheNames[1]=bar").run((context) -> {
 					RedisCacheManager cacheManager = getCacheManager(context, RedisCacheManager.class);
@@ -307,7 +307,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void noOpCacheExplicit() {
+	void noOpCacheExplicit() {
 		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=none").run((context) -> {
 					NoOpCacheManager cacheManager = getCacheManager(context, NoOpCacheManager.class);
@@ -316,7 +316,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void jCacheCacheNoProviderExplicit() {
+	void jCacheCacheNoProviderExplicit() {
 		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=jcache")
 				.run((context) -> assertThat(context).getFailure().isInstanceOf(BeanCreationException.class)
@@ -325,7 +325,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void jCacheCacheWithProvider() {
+	void jCacheCacheWithProvider() {
 		String cachingProviderFqn = MockCachingProvider.class.getName();
 		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=jcache", "spring.cache.jcache.provider=" + cachingProviderFqn)
@@ -338,7 +338,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void jCacheCacheWithCaches() {
+	void jCacheCacheWithCaches() {
 		String cachingProviderFqn = MockCachingProvider.class.getName();
 		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=jcache", "spring.cache.jcache.provider=" + cachingProviderFqn,
@@ -350,7 +350,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void jCacheCacheWithCachesAndCustomConfig() {
+	void jCacheCacheWithCachesAndCustomConfig() {
 		String cachingProviderFqn = MockCachingProvider.class.getName();
 		this.contextRunner.withUserConfiguration(JCacheCustomConfiguration.class)
 				.withPropertyValues("spring.cache.type=jcache", "spring.cache.jcache.provider=" + cachingProviderFqn,
@@ -366,7 +366,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void jCacheCacheWithExistingJCacheManager() {
+	void jCacheCacheWithExistingJCacheManager() {
 		this.contextRunner.withUserConfiguration(JCacheCustomCacheManager.class)
 				.withPropertyValues("spring.cache.type=jcache").run((context) -> {
 					JCacheCacheManager cacheManager = getCacheManager(context, JCacheCacheManager.class);
@@ -375,7 +375,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void jCacheCacheWithUnknownProvider() {
+	void jCacheCacheWithUnknownProvider() {
 		String wrongCachingProviderClassName = "org.acme.FooBar";
 		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=jcache",
@@ -385,7 +385,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void jCacheCacheWithConfig() {
+	void jCacheCacheWithConfig() {
 		String cachingProviderFqn = MockCachingProvider.class.getName();
 		String configLocation = "org/springframework/boot/autoconfigure/hazelcast/hazelcast-specific.xml";
 		this.contextRunner.withUserConfiguration(JCacheCustomConfiguration.class)
@@ -399,7 +399,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void jCacheCacheWithWrongConfig() {
+	void jCacheCacheWithWrongConfig() {
 		String cachingProviderFqn = MockCachingProvider.class.getName();
 		String configLocation = "org/springframework/boot/autoconfigure/cache/does-not-exist.xml";
 		this.contextRunner.withUserConfiguration(JCacheCustomConfiguration.class)
@@ -410,7 +410,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void jCacheCacheUseBeanClassLoader() {
+	void jCacheCacheUseBeanClassLoader() {
 		String cachingProviderFqn = MockCachingProvider.class.getName();
 		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=jcache", "spring.cache.jcache.provider=" + cachingProviderFqn)
@@ -421,7 +421,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void hazelcastCacheExplicit() {
+	void hazelcastCacheExplicit() {
 		this.contextRunner.withConfiguration(AutoConfigurations.of(HazelcastAutoConfiguration.class))
 				.withUserConfiguration(DefaultCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=hazelcast").run((context) -> {
@@ -435,14 +435,14 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void hazelcastCacheWithCustomizers() {
+	void hazelcastCacheWithCustomizers() {
 		this.contextRunner.withUserConfiguration(HazelcastCacheAndCustomizersConfiguration.class)
 				.withPropertyValues("spring.cache.type=hazelcast")
 				.run(verifyCustomizers("allCacheManagerCustomizer", "hazelcastCacheManagerCustomizer"));
 	}
 
 	@Test
-	public void hazelcastCacheWithExistingHazelcastInstance() {
+	void hazelcastCacheWithExistingHazelcastInstance() {
 		this.contextRunner.withUserConfiguration(HazelcastCustomHazelcastInstance.class)
 				.withPropertyValues("spring.cache.type=hazelcast").run((context) -> {
 					HazelcastCacheManager cacheManager = getCacheManager(context, HazelcastCacheManager.class);
@@ -452,7 +452,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void hazelcastCacheWithHazelcastAutoConfiguration() {
+	void hazelcastCacheWithHazelcastAutoConfiguration() {
 		String hazelcastConfig = "org/springframework/boot/autoconfigure/hazelcast/hazelcast-specific.xml";
 		this.contextRunner.withConfiguration(AutoConfigurations.of(HazelcastAutoConfiguration.class))
 				.withUserConfiguration(DefaultCacheConfiguration.class)
@@ -469,7 +469,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void hazelcastAsJCacheWithCaches() {
+	void hazelcastAsJCacheWithCaches() {
 		String cachingProviderFqn = HazelcastCachingProvider.class.getName();
 		try {
 			this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
@@ -488,7 +488,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void hazelcastAsJCacheWithConfig() {
+	void hazelcastAsJCacheWithConfig() {
 		String cachingProviderFqn = HazelcastCachingProvider.class.getName();
 		try {
 			String configLocation = "org/springframework/boot/autoconfigure/hazelcast/hazelcast-specific.xml";
@@ -509,7 +509,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void hazelcastAsJCacheWithExistingHazelcastInstance() {
+	void hazelcastAsJCacheWithExistingHazelcastInstance() {
 		String cachingProviderFqn = HazelcastCachingProvider.class.getName();
 		this.contextRunner.withConfiguration(AutoConfigurations.of(HazelcastAutoConfiguration.class))
 				.withUserConfiguration(DefaultCacheConfiguration.class)
@@ -528,7 +528,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void infinispanCacheWithConfig() {
+	void infinispanCacheWithConfig() {
 		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=infinispan", "spring.cache.infinispan.config=infinispan.xml")
 				.run((context) -> {
@@ -539,14 +539,14 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void infinispanCacheWithCustomizers() {
+	void infinispanCacheWithCustomizers() {
 		this.contextRunner.withUserConfiguration(DefaultCacheAndCustomizersConfiguration.class)
 				.withPropertyValues("spring.cache.type=infinispan")
 				.run(verifyCustomizers("allCacheManagerCustomizer", "infinispanCacheManagerCustomizer"));
 	}
 
 	@Test
-	public void infinispanCacheWithCaches() {
+	void infinispanCacheWithCaches() {
 		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=infinispan", "spring.cache.cacheNames[0]=foo",
 						"spring.cache.cacheNames[1]=bar")
@@ -555,7 +555,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void infinispanCacheWithCachesAndCustomConfig() {
+	void infinispanCacheWithCachesAndCustomConfig() {
 		this.contextRunner.withUserConfiguration(InfinispanCustomConfiguration.class)
 				.withPropertyValues("spring.cache.type=infinispan", "spring.cache.cacheNames[0]=foo",
 						"spring.cache.cacheNames[1]=bar")
@@ -567,7 +567,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void infinispanAsJCacheWithCaches() {
+	void infinispanAsJCacheWithCaches() {
 		String cachingProviderClassName = JCachingProvider.class.getName();
 		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=jcache",
@@ -578,7 +578,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void infinispanAsJCacheWithConfig() {
+	void infinispanAsJCacheWithConfig() {
 		String cachingProviderClassName = JCachingProvider.class.getName();
 		String configLocation = "infinispan.xml";
 		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
@@ -593,7 +593,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void jCacheCacheWithCachesAndCustomizer() {
+	void jCacheCacheWithCachesAndCustomizer() {
 		String cachingProviderClassName = HazelcastCachingProvider.class.getName();
 		try {
 			this.contextRunner.withUserConfiguration(JCacheWithCustomizerConfiguration.class)
@@ -611,7 +611,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void caffeineCacheWithExplicitCaches() {
+	void caffeineCacheWithExplicitCaches() {
 		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=caffeine", "spring.cache.cacheNames=foo").run((context) -> {
 					CaffeineCacheManager manager = getCacheManager(context, CaffeineCacheManager.class);
@@ -624,21 +624,21 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void caffeineCacheWithCustomizers() {
+	void caffeineCacheWithCustomizers() {
 		this.contextRunner.withUserConfiguration(DefaultCacheAndCustomizersConfiguration.class)
 				.withPropertyValues("spring.cache.type=caffeine")
 				.run(verifyCustomizers("allCacheManagerCustomizer", "caffeineCacheManagerCustomizer"));
 	}
 
 	@Test
-	public void caffeineCacheWithExplicitCacheBuilder() {
+	void caffeineCacheWithExplicitCacheBuilder() {
 		this.contextRunner.withUserConfiguration(CaffeineCacheBuilderConfiguration.class)
 				.withPropertyValues("spring.cache.type=caffeine", "spring.cache.cacheNames=foo,bar")
 				.run(this::validateCaffeineCacheWithStats);
 	}
 
 	@Test
-	public void caffeineCacheExplicitWithSpec() {
+	void caffeineCacheExplicitWithSpec() {
 		this.contextRunner.withUserConfiguration(CaffeineCacheSpecConfiguration.class)
 				.withPropertyValues("spring.cache.type=caffeine", "spring.cache.cacheNames[0]=foo",
 						"spring.cache.cacheNames[1]=bar")
@@ -646,7 +646,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void caffeineCacheExplicitWithSpecString() {
+	void caffeineCacheExplicitWithSpecString() {
 		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=caffeine", "spring.cache.caffeine.spec=recordStats",
 						"spring.cache.cacheNames[0]=foo", "spring.cache.cacheNames[1]=bar")
@@ -654,7 +654,7 @@ public class CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationT
 	}
 
 	@Test
-	public void autoConfiguredCacheManagerCanBeSwapped() {
+	void autoConfiguredCacheManagerCanBeSwapped() {
 		this.contextRunner.withUserConfiguration(CacheManagerPostProcessorConfiguration.class)
 				.withPropertyValues("spring.cache.type=caffeine").run((context) -> {
 					getCacheManager(context, SimpleCacheManager.class);

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/cache/EhCache2CacheAutoConfigurationTests.java

@@ -16,8 +16,8 @@
 
 package org.springframework.boot.autoconfigure.cache;
 
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 import org.springframework.boot.autoconfigure.cache.CacheAutoConfigurationTests.DefaultCacheAndCustomizersConfiguration;
@@ -25,7 +25,7 @@ import org.springframework.boot.autoconfigure.cache.CacheAutoConfigurationTests.
 import org.springframework.boot.autoconfigure.cache.CacheAutoConfigurationTests.EhCacheCustomCacheManager;
 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.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
 import org.springframework.cache.ehcache.EhCacheCacheManager;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -36,15 +36,15 @@ import static org.assertj.core.api.Assertions.assertThat;
  * @author Stephane Nicoll
  * @author Andy Wilkinson
  */
-@RunWith(ModifiedClassPathRunner.class)
+@ExtendWith(ModifiedClassPathExtension.class)
 @ClassPathExclusions("ehcache-3*.jar")
-public class EhCache2CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
+class EhCache2CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
 
 	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
 			.withConfiguration(AutoConfigurations.of(CacheAutoConfiguration.class));
 
 	@Test
-	public void ehCacheWithCaches() {
+	void ehCacheWithCaches() {
 		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=ehcache").run((context) -> {
 					EhCacheCacheManager cacheManager = getCacheManager(context, EhCacheCacheManager.class);
@@ -55,14 +55,14 @@ public class EhCache2CacheAutoConfigurationTests extends AbstractCacheAutoConfig
 	}
 
 	@Test
-	public void ehCacheWithCustomizers() {
+	void ehCacheWithCustomizers() {
 		this.contextRunner.withUserConfiguration(DefaultCacheAndCustomizersConfiguration.class)
 				.withPropertyValues("spring.cache.type=ehcache")
 				.run(verifyCustomizers("allCacheManagerCustomizer", "ehcacheCacheManagerCustomizer"));
 	}
 
 	@Test
-	public void ehCacheWithConfig() {
+	void ehCacheWithConfig() {
 		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=ehcache",
 						"spring.cache.ehcache.config=cache/ehcache-override.xml")
@@ -73,7 +73,7 @@ public class EhCache2CacheAutoConfigurationTests extends AbstractCacheAutoConfig
 	}
 
 	@Test
-	public void ehCacheWithExistingCacheManager() {
+	void ehCacheWithExistingCacheManager() {
 		this.contextRunner.withUserConfiguration(EhCacheCustomCacheManager.class)
 				.withPropertyValues("spring.cache.type=ehcache").run((context) -> {
 					EhCacheCacheManager cacheManager = getCacheManager(context, EhCacheCacheManager.class);

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/cache/EhCache3CacheAutoConfigurationTests.java

@@ -17,12 +17,12 @@
 package org.springframework.boot.autoconfigure.cache;
 
 import org.ehcache.jsr107.EhcacheCachingProvider;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
 import org.springframework.boot.autoconfigure.cache.CacheAutoConfigurationTests.DefaultCacheConfiguration;
 import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
-import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
+import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
 import org.springframework.cache.jcache.JCacheCacheManager;
 import org.springframework.core.io.ClassPathResource;
 import org.springframework.core.io.Resource;
@@ -35,12 +35,12 @@ import static org.assertj.core.api.Assertions.assertThat;
  * @author Stephane Nicoll
  * @author Andy Wilkinson
  */
-@RunWith(ModifiedClassPathRunner.class)
+@ExtendWith(ModifiedClassPathExtension.class)
 @ClassPathExclusions("ehcache-2*.jar")
-public class EhCache3CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
+class EhCache3CacheAutoConfigurationTests extends AbstractCacheAutoConfigurationTests {
 
 	@Test
-	public void ehcache3AsJCacheWithCaches() {
+	void ehcache3AsJCacheWithCaches() {
 		String cachingProviderFqn = EhcacheCachingProvider.class.getName();
 		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
 				.withPropertyValues("spring.cache.type=jcache", "spring.cache.jcache.provider=" + cachingProviderFqn,
@@ -52,7 +52,7 @@ public class EhCache3CacheAutoConfigurationTests extends AbstractCacheAutoConfig
 	}
 
 	@Test
-	public void ehcache3AsJCacheWithConfig() {
+	void ehcache3AsJCacheWithConfig() {
 		String cachingProviderFqn = EhcacheCachingProvider.class.getName();
 		String configLocation = "ehcache3.xml";
 		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)

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

@@ -16,12 +16,12 @@
 
 package org.springframework.boot.autoconfigure.condition;
 
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
 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.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
 import org.springframework.cache.caffeine.CaffeineCacheManager;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -35,15 +35,15 @@ import static org.assertj.core.api.Assertions.assertThat;
  * @author Stephane Nicoll
  * @author Andy Wilkinson
  */
-@RunWith(ModifiedClassPathRunner.class)
+@ExtendWith(ModifiedClassPathExtension.class)
 @ClassPathExclusions("spring-context-support-*.jar")
-public class ConditionalOnMissingBeanWithFilteredClasspathTests {
+class ConditionalOnMissingBeanWithFilteredClasspathTests {
 
 	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
 			.withUserConfiguration(OnBeanTypeConfiguration.class);
 
 	@Test
-	public void testNameOnMissingBeanTypeWithMissingImport() {
+	void testNameOnMissingBeanTypeWithMissingImport() {
 		this.contextRunner.run((context) -> assertThat(context).hasBean("foo"));
 	}
 

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

@@ -17,12 +17,12 @@
 package org.springframework.boot.autoconfigure.condition;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
 import org.springframework.boot.autoconfigure.condition.OnBeanCondition.BeanTypeDeductionException;
 import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
-import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
+import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -38,12 +38,12 @@ import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
  *
  * @author Andy Wilkinson
  */
-@RunWith(ModifiedClassPathRunner.class)
+@ExtendWith(ModifiedClassPathExtension.class)
 @ClassPathExclusions("jackson-core-*.jar")
-public class OnBeanConditionTypeDeductionFailureTests {
+class OnBeanConditionTypeDeductionFailureTests {
 
 	@Test
-	public void conditionalOnMissingBeanWithDeducedTypeThatIsPartiallyMissingFromClassPath() {
+	void conditionalOnMissingBeanWithDeducedTypeThatIsPartiallyMissingFromClassPath() {
 		assertThatExceptionOfType(Exception.class)
 				.isThrownBy(() -> new AnnotationConfigApplicationContext(ImportingConfiguration.class).close())
 				.satisfies((ex) -> {

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/data/redis/RedisAutoConfigurationJedisTests.java

@@ -16,15 +16,15 @@
 
 package org.springframework.boot.autoconfigure.data.redis;
 
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
 import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.config.BeanPostProcessor;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 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.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.data.redis.connection.jedis.JedisClientConfiguration.JedisClientConfigurationBuilder;
@@ -38,15 +38,15 @@ import static org.assertj.core.api.Assertions.assertThat;
  * @author Mark Paluch
  * @author Stephane Nicoll
  */
-@RunWith(ModifiedClassPathRunner.class)
+@ExtendWith(ModifiedClassPathExtension.class)
 @ClassPathExclusions("lettuce-core-*.jar")
-public class RedisAutoConfigurationJedisTests {
+class RedisAutoConfigurationJedisTests {
 
 	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
 			.withConfiguration(AutoConfigurations.of(RedisAutoConfiguration.class));
 
 	@Test
-	public void testOverrideRedisConfiguration() {
+	void testOverrideRedisConfiguration() {
 		this.contextRunner.withPropertyValues("spring.redis.host:foo", "spring.redis.database:1").run((context) -> {
 			JedisConnectionFactory cf = context.getBean(JedisConnectionFactory.class);
 			assertThat(cf.getHostName()).isEqualTo("foo");
@@ -57,7 +57,7 @@ public class RedisAutoConfigurationJedisTests {
 	}
 
 	@Test
-	public void testCustomizeRedisConfiguration() {
+	void testCustomizeRedisConfiguration() {
 		this.contextRunner.withUserConfiguration(CustomConfiguration.class).run((context) -> {
 			JedisConnectionFactory cf = context.getBean(JedisConnectionFactory.class);
 			assertThat(cf.isUseSsl()).isTrue();
@@ -65,7 +65,7 @@ public class RedisAutoConfigurationJedisTests {
 	}
 
 	@Test
-	public void testRedisUrlConfiguration() {
+	void testRedisUrlConfiguration() {
 		this.contextRunner
 				.withPropertyValues("spring.redis.host:foo", "spring.redis.url:redis://user:password@example:33")
 				.run((context) -> {
@@ -78,7 +78,7 @@ public class RedisAutoConfigurationJedisTests {
 	}
 
 	@Test
-	public void testOverrideUrlRedisConfiguration() {
+	void testOverrideUrlRedisConfiguration() {
 		this.contextRunner
 				.withPropertyValues("spring.redis.host:foo", "spring.redis.password:xyz", "spring.redis.port:1000",
 						"spring.redis.ssl:false", "spring.redis.url:rediss://user:password@example:33")
@@ -92,7 +92,7 @@ public class RedisAutoConfigurationJedisTests {
 	}
 
 	@Test
-	public void testPasswordInUrlWithColon() {
+	void testPasswordInUrlWithColon() {
 		this.contextRunner.withPropertyValues("spring.redis.url:redis://:pass:word@example:33").run((context) -> {
 			assertThat(context.getBean(JedisConnectionFactory.class).getHostName()).isEqualTo("example");
 			assertThat(context.getBean(JedisConnectionFactory.class).getPort()).isEqualTo(33);
@@ -101,7 +101,7 @@ public class RedisAutoConfigurationJedisTests {
 	}
 
 	@Test
-	public void testPasswordInUrlStartsWithColon() {
+	void testPasswordInUrlStartsWithColon() {
 		this.contextRunner.withPropertyValues("spring.redis.url:redis://user::pass:word@example:33").run((context) -> {
 			assertThat(context.getBean(JedisConnectionFactory.class).getHostName()).isEqualTo("example");
 			assertThat(context.getBean(JedisConnectionFactory.class).getPort()).isEqualTo(33);
@@ -110,7 +110,7 @@ public class RedisAutoConfigurationJedisTests {
 	}
 
 	@Test
-	public void testRedisConfigurationWithPool() {
+	void testRedisConfigurationWithPool() {
 		this.contextRunner.withPropertyValues("spring.redis.host:foo", "spring.redis.jedis.pool.min-idle:1",
 				"spring.redis.jedis.pool.max-idle:4", "spring.redis.jedis.pool.max-active:16",
 				"spring.redis.jedis.pool.max-wait:2000", "spring.redis.jedis.pool.time-between-eviction-runs:30000")
@@ -126,7 +126,7 @@ public class RedisAutoConfigurationJedisTests {
 	}
 
 	@Test
-	public void testRedisConfigurationWithTimeout() {
+	void testRedisConfigurationWithTimeout() {
 		this.contextRunner.withPropertyValues("spring.redis.host:foo", "spring.redis.timeout:100").run((context) -> {
 			JedisConnectionFactory cf = context.getBean(JedisConnectionFactory.class);
 			assertThat(cf.getHostName()).isEqualTo("foo");
@@ -135,7 +135,7 @@ public class RedisAutoConfigurationJedisTests {
 	}
 
 	@Test
-	public void testRedisConfigurationWithClientName() {
+	void testRedisConfigurationWithClientName() {
 		this.contextRunner.withPropertyValues("spring.redis.host:foo", "spring.redis.client-name:spring-boot")
 				.run((context) -> {
 					JedisConnectionFactory cf = context.getBean(JedisConnectionFactory.class);
@@ -145,7 +145,7 @@ public class RedisAutoConfigurationJedisTests {
 	}
 
 	@Test
-	public void testRedisConfigurationWithSentinel() {
+	void testRedisConfigurationWithSentinel() {
 		this.contextRunner
 				.withPropertyValues("spring.redis.sentinel.master:mymaster",
 						"spring.redis.sentinel.nodes:127.0.0.1:26379,127.0.0.1:26380")
@@ -156,7 +156,7 @@ public class RedisAutoConfigurationJedisTests {
 	}
 
 	@Test
-	public void testRedisConfigurationWithSentinelAndPassword() {
+	void testRedisConfigurationWithSentinelAndPassword() {
 		this.contextRunner
 				.withPropertyValues("spring.redis.password=password", "spring.redis.sentinel.master:mymaster",
 						"spring.redis.sentinel.nodes:127.0.0.1:26379,127.0.0.1:26380")
@@ -168,7 +168,7 @@ public class RedisAutoConfigurationJedisTests {
 	}
 
 	@Test
-	public void testRedisConfigurationWithCluster() {
+	void testRedisConfigurationWithCluster() {
 		this.contextRunner.withPropertyValues("spring.redis.cluster.nodes=127.0.0.1:27379,127.0.0.1:27380")
 				.run((context) -> assertThat(context.getBean(JedisConnectionFactory.class).getClusterConnection())
 						.isNotNull());

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/hateoas/HypermediaAutoConfigurationWithoutJacksonTests.java

@@ -16,14 +16,14 @@
 
 package org.springframework.boot.autoconfigure.hateoas;
 
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
 import org.springframework.boot.autoconfigure.ImportAutoConfiguration;
 import org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration;
 import org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration;
 import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
-import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
+import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
 import org.springframework.boot.web.servlet.context.AnnotationConfigServletWebApplicationContext;
 import org.springframework.mock.web.MockServletContext;
 
@@ -32,14 +32,14 @@ import org.springframework.mock.web.MockServletContext;
  *
  * @author Andy Wilkinson
  */
-@RunWith(ModifiedClassPathRunner.class)
+@ExtendWith(ModifiedClassPathExtension.class)
 @ClassPathExclusions("jackson-*.jar")
-public class HypermediaAutoConfigurationWithoutJacksonTests {
+class HypermediaAutoConfigurationWithoutJacksonTests {
 
 	private AnnotationConfigServletWebApplicationContext context;
 
 	@Test
-	public void jacksonRelatedConfigurationBacksOff() {
+	void jacksonRelatedConfigurationBacksOff() {
 		this.context = new AnnotationConfigServletWebApplicationContext();
 		this.context.register(BaseConfig.class);
 		this.context.setServletContext(new MockServletContext());

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

@@ -22,8 +22,8 @@ import com.hazelcast.config.Config;
 import com.hazelcast.config.QueueConfig;
 import com.hazelcast.core.Hazelcast;
 import com.hazelcast.core.HazelcastInstance;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
 import org.springframework.beans.factory.BeanCreationException;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
@@ -31,7 +31,7 @@ import org.springframework.boot.test.context.assertj.AssertableApplicationContex
 import org.springframework.boot.test.context.runner.ApplicationContextRunner;
 import org.springframework.boot.test.context.runner.ContextConsumer;
 import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
-import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
+import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.io.ClassPathResource;
@@ -43,15 +43,15 @@ import static org.assertj.core.api.Assertions.assertThat;
  *
  * @author Stephane Nicoll
  */
-@RunWith(ModifiedClassPathRunner.class)
+@ExtendWith(ModifiedClassPathExtension.class)
 @ClassPathExclusions("hazelcast-client-*.jar")
-public class HazelcastAutoConfigurationServerTests {
+class HazelcastAutoConfigurationServerTests {
 
 	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
 			.withConfiguration(AutoConfigurations.of(HazelcastAutoConfiguration.class));
 
 	@Test
-	public void defaultConfigFile() {
+	void defaultConfigFile() {
 		// hazelcast.xml present in root classpath
 		this.contextRunner.run((context) -> {
 			Config config = context.getBean(HazelcastInstance.class).getConfig();
@@ -60,7 +60,7 @@ public class HazelcastAutoConfigurationServerTests {
 	}
 
 	@Test
-	public void systemPropertyWithXml() {
+	void systemPropertyWithXml() {
 		this.contextRunner
 				.withSystemProperties(HazelcastServerConfiguration.CONFIG_SYSTEM_PROPERTY
 						+ "=classpath:org/springframework/boot/autoconfigure/hazelcast/hazelcast-specific.xml")
@@ -71,7 +71,7 @@ public class HazelcastAutoConfigurationServerTests {
 	}
 
 	@Test
-	public void systemPropertyWithYaml() {
+	void systemPropertyWithYaml() {
 		this.contextRunner
 				.withSystemProperties(HazelcastServerConfiguration.CONFIG_SYSTEM_PROPERTY
 						+ "=classpath:org/springframework/boot/autoconfigure/hazelcast/hazelcast-specific.yaml")
@@ -82,7 +82,7 @@ public class HazelcastAutoConfigurationServerTests {
 	}
 
 	@Test
-	public void explicitConfigFileWithXml() {
+	void explicitConfigFileWithXml() {
 		this.contextRunner
 				.withPropertyValues("spring.hazelcast.config=org/springframework/boot/autoconfigure/hazelcast/"
 						+ "hazelcast-specific.xml")
@@ -91,7 +91,7 @@ public class HazelcastAutoConfigurationServerTests {
 	}
 
 	@Test
-	public void explicitConfigFileWithYaml() {
+	void explicitConfigFileWithYaml() {
 		this.contextRunner
 				.withPropertyValues("spring.hazelcast.config=org/springframework/boot/autoconfigure/hazelcast/"
 						+ "hazelcast-specific.yaml")
@@ -100,7 +100,7 @@ public class HazelcastAutoConfigurationServerTests {
 	}
 
 	@Test
-	public void explicitConfigUrlWithXml() {
+	void explicitConfigUrlWithXml() {
 		this.contextRunner
 				.withPropertyValues("spring.hazelcast.config=classpath:org/springframework/"
 						+ "boot/autoconfigure/hazelcast/hazelcast-specific.xml")
@@ -109,7 +109,7 @@ public class HazelcastAutoConfigurationServerTests {
 	}
 
 	@Test
-	public void explicitConfigUrlWithYaml() {
+	void explicitConfigUrlWithYaml() {
 		this.contextRunner
 				.withPropertyValues("spring.hazelcast.config=classpath:org/springframework/"
 						+ "boot/autoconfigure/hazelcast/hazelcast-specific.yaml")
@@ -125,14 +125,14 @@ public class HazelcastAutoConfigurationServerTests {
 	}
 
 	@Test
-	public void unknownConfigFile() {
+	void unknownConfigFile() {
 		this.contextRunner.withPropertyValues("spring.hazelcast.config=foo/bar/unknown.xml")
 				.run((context) -> assertThat(context).getFailure().isInstanceOf(BeanCreationException.class)
 						.hasMessageContaining("foo/bar/unknown.xml"));
 	}
 
 	@Test
-	public void configInstanceWithName() {
+	void configInstanceWithName() {
 		Config config = new Config("my-test-instance");
 		HazelcastInstance existing = Hazelcast.newHazelcastInstance(config);
 		try {
@@ -150,7 +150,7 @@ public class HazelcastAutoConfigurationServerTests {
 	}
 
 	@Test
-	public void configInstanceWithoutName() {
+	void configInstanceWithoutName() {
 		this.contextRunner.withUserConfiguration(HazelcastConfigNoName.class)
 				.withPropertyValues("spring.hazelcast.config=this-is-ignored.xml").run((context) -> {
 					Config config = context.getBean(HazelcastInstance.class).getConfig();

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/http/HttpMessageConvertersAutoConfigurationWithoutJacksonTests.java

@@ -16,13 +16,13 @@
 
 package org.springframework.boot.autoconfigure.http;
 
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 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.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -32,15 +32,15 @@ import static org.assertj.core.api.Assertions.assertThat;
  *
  * @author Andy Wilkinson
  */
-@RunWith(ModifiedClassPathRunner.class)
+@ExtendWith(ModifiedClassPathExtension.class)
 @ClassPathExclusions("jackson-*.jar")
-public class HttpMessageConvertersAutoConfigurationWithoutJacksonTests {
+class HttpMessageConvertersAutoConfigurationWithoutJacksonTests {
 
 	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
 			.withConfiguration(AutoConfigurations.of(HttpMessageConvertersAutoConfiguration.class));
 
 	@Test
-	public void autoConfigurationWorksWithSpringHateoasButWithoutJackson() {
+	void autoConfigurationWorksWithSpringHateoasButWithoutJackson() {
 		this.contextRunner.run((context) -> assertThat(context).hasSingleBean(HttpMessageConverters.class));
 	}
 

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

@@ -16,14 +16,14 @@
 
 package org.springframework.boot.autoconfigure.jdbc;
 
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
 import org.springframework.beans.factory.BeanCreationException;
 import org.springframework.boot.autoconfigure.ImportAutoConfiguration;
 import org.springframework.boot.diagnostics.FailureAnalysis;
 import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
-import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
+import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.mock.env.MockEnvironment;
@@ -36,14 +36,14 @@ import static org.assertj.core.api.Assertions.assertThat;
  * @author Andy Wilkinson
  * @author Stephane Nicoll
  */
-@RunWith(ModifiedClassPathRunner.class)
+@ExtendWith(ModifiedClassPathExtension.class)
 @ClassPathExclusions({ "h2-*.jar", "hsqldb-*.jar" })
-public class DataSourceBeanCreationFailureAnalyzerTests {
+class DataSourceBeanCreationFailureAnalyzerTests {
 
 	private final MockEnvironment environment = new MockEnvironment();
 
 	@Test
-	public void failureAnalysisIsPerformed() {
+	void failureAnalysisIsPerformed() {
 		FailureAnalysis failureAnalysis = performAnalysis(TestConfiguration.class);
 		assertThat(failureAnalysis.getDescription()).contains("'url' attribute is not specified",
 				"no embedded datasource could be configured", "Failed to determine a suitable driver class");
@@ -54,7 +54,7 @@ public class DataSourceBeanCreationFailureAnalyzerTests {
 	}
 
 	@Test
-	public void failureAnalysisIsPerformedWithActiveProfiles() {
+	void failureAnalysisIsPerformedWithActiveProfiles() {
 		this.environment.setActiveProfiles("first", "second");
 		FailureAnalysis failureAnalysis = performAnalysis(TestConfiguration.class);
 		assertThat(failureAnalysis.getAction()).contains("(the profiles first,second are currently active)");

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jsonb/JsonbAutoConfigurationWithNoProviderTests.java

@@ -18,13 +18,13 @@ package org.springframework.boot.autoconfigure.jsonb;
 
 import javax.json.bind.Jsonb;
 
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 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.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -33,15 +33,15 @@ import static org.assertj.core.api.Assertions.assertThat;
  *
  * @author Andy Wilkinson
  */
-@RunWith(ModifiedClassPathRunner.class)
+@ExtendWith(ModifiedClassPathExtension.class)
 @ClassPathExclusions("johnzon-jsonb-*.jar")
-public class JsonbAutoConfigurationWithNoProviderTests {
+class JsonbAutoConfigurationWithNoProviderTests {
 
 	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
 			.withConfiguration(AutoConfigurations.of(JsonbAutoConfiguration.class));
 
 	@Test
-	public void jsonbBacksOffWhenThereIsNoProvider() {
+	void jsonbBacksOffWhenThereIsNoProvider() {
 		this.contextRunner.run((context) -> assertThat(context).doesNotHaveBean(Jsonb.class));
 	}
 

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

@@ -17,15 +17,15 @@
 package org.springframework.boot.autoconfigure.orm.jpa;
 
 import org.ehcache.jsr107.EhcacheCachingProvider;
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 import org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration;
 import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
 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.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
 import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Configuration;
 
@@ -36,9 +36,9 @@ import static org.assertj.core.api.Assertions.assertThat;
  *
  * @author Stephane Nicoll
  */
-@RunWith(ModifiedClassPathRunner.class)
+@ExtendWith(ModifiedClassPathExtension.class)
 @ClassPathExclusions("ehcache-2*.jar")
-public class Hibernate2ndLevelCacheIntegrationTests {
+class Hibernate2ndLevelCacheIntegrationTests {
 
 	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
 			.withConfiguration(AutoConfigurations.of(CacheAutoConfiguration.class, DataSourceAutoConfiguration.class,
@@ -47,7 +47,7 @@ public class Hibernate2ndLevelCacheIntegrationTests {
 			.withUserConfiguration(TestConfiguration.class);
 
 	@Test
-	public void hibernate2ndLevelCacheWithJCacheAndEhCache3() {
+	void hibernate2ndLevelCacheWithJCacheAndEhCache3() {
 		String cachingProviderFqn = EhcacheCachingProvider.class.getName();
 		String configLocation = "ehcache3.xml";
 		this.contextRunner

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/session/SessionAutoConfigurationWithoutSecurityTests.java

@@ -16,13 +16,13 @@
 
 package org.springframework.boot.autoconfigure.session;
 
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 import org.springframework.boot.test.context.runner.WebApplicationContextRunner;
 import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
-import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
+import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
 import org.springframework.session.web.http.DefaultCookieSerializer;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -33,15 +33,15 @@ import static org.assertj.core.api.Assertions.assertThat;
  *
  * @author Vedran Pavic
  */
-@RunWith(ModifiedClassPathRunner.class)
+@ExtendWith(ModifiedClassPathExtension.class)
 @ClassPathExclusions("spring-security-*")
-public class SessionAutoConfigurationWithoutSecurityTests extends AbstractSessionAutoConfigurationTests {
+class SessionAutoConfigurationWithoutSecurityTests extends AbstractSessionAutoConfigurationTests {
 
 	private final WebApplicationContextRunner contextRunner = new WebApplicationContextRunner()
 			.withConfiguration(AutoConfigurations.of(SessionAutoConfiguration.class));
 
 	@Test
-	public void sessionCookieConfigurationIsAppliedToAutoConfiguredCookieSerializer() {
+	void sessionCookieConfigurationIsAppliedToAutoConfiguredCookieSerializer() {
 		this.contextRunner.withUserConfiguration(SessionRepositoryConfiguration.class).run((context) -> {
 			DefaultCookieSerializer cookieSerializer = context.getBean(DefaultCookieSerializer.class);
 			assertThat(cookieSerializer).hasFieldOrPropertyWithValue("rememberMeRequestAttribute", null);

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/validation/ValidationAutoConfigurationWithHibernateValidatorMissingElImplTests.java

@@ -18,13 +18,13 @@ package org.springframework.boot.autoconfigure.validation;
 
 import javax.validation.Validator;
 
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 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.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
 import org.springframework.validation.beanvalidation.MethodValidationPostProcessor;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -35,15 +35,15 @@ import static org.assertj.core.api.Assertions.assertThat;
  *
  * @author Stephane Nicoll
  */
-@RunWith(ModifiedClassPathRunner.class)
+@ExtendWith(ModifiedClassPathExtension.class)
 @ClassPathExclusions({ "tomcat-embed-el-*.jar", "el-api-*.jar" })
-public class ValidationAutoConfigurationWithHibernateValidatorMissingElImplTests {
+class ValidationAutoConfigurationWithHibernateValidatorMissingElImplTests {
 
 	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
 			.withConfiguration(AutoConfigurations.of(ValidationAutoConfiguration.class));
 
 	@Test
-	public void missingElDependencyIsTolerated() {
+	void missingElDependencyIsTolerated() {
 		this.contextRunner.run((context) -> {
 			assertThat(context).hasSingleBean(Validator.class);
 			assertThat(context).hasSingleBean(MethodValidationPostProcessor.class);

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/validation/ValidationAutoConfigurationWithoutValidatorTests.java

@@ -18,13 +18,13 @@ package org.springframework.boot.autoconfigure.validation;
 
 import javax.validation.Validator;
 
-import org.junit.Test;
-import org.junit.runner.RunWith;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 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.boot.testsupport.runner.classpath.ModifiedClassPathExtension;
 import org.springframework.validation.beanvalidation.MethodValidationPostProcessor;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -34,15 +34,15 @@ import static org.assertj.core.api.Assertions.assertThat;
  *
  * @author Stephane Nicoll
  */
-@RunWith(ModifiedClassPathRunner.class)
+@ExtendWith(ModifiedClassPathExtension.class)
 @ClassPathExclusions("hibernate-validator-*.jar")
-public class ValidationAutoConfigurationWithoutValidatorTests {
+class ValidationAutoConfigurationWithoutValidatorTests {
 
 	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
 			.withConfiguration(AutoConfigurations.of(ValidationAutoConfiguration.class));
 
 	@Test
-	public void validationIsDisabled() {
+	void validationIsDisabled() {
 		this.contextRunner.run((context) -> {
 			assertThat(context).doesNotHaveBean(Validator.class);
 			assertThat(context).doesNotHaveBean(MethodValidationPostProcessor.class);