Use AssertJ in spring-boot-devtools

See gh-5083

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/RemoteUrlPropertyExtractorTests.java

@@ -27,10 +27,7 @@ import org.springframework.boot.SpringApplication;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.annotation.Configuration;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link RemoteUrlPropertyExtractor}.
@@ -73,17 +70,17 @@ public class RemoteUrlPropertyExtractorTests {
 	@Test
 	public void validUrl() throws Exception {
 		ApplicationContext context = doTest("http://localhost:8080");
-		assertThat(context.getEnvironment().getProperty("remoteUrl"),
-				equalTo("http://localhost:8080"));
-		assertThat(context.getEnvironment().getProperty("spring.thymeleaf.cache"),
-				is(nullValue()));
+		assertThat(context.getEnvironment().getProperty("remoteUrl"))
+				.isEqualTo("http://localhost:8080");
+		assertThat(context.getEnvironment().getProperty("spring.thymeleaf.cache"))
+				.isNull();
 	}
 
 	@Test
 	public void cleanValidUrl() throws Exception {
 		ApplicationContext context = doTest("http://localhost:8080/");
-		assertThat(context.getEnvironment().getProperty("remoteUrl"),
-				equalTo("http://localhost:8080"));
+		assertThat(context.getEnvironment().getProperty("remoteUrl"))
+				.isEqualTo("http://localhost:8080");
 	}
 
 	private ApplicationContext doTest(String... args) {

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/autoconfigure/DevToolsPropertiesTests.java

@@ -18,8 +18,7 @@ package org.springframework.boot.devtools.autoconfigure;
 
 import org.junit.Test;
 
-import static org.hamcrest.Matchers.arrayContaining;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link DevToolsProperties}.
@@ -34,11 +33,10 @@ public class DevToolsPropertiesTests {
 	public void additionalExcludeKeepsDefaults() {
 		DevToolsProperties.Restart restart = this.devToolsProperties.getRestart();
 		restart.setAdditionalExclude("foo/**,bar/**");
-		assertThat(restart.getAllExclude(),
-				arrayContaining("META-INF/maven/**", "META-INF/resources/**",
-						"resources/**", "static/**", "public/**", "templates/**",
-						"**/*Test.class", "**/*Tests.class", "git.properties", "foo/**",
-						"bar/**"));
+		assertThat(restart.getAllExclude()).containsOnly("META-INF/maven/**",
+				"META-INF/resources/**", "resources/**", "static/**", "public/**",
+				"templates/**", "**/*Test.class", "**/*Tests.class", "git.properties",
+				"foo/**", "bar/**");
 	}
 
 	@Test
@@ -46,7 +44,7 @@ public class DevToolsPropertiesTests {
 		DevToolsProperties.Restart restart = this.devToolsProperties.getRestart();
 		restart.setExclude("");
 		restart.setAdditionalExclude("foo/**,bar/**");
-		assertThat(restart.getAllExclude(), arrayContaining("foo/**", "bar/**"));
+		assertThat(restart.getAllExclude()).containsOnly("foo/**", "bar/**");
 	}
 
 	@Test
@@ -54,8 +52,7 @@ public class DevToolsPropertiesTests {
 		DevToolsProperties.Restart restart = this.devToolsProperties.getRestart();
 		restart.setExclude("biz/**");
 		restart.setAdditionalExclude("foo/**,bar/**");
-		assertThat(restart.getAllExclude(),
-				arrayContaining("biz/**", "foo/**", "bar/**"));
+		assertThat(restart.getAllExclude()).containsOnly("biz/**", "foo/**", "bar/**");
 	}
 
 }

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/autoconfigure/LocalDevToolsAutoConfigurationTests.java

@@ -51,12 +51,7 @@ import org.springframework.session.ExpiringSession;
 import org.springframework.test.util.ReflectionTestUtils;
 import org.springframework.util.SocketUtils;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.hasKey;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.notNullValue;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
@@ -94,7 +89,7 @@ public class LocalDevToolsAutoConfigurationTests {
 		this.context = initializeAndRun(Config.class);
 		TemplateResolver resolver = this.context.getBean(TemplateResolver.class);
 		resolver.initialize();
-		assertThat(resolver.isCacheable(), equalTo(false));
+		assertThat(resolver.isCacheable()).isFalse();
 	}
 
 	@Test
@@ -102,7 +97,7 @@ public class LocalDevToolsAutoConfigurationTests {
 		this.context = initializeAndRun(Config.class, "--spring.thymeleaf.cache=true");
 		TemplateResolver resolver = this.context.getBean(TemplateResolver.class);
 		resolver.initialize();
-		assertThat(resolver.isCacheable(), equalTo(true));
+		assertThat(resolver.isCacheable()).isTrue();
 	}
 
 	@Test
@@ -114,7 +109,7 @@ public class LocalDevToolsAutoConfigurationTests {
 			this.context = initializeAndRun(Config.class);
 			TemplateResolver resolver = this.context.getBean(TemplateResolver.class);
 			resolver.initialize();
-			assertThat(resolver.isCacheable(), equalTo(true));
+			assertThat(resolver.isCacheable()).isTrue();
 		}
 		finally {
 			System.setProperty("user.home", userHome);
@@ -125,14 +120,14 @@ public class LocalDevToolsAutoConfigurationTests {
 	public void resourceCachePeriodIsZero() throws Exception {
 		this.context = initializeAndRun(WebResourcesConfig.class);
 		ResourceProperties properties = this.context.getBean(ResourceProperties.class);
-		assertThat(properties.getCachePeriod(), equalTo(0));
+		assertThat(properties.getCachePeriod()).isEqualTo(0);
 	}
 
 	@Test
 	public void liveReloadServer() throws Exception {
 		this.context = initializeAndRun(Config.class);
 		LiveReloadServer server = this.context.getBean(LiveReloadServer.class);
-		assertThat(server.isStarted(), equalTo(true));
+		assertThat(server.isStarted()).isTrue();
 	}
 
 	@Test
@@ -198,7 +193,7 @@ public class LocalDevToolsAutoConfigurationTests {
 		this.context = initializeAndRun(Config.class);
 		ClassPathFileSystemWatcher watcher = this.context
 				.getBean(ClassPathFileSystemWatcher.class);
-		assertThat(watcher, notNullValue());
+		assertThat(watcher).isNotNull();
 	}
 
 	@Test
@@ -220,7 +215,7 @@ public class LocalDevToolsAutoConfigurationTests {
 		Object watcher = ReflectionTestUtils.getField(classPathWatcher,
 				"fileSystemWatcher");
 		Object filter = ReflectionTestUtils.getField(watcher, "triggerFilter");
-		assertThat(filter, instanceOf(TriggerFileFilter.class));
+		assertThat(filter).isInstanceOf(TriggerFileFilter.class);
 	}
 
 	@Test
@@ -236,9 +231,9 @@ public class LocalDevToolsAutoConfigurationTests {
 		@SuppressWarnings("unchecked")
 		Map<File, Object> folders = (Map<File, Object>) ReflectionTestUtils
 				.getField(watcher, "folders");
-		assertThat(folders.size(), is(equalTo(2)));
-		assertThat(folders, hasKey(new File("src/main/java").getAbsoluteFile()));
-		assertThat(folders, hasKey(new File("src/test/java").getAbsoluteFile()));
+		assertThat(folders).hasSize(2)
+				.containsKey(new File("src/main/java").getAbsoluteFile())
+				.containsKey(new File("src/test/java").getAbsoluteFile());
 	}
 
 	@Test
@@ -263,14 +258,14 @@ public class LocalDevToolsAutoConfigurationTests {
 		this.context = application.run();
 		RedisTemplate<?, ?> redisTemplate = this.context.getBean("sessionRedisTemplate",
 				RedisTemplate.class);
-		assertThat(redisTemplate.getHashKeySerializer(),
-				is(instanceOf(RestartCompatibleRedisSerializer.class)));
-		assertThat(redisTemplate.getHashValueSerializer(),
-				is(instanceOf(RestartCompatibleRedisSerializer.class)));
-		assertThat(redisTemplate.getKeySerializer(),
-				is(instanceOf(RestartCompatibleRedisSerializer.class)));
-		assertThat(redisTemplate.getValueSerializer(),
-				is(instanceOf(RestartCompatibleRedisSerializer.class)));
+		assertThat(redisTemplate.getHashKeySerializer())
+				.isInstanceOf(RestartCompatibleRedisSerializer.class);
+		assertThat(redisTemplate.getHashValueSerializer())
+				.isInstanceOf(RestartCompatibleRedisSerializer.class);
+		assertThat(redisTemplate.getKeySerializer())
+				.isInstanceOf(RestartCompatibleRedisSerializer.class);
+		assertThat(redisTemplate.getValueSerializer())
+				.isInstanceOf(RestartCompatibleRedisSerializer.class);
 	}
 
 	private ConfigurableApplicationContext initializeAndRun(Class<?> config,

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/autoconfigure/RemoteDevToolsAutoConfigurationTests.java

@@ -47,8 +47,7 @@ import org.springframework.mock.web.MockHttpServletResponse;
 import org.springframework.mock.web.MockServletContext;
 import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 
 /**
@@ -204,7 +203,7 @@ public class RemoteDevToolsAutoConfigurationTests {
 		this.request.addHeader(DEFAULT_SECRET_HEADER_NAME, "supersecret");
 		this.response.setStatus(500);
 		filter.doFilter(this.request, this.response, this.chain);
-		assertThat(this.response.getStatus(), equalTo(200));
+		assertThat(this.response.getStatus()).isEqualTo(200);
 	}
 
 	@Test
@@ -216,17 +215,17 @@ public class RemoteDevToolsAutoConfigurationTests {
 		this.request.addHeader(DEFAULT_SECRET_HEADER_NAME, "supersecret");
 		this.response.setStatus(500);
 		filter.doFilter(this.request, this.response, this.chain);
-		assertThat(this.response.getStatus(), equalTo(200));
+		assertThat(this.response.getStatus()).isEqualTo(200);
 	}
 
 	private void assertTunnelInvoked(boolean value) {
-		assertThat(this.context.getBean(MockHttpTunnelServer.class).invoked,
-				equalTo(value));
+		assertThat(this.context.getBean(MockHttpTunnelServer.class).invoked)
+				.isEqualTo(value);
 	}
 
 	private void assertRestartInvoked(boolean value) {
-		assertThat(this.context.getBean(MockHttpRestartServer.class).invoked,
-				equalTo(value));
+		assertThat(this.context.getBean(MockHttpRestartServer.class).invoked)
+				.isEqualTo(value);
 	}
 
 	private void loadContext(String... properties) {

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/autoconfigure/TriggerFileFilterTests.java

@@ -23,8 +23,7 @@ import org.junit.Test;
 import org.junit.rules.ExpectedException;
 import org.junit.rules.TemporaryFolder;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link TriggerFileFilter}.
@@ -49,13 +48,13 @@ public class TriggerFileFilterTests {
 	@Test
 	public void acceptNameMatch() throws Exception {
 		File file = this.temp.newFile("thefile.txt");
-		assertThat(new TriggerFileFilter("thefile.txt").accept(file), equalTo(true));
+		assertThat(new TriggerFileFilter("thefile.txt").accept(file)).isTrue();
 	}
 
 	@Test
 	public void doesNotAcceptNameMismatch() throws Exception {
 		File file = this.temp.newFile("notthefile.txt");
-		assertThat(new TriggerFileFilter("thefile.txt").accept(file), equalTo(false));
+		assertThat(new TriggerFileFilter("thefile.txt").accept(file)).isFalse();
 	}
 
 }

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/classpath/ClassPathChangedEventTests.java

@@ -25,9 +25,7 @@ import org.junit.rules.ExpectedException;
 
 import org.springframework.boot.devtools.filewatch.ChangedFiles;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.sameInstance;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link ClassPathChangedEvent}.
@@ -53,7 +51,7 @@ public class ClassPathChangedEventTests {
 		Set<ChangedFiles> changeSet = new LinkedHashSet<ChangedFiles>();
 		ClassPathChangedEvent event = new ClassPathChangedEvent(this.source, changeSet,
 				false);
-		assertThat(event.getChangeSet(), sameInstance(changeSet));
+		assertThat(event.getChangeSet()).isSameAs(changeSet);
 	}
 
 	@Test
@@ -61,9 +59,9 @@ public class ClassPathChangedEventTests {
 		Set<ChangedFiles> changeSet = new LinkedHashSet<ChangedFiles>();
 		ClassPathChangedEvent event;
 		event = new ClassPathChangedEvent(this.source, changeSet, false);
-		assertThat(event.isRestartRequired(), equalTo(false));
+		assertThat(event.isRestartRequired()).isFalse();
 		event = new ClassPathChangedEvent(this.source, changeSet, true);
-		assertThat(event.isRestartRequired(), equalTo(true));
+		assertThat(event.isRestartRequired()).isTrue();
 	}
 
 }

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/classpath/ClassPathFileChangeListenerTests.java

@@ -36,8 +36,7 @@ import org.springframework.boot.devtools.filewatch.FileSystemWatcher;
 import org.springframework.context.ApplicationEvent;
 import org.springframework.context.ApplicationEventPublisher;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
@@ -116,8 +115,8 @@ public class ClassPathFileChangeListenerTests {
 		verify(this.eventPublisher).publishEvent(this.eventCaptor.capture());
 		ClassPathChangedEvent actualEvent = (ClassPathChangedEvent) this.eventCaptor
 				.getValue();
-		assertThat(actualEvent.getChangeSet(), equalTo(changeSet));
-		assertThat(actualEvent.isRestartRequired(), equalTo(restart));
+		assertThat(actualEvent.getChangeSet()).isEqualTo(changeSet);
+		assertThat(actualEvent.isRestartRequired()).isEqualTo(restart);
 	}
 
 }

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/classpath/ClassPathFileSystemWatcherTests.java

@@ -40,8 +40,7 @@ import org.springframework.core.env.Environment;
 import org.springframework.core.env.MapPropertySource;
 import org.springframework.util.FileCopyUtils;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 
 /**
@@ -84,9 +83,9 @@ public class ClassPathFileSystemWatcherTests {
 		FileCopyUtils.copy("file".getBytes(), classFile);
 		Thread.sleep(1100);
 		List<ClassPathChangedEvent> events = context.getBean(Listener.class).getEvents();
-		assertThat(events.size(), equalTo(1));
+		assertThat(events.size()).isEqualTo(1);
 		assertThat(events.get(0).getChangeSet().iterator().next().getFiles().iterator()
-				.next().getFile(), equalTo(classFile));
+				.next().getFile()).isEqualTo(classFile);
 		context.close();
 	}
 

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/classpath/PatternClassPathRestartStrategyTests.java

@@ -23,8 +23,7 @@ import org.junit.Test;
 import org.springframework.boot.devtools.filewatch.ChangedFile;
 import org.springframework.boot.devtools.filewatch.ChangedFile.Type;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link PatternClassPathRestartStrategy}.
@@ -90,7 +89,8 @@ public class PatternClassPathRestartStrategyTests {
 
 	private void assertRestartRequired(ClassPathRestartStrategy strategy,
 			String relativeName, boolean expected) {
-		assertThat(strategy.isRestartRequired(mockFile(relativeName)), equalTo(expected));
+		assertThat(strategy.isRestartRequired(mockFile(relativeName)))
+				.isEqualTo(expected);
 	}
 
 	private ChangedFile mockFile(String relativeName) {

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/env/DevToolsHomePropertiesPostProcessorTests.java

@@ -30,9 +30,7 @@ import org.junit.rules.TemporaryFolder;
 import org.springframework.core.env.ConfigurableEnvironment;
 import org.springframework.mock.env.MockEnvironment;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link DevToolsHomePropertiesPostProcessor}.
@@ -63,7 +61,7 @@ public class DevToolsHomePropertiesPostProcessorTests {
 		ConfigurableEnvironment environment = new MockEnvironment();
 		MockDevToolHomePropertiesPostProcessor postProcessor = new MockDevToolHomePropertiesPostProcessor();
 		postProcessor.postProcessEnvironment(environment, null);
-		assertThat(environment.getProperty("abc"), equalTo("def"));
+		assertThat(environment.getProperty("abc")).isEqualTo("def");
 	}
 
 	@Test
@@ -71,7 +69,7 @@ public class DevToolsHomePropertiesPostProcessorTests {
 		ConfigurableEnvironment environment = new MockEnvironment();
 		MockDevToolHomePropertiesPostProcessor postProcessor = new MockDevToolHomePropertiesPostProcessor();
 		postProcessor.postProcessEnvironment(environment, null);
-		assertThat(environment.getProperty("abc"), nullValue());
+		assertThat(environment.getProperty("abc")).isNull();
 	}
 
 	private class MockDevToolHomePropertiesPostProcessor

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/filewatch/ChangedFileTests.java

@@ -25,8 +25,7 @@ import org.junit.rules.TemporaryFolder;
 
 import org.springframework.boot.devtools.filewatch.ChangedFile.Type;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link ChangedFile}.
@@ -66,14 +65,14 @@ public class ChangedFileTests {
 	public void getFile() throws Exception {
 		File file = this.temp.newFile();
 		ChangedFile changedFile = new ChangedFile(this.temp.newFolder(), file, Type.ADD);
-		assertThat(changedFile.getFile(), equalTo(file));
+		assertThat(changedFile.getFile()).isEqualTo(file);
 	}
 
 	@Test
 	public void getType() throws Exception {
 		ChangedFile changedFile = new ChangedFile(this.temp.newFolder(),
 				this.temp.newFile(), Type.DELETE);
-		assertThat(changedFile.getType(), equalTo(Type.DELETE));
+		assertThat(changedFile.getType()).isEqualTo(Type.DELETE);
 	}
 
 	@Test
@@ -82,7 +81,7 @@ public class ChangedFileTests {
 		File subFolder = new File(folder, "A");
 		File file = new File(subFolder, "B.txt");
 		ChangedFile changedFile = new ChangedFile(folder, file, Type.ADD);
-		assertThat(changedFile.getRelativeName(), equalTo("A/B.txt"));
+		assertThat(changedFile.getRelativeName()).isEqualTo("A/B.txt");
 	}
 
 }

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/filewatch/FileSnapshotTests.java

@@ -28,9 +28,7 @@ import org.junit.rules.TemporaryFolder;
 
 import org.springframework.util.FileCopyUtils;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.not;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link FileSnapshot}.
@@ -70,8 +68,8 @@ public class FileSnapshotTests {
 		File fileCopy = new File(file, "x").getParentFile();
 		FileSnapshot snapshot1 = new FileSnapshot(file);
 		FileSnapshot snapshot2 = new FileSnapshot(fileCopy);
-		assertThat(snapshot1, equalTo(snapshot2));
-		assertThat(snapshot1.hashCode(), equalTo(snapshot2.hashCode()));
+		assertThat(snapshot1).isEqualTo(snapshot2);
+		assertThat(snapshot1.hashCode()).isEqualTo(snapshot2.hashCode());
 	}
 
 	@Test
@@ -79,7 +77,7 @@ public class FileSnapshotTests {
 		File file = createNewFile("abc", MODIFIED);
 		FileSnapshot snapshot1 = new FileSnapshot(file);
 		file.delete();
-		assertThat(snapshot1, not(equalTo(new FileSnapshot(file))));
+		assertThat(snapshot1).isNotEqualTo(new FileSnapshot(file));
 	}
 
 	@Test
@@ -87,7 +85,7 @@ public class FileSnapshotTests {
 		File file = createNewFile("abc", MODIFIED);
 		FileSnapshot snapshot1 = new FileSnapshot(file);
 		setupFile(file, "abcd", MODIFIED);
-		assertThat(snapshot1, not(equalTo(new FileSnapshot(file))));
+		assertThat(snapshot1).isNotEqualTo(new FileSnapshot(file));
 	}
 
 	@Test
@@ -95,7 +93,7 @@ public class FileSnapshotTests {
 		File file = createNewFile("abc", MODIFIED);
 		FileSnapshot snapshot1 = new FileSnapshot(file);
 		setupFile(file, "abc", MODIFIED + TWO_MINS);
-		assertThat(snapshot1, not(equalTo(new FileSnapshot(file))));
+		assertThat(snapshot1).isNotEqualTo(new FileSnapshot(file));
 	}
 
 	private File createNewFile(String content, long lastModified) throws IOException {

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/filewatch/FileSystemWatcherTests.java

@@ -22,7 +22,6 @@ import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.List;
@@ -37,11 +36,7 @@ import org.junit.rules.TemporaryFolder;
 import org.springframework.boot.devtools.filewatch.ChangedFile.Type;
 import org.springframework.util.FileCopyUtils;
 
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 
 /**
@@ -112,7 +107,7 @@ public class FileSystemWatcherTests {
 	@Test
 	public void sourceFolderMustExist() throws Exception {
 		File folder = new File("does/not/exist");
-		assertThat(folder.exists(), is(false));
+		assertThat(folder.exists()).isFalse();
 		this.thrown.expect(IllegalArgumentException.class);
 		this.thrown.expectMessage(
 				"Folder '" + folder + "' must exist and must be a directory");
@@ -122,7 +117,7 @@ public class FileSystemWatcherTests {
 	@Test
 	public void sourceFolderMustBeADirectory() throws Exception {
 		File folder = new File("pom.xml");
-		assertThat(folder.isFile(), is(true));
+		assertThat(folder.isFile()).isTrue();
 		this.thrown.expect(IllegalArgumentException.class);
 		this.thrown.expectMessage("Folder 'pom.xml' must exist and must be a directory");
 		this.watcher.addSourceFolder(new File("pom.xml"));
@@ -143,7 +138,7 @@ public class FileSystemWatcherTests {
 		this.watcher.stopAfter(1);
 		ChangedFiles changedFiles = getSingleChangedFiles();
 		ChangedFile expected = new ChangedFile(folder, file, Type.ADD);
-		assertThat(changedFiles.getFiles(), contains(expected));
+		assertThat(changedFiles.getFiles()).contains(expected);
 	}
 
 	@Test
@@ -153,7 +148,7 @@ public class FileSystemWatcherTests {
 		this.watcher.stopAfter(1);
 		ChangedFiles changedFiles = getSingleChangedFiles();
 		ChangedFile expected = new ChangedFile(folder, file, Type.ADD);
-		assertThat(changedFiles.getFiles(), contains(expected));
+		assertThat(changedFiles.getFiles()).contains(expected);
 	}
 
 	@Test
@@ -165,7 +160,7 @@ public class FileSystemWatcherTests {
 		Thread.sleep(200);
 		touch(new File(folder, "test2.txt"));
 		this.watcher.stopAfter(1);
-		assertThat(this.changes.size(), equalTo(2));
+		assertThat(this.changes.size()).isEqualTo(2);
 	}
 
 	@Test
@@ -178,7 +173,7 @@ public class FileSystemWatcherTests {
 		}
 		this.watcher.stopAfter(1);
 		ChangedFiles changedFiles = getSingleChangedFiles();
-		assertThat(changedFiles.getFiles().size(), equalTo(10));
+		assertThat(changedFiles.getFiles().size()).isEqualTo(10);
 	}
 
 	@Test
@@ -191,7 +186,7 @@ public class FileSystemWatcherTests {
 		this.watcher.stopAfter(1);
 		ChangedFiles changedFiles = getSingleChangedFiles();
 		ChangedFile expected = new ChangedFile(folder, file, Type.ADD);
-		assertThat(changedFiles.getFiles(), contains(expected));
+		assertThat(changedFiles.getFiles()).contains(expected);
 	}
 
 	@Test
@@ -205,17 +200,15 @@ public class FileSystemWatcherTests {
 		File file2 = touch(new File(folder2, "test.txt"));
 		this.watcher.stopAfter(1);
 		Set<ChangedFiles> change = getSingleOnChange();
-		assertThat(change.size(), equalTo(2));
+		assertThat(change.size()).isEqualTo(2);
 		for (ChangedFiles changedFiles : change) {
 			if (changedFiles.getSourceFolder().equals(folder1)) {
 				ChangedFile file = new ChangedFile(folder1, file1, Type.ADD);
-				assertEquals(new HashSet<ChangedFile>(Arrays.asList(file)),
-						changedFiles.getFiles());
+				assertThat(changedFiles.getFiles()).containsOnly(file);
 			}
 			else {
 				ChangedFile file = new ChangedFile(folder2, file2, Type.ADD);
-				assertEquals(new HashSet<ChangedFile>(Arrays.asList(file)),
-						changedFiles.getFiles());
+				assertThat(changedFiles.getFiles()).containsOnly(file);
 			}
 		}
 	}
@@ -236,8 +229,8 @@ public class FileSystemWatcherTests {
 		this.watcher.stopAfter(1);
 		ChangedFiles changedFiles = getSingleChangedFiles();
 		ChangedFile expected = new ChangedFile(folder, file, Type.ADD);
-		assertThat(changedFiles.getFiles(), contains(expected));
-		assertEquals(this.changes.get(0), listener2Changes);
+		assertThat(changedFiles.getFiles()).contains(expected);
+		assertThat(listener2Changes).isEqualTo(this.changes.get(0));
 	}
 
 	@Test
@@ -257,7 +250,7 @@ public class FileSystemWatcherTests {
 		expected.add(new ChangedFile(folder, modify, Type.MODIFY));
 		expected.add(new ChangedFile(folder, delete, Type.DELETE));
 		expected.add(new ChangedFile(folder, add, Type.ADD));
-		assertEquals(expected, actual);
+		assertThat(actual).isEqualTo(expected);
 	}
 
 	@Test
@@ -277,14 +270,14 @@ public class FileSystemWatcherTests {
 		this.watcher.start();
 		FileCopyUtils.copy("abc".getBytes(), file);
 		Thread.sleep(100);
-		assertThat(this.changes.size(), equalTo(0));
+		assertThat(this.changes.size()).isEqualTo(0);
 		FileCopyUtils.copy("abc".getBytes(), trigger);
 		this.watcher.stopAfter(1);
 		ChangedFiles changedFiles = getSingleChangedFiles();
 		Set<ChangedFile> actual = changedFiles.getFiles();
 		Set<ChangedFile> expected = new HashSet<ChangedFile>();
 		expected.add(new ChangedFile(folder, file, Type.MODIFY));
-		assertEquals(expected, actual);
+		assertThat(actual).isEqualTo(expected);
 	}
 
 	private void setupWatcher(long pollingInterval, long quietPeriod) {
@@ -306,12 +299,12 @@ public class FileSystemWatcherTests {
 
 	private ChangedFiles getSingleChangedFiles() {
 		Set<ChangedFiles> singleChange = getSingleOnChange();
-		assertThat(singleChange.size(), equalTo(1));
+		assertThat(singleChange.size()).isEqualTo(1);
 		return singleChange.iterator().next();
 	}
 
 	private Set<ChangedFiles> getSingleOnChange() {
-		assertThat(this.changes.size(), equalTo(1));
+		assertThat(this.changes.size()).isEqualTo(1);
 		return this.changes.get(0);
 	}
 

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/filewatch/FolderSnapshotTests.java

@@ -28,9 +28,7 @@ import org.junit.rules.TemporaryFolder;
 import org.springframework.boot.devtools.filewatch.ChangedFile.Type;
 import org.springframework.util.FileCopyUtils;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.not;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link FolderSnapshot}.
@@ -72,22 +70,22 @@ public class FolderSnapshotTests {
 	@Test
 	public void equalsWhenNothingHasChanged() throws Exception {
 		FolderSnapshot updatedSnapshot = new FolderSnapshot(this.folder);
-		assertThat(this.initialSnapshot, equalTo(updatedSnapshot));
-		assertThat(this.initialSnapshot.hashCode(), equalTo(updatedSnapshot.hashCode()));
+		assertThat(this.initialSnapshot).isEqualTo(updatedSnapshot);
+		assertThat(this.initialSnapshot.hashCode()).isEqualTo(updatedSnapshot.hashCode());
 	}
 
 	@Test
 	public void notEqualsWhenAFileIsAdded() throws Exception {
 		new File(new File(this.folder, "folder1"), "newfile").createNewFile();
 		FolderSnapshot updatedSnapshot = new FolderSnapshot(this.folder);
-		assertThat(this.initialSnapshot, not(equalTo(updatedSnapshot)));
+		assertThat(this.initialSnapshot).isNotEqualTo(updatedSnapshot);
 	}
 
 	@Test
 	public void notEqualsWhenAFileIsDeleted() throws Exception {
 		new File(new File(this.folder, "folder1"), "file1").delete();
 		FolderSnapshot updatedSnapshot = new FolderSnapshot(this.folder);
-		assertThat(this.initialSnapshot, not(equalTo(updatedSnapshot)));
+		assertThat(this.initialSnapshot).isNotEqualTo(updatedSnapshot);
 	}
 
 	@Test
@@ -95,7 +93,7 @@ public class FolderSnapshotTests {
 		File file1 = new File(new File(this.folder, "folder1"), "file1");
 		FileCopyUtils.copy("updatedcontent".getBytes(), file1);
 		FolderSnapshot updatedSnapshot = new FolderSnapshot(this.folder);
-		assertThat(this.initialSnapshot, not(equalTo(updatedSnapshot)));
+		assertThat(this.initialSnapshot).isNotEqualTo(updatedSnapshot);
 	}
 
 	@Test
@@ -131,10 +129,10 @@ public class FolderSnapshotTests {
 		FolderSnapshot updatedSnapshot = new FolderSnapshot(this.folder);
 		ChangedFiles changedFiles = this.initialSnapshot.getChangedFiles(updatedSnapshot,
 				null);
-		assertThat(changedFiles.getSourceFolder(), equalTo(this.folder));
-		assertThat(getChangedFile(changedFiles, file1).getType(), equalTo(Type.MODIFY));
-		assertThat(getChangedFile(changedFiles, file2).getType(), equalTo(Type.DELETE));
-		assertThat(getChangedFile(changedFiles, newFile).getType(), equalTo(Type.ADD));
+		assertThat(changedFiles.getSourceFolder()).isEqualTo(this.folder);
+		assertThat(getChangedFile(changedFiles, file1).getType()).isEqualTo(Type.MODIFY);
+		assertThat(getChangedFile(changedFiles, file2).getType()).isEqualTo(Type.DELETE);
+		assertThat(getChangedFile(changedFiles, newFile).getType()).isEqualTo(Type.ADD);
 	}
 
 	private ChangedFile getChangedFile(ChangedFiles changedFiles, File file) {

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/integrationtest/HttpTunnelIntegrationTests.java

@@ -54,7 +54,7 @@ import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.servlet.DispatcherServlet;
 import org.springframework.web.servlet.config.annotation.EnableWebMvc;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Simple integration tests for HTTP tunneling.
@@ -74,8 +74,8 @@ public class HttpTunnelIntegrationTests {
 		String url = "http://localhost:" + this.config.httpServerPort + "/hello";
 		ResponseEntity<String> entity = new TestRestTemplate().getForEntity(url,
 				String.class);
-		assertEquals(HttpStatus.OK, entity.getStatusCode());
-		assertEquals("Hello World", entity.getBody());
+		assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.OK);
+		assertThat(entity.getBody()).isEqualTo("Hello World");
 	}
 
 	@Test
@@ -83,8 +83,8 @@ public class HttpTunnelIntegrationTests {
 		String url = "http://localhost:" + this.config.clientPort + "/hello";
 		ResponseEntity<String> entity = new TestRestTemplate().getForEntity(url,
 				String.class);
-		assertEquals(HttpStatus.OK, entity.getStatusCode());
-		assertEquals("Hello World", entity.getBody());
+		assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.OK);
+		assertThat(entity.getBody()).isEqualTo("Hello World");
 	}
 
 	@Configuration

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/livereload/ConnectionInputStreamTests.java

@@ -25,8 +25,7 @@ import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link ConnectionInputStream}.
@@ -51,7 +50,7 @@ public class ConnectionInputStreamTests {
 		String data = header + "\r\n\r\n" + "content\r\n";
 		ConnectionInputStream inputStream = new ConnectionInputStream(
 				new ByteArrayInputStream(data.getBytes()));
-		assertThat(inputStream.readHeader(), equalTo(header));
+		assertThat(inputStream.readHeader()).isEqualTo(header);
 	}
 
 	@Test
@@ -62,7 +61,7 @@ public class ConnectionInputStreamTests {
 		ConnectionInputStream inputStream = new ConnectionInputStream(source);
 		byte[] buffer = new byte[bytes.length];
 		inputStream.readFully(buffer, 0, buffer.length);
-		assertThat(buffer, equalTo(bytes));
+		assertThat(buffer).isEqualTo(bytes);
 	}
 
 	@Test

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/livereload/ConnectionOutputStreamTests.java

@@ -22,8 +22,7 @@ import java.io.OutputStream;
 
 import org.junit.Test;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 
@@ -55,7 +54,7 @@ public class ConnectionOutputStreamTests {
 		expected += "Content-Length: 2\r\n";
 		expected += "Connection: close\r\n\r\n";
 		expected += "hi";
-		assertThat(out.toString(), equalTo(expected));
+		assertThat(out.toString()).isEqualTo(expected);
 	}
 
 	@Test
@@ -67,7 +66,7 @@ public class ConnectionOutputStreamTests {
 		String expected = "";
 		expected += "A: a\r\n";
 		expected += "B: b\r\n\r\n";
-		assertThat(out.toString(), equalTo(expected));
+		assertThat(out.toString()).isEqualTo(expected);
 	}
 
 }

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/livereload/FrameTests.java

@@ -24,8 +24,7 @@ import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link Frame}.
@@ -54,15 +53,15 @@ public class FrameTests {
 	@Test
 	public void textPayload() throws Exception {
 		Frame frame = new Frame("abc");
-		assertThat(frame.getType(), equalTo(Frame.Type.TEXT));
-		assertThat(frame.getPayload(), equalTo("abc".getBytes()));
+		assertThat(frame.getType()).isEqualTo(Frame.Type.TEXT);
+		assertThat(frame.getPayload()).isEqualTo("abc".getBytes());
 	}
 
 	@Test
 	public void typedPayload() throws Exception {
 		Frame frame = new Frame(Frame.Type.CLOSE);
-		assertThat(frame.getType(), equalTo(Frame.Type.CLOSE));
-		assertThat(frame.getPayload(), equalTo(new byte[] {}));
+		assertThat(frame.getType()).isEqualTo(Frame.Type.CLOSE);
+		assertThat(frame.getPayload()).isEqualTo(new byte[] {});
 	}
 
 	@Test
@@ -71,7 +70,7 @@ public class FrameTests {
 		Frame frame = new Frame(payload);
 		ByteArrayOutputStream bos = new ByteArrayOutputStream();
 		frame.write(bos);
-		assertThat(bos.toByteArray(), equalTo(new byte[] { (byte) 0x81, 0x01, 0x41 }));
+		assertThat(bos.toByteArray()).isEqualTo(new byte[] { (byte) 0x81, 0x01, 0x41 });
 	}
 
 	@Test
@@ -81,13 +80,13 @@ public class FrameTests {
 		ByteArrayOutputStream bos = new ByteArrayOutputStream();
 		frame.write(bos);
 		byte[] bytes = bos.toByteArray();
-		assertThat(bytes.length, equalTo(130));
-		assertThat(bytes[0], equalTo((byte) 0x81));
-		assertThat(bytes[1], equalTo((byte) 0x7E));
-		assertThat(bytes[2], equalTo((byte) 0x00));
-		assertThat(bytes[3], equalTo((byte) 126));
-		assertThat(bytes[4], equalTo((byte) 0x41));
-		assertThat(bytes[5], equalTo((byte) 0x41));
+		assertThat(bytes.length).isEqualTo(130);
+		assertThat(bytes[0]).isEqualTo((byte) 0x81);
+		assertThat(bytes[1]).isEqualTo((byte) 0x7E);
+		assertThat(bytes[2]).isEqualTo((byte) 0x00);
+		assertThat(bytes[3]).isEqualTo((byte) 126);
+		assertThat(bytes[4]).isEqualTo((byte) 0x41);
+		assertThat(bytes[5]).isEqualTo((byte) 0x41);
 	}
 
 	@Test
@@ -110,8 +109,8 @@ public class FrameTests {
 	public void readSmallTextFrame() throws Exception {
 		byte[] bytes = new byte[] { (byte) 0x81, (byte) 0x02, 0x41, 0x41 };
 		Frame frame = Frame.read(newConnectionInputStream(bytes));
-		assertThat(frame.getType(), equalTo(Frame.Type.TEXT));
-		assertThat(frame.getPayload(), equalTo(new byte[] { 0x41, 0x41 }));
+		assertThat(frame.getType()).isEqualTo(Frame.Type.TEXT);
+		assertThat(frame.getPayload()).isEqualTo(new byte[] { 0x41, 0x41 });
 	}
 
 	@Test
@@ -119,8 +118,8 @@ public class FrameTests {
 		byte[] bytes = new byte[] { (byte) 0x81, (byte) 0x82, 0x0F, 0x0F, 0x0F, 0x0F,
 				0x4E, 0x4E };
 		Frame frame = Frame.read(newConnectionInputStream(bytes));
-		assertThat(frame.getType(), equalTo(Frame.Type.TEXT));
-		assertThat(frame.getPayload(), equalTo(new byte[] { 0x41, 0x41 }));
+		assertThat(frame.getType()).isEqualTo(Frame.Type.TEXT);
+		assertThat(frame.getPayload()).isEqualTo(new byte[] { 0x41, 0x41 });
 	}
 
 	@Test
@@ -136,43 +135,43 @@ public class FrameTests {
 		bytes[6] = 0x0F;
 		bytes[7] = 0x0F;
 		Frame frame = Frame.read(newConnectionInputStream(bytes));
-		assertThat(frame.getType(), equalTo(Frame.Type.TEXT));
-		assertThat(frame.getPayload(), equalTo(createString(126).getBytes()));
+		assertThat(frame.getType()).isEqualTo(Frame.Type.TEXT);
+		assertThat(frame.getPayload()).isEqualTo(createString(126).getBytes());
 	}
 
 	@Test
 	public void readContinuation() throws Exception {
 		byte[] bytes = new byte[] { (byte) 0x80, (byte) 0x00 };
 		Frame frame = Frame.read(newConnectionInputStream(bytes));
-		assertThat(frame.getType(), equalTo(Frame.Type.CONTINUATION));
+		assertThat(frame.getType()).isEqualTo(Frame.Type.CONTINUATION);
 	}
 
 	@Test
 	public void readBinary() throws Exception {
 		byte[] bytes = new byte[] { (byte) 0x82, (byte) 0x00 };
 		Frame frame = Frame.read(newConnectionInputStream(bytes));
-		assertThat(frame.getType(), equalTo(Frame.Type.BINARY));
+		assertThat(frame.getType()).isEqualTo(Frame.Type.BINARY);
 	}
 
 	@Test
 	public void readClose() throws Exception {
 		byte[] bytes = new byte[] { (byte) 0x88, (byte) 0x00 };
 		Frame frame = Frame.read(newConnectionInputStream(bytes));
-		assertThat(frame.getType(), equalTo(Frame.Type.CLOSE));
+		assertThat(frame.getType()).isEqualTo(Frame.Type.CLOSE);
 	}
 
 	@Test
 	public void readPing() throws Exception {
 		byte[] bytes = new byte[] { (byte) 0x89, (byte) 0x00 };
 		Frame frame = Frame.read(newConnectionInputStream(bytes));
-		assertThat(frame.getType(), equalTo(Frame.Type.PING));
+		assertThat(frame.getType()).isEqualTo(Frame.Type.PING);
 	}
 
 	@Test
 	public void readPong() throws Exception {
 		byte[] bytes = new byte[] { (byte) 0x8A, (byte) 0x00 };
 		Frame frame = Frame.read(newConnectionInputStream(bytes));
-		assertThat(frame.getType(), equalTo(Frame.Type.PONG));
+		assertThat(frame.getType()).isEqualTo(Frame.Type.PONG);
 	}
 
 	private ConnectionInputStream newConnectionInputStream(byte[] bytes) {

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/livereload/LiveReloadServerTests.java

@@ -40,10 +40,7 @@ import org.junit.Test;
 import org.springframework.util.SocketUtils;
 import org.springframework.web.client.RestTemplate;
 
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.greaterThan;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link LiveReloadServer}.
@@ -78,7 +75,7 @@ public class LiveReloadServerTests {
 		RestTemplate template = new RestTemplate();
 		URI uri = new URI("http://localhost:" + this.port + "/livereload.js");
 		String script = template.getForObject(uri, String.class);
-		assertThat(script, containsString("livereload.com/protocols/official-7"));
+		assertThat(script).contains("livereload.com/protocols/official-7");
 	}
 
 	@Test
@@ -89,9 +86,9 @@ public class LiveReloadServerTests {
 			this.server.triggerReload();
 			Thread.sleep(500);
 			this.server.stop();
-			assertThat(socket.getMessages(0),
-					containsString("http://livereload.com/protocols/official-7"));
-			assertThat(socket.getMessages(1), containsString("command\":\"reload\""));
+			assertThat(socket.getMessages(0))
+					.contains("http://livereload.com/protocols/official-7");
+			assertThat(socket.getMessages(1)).contains("command\":\"reload\"");
 		}
 		finally {
 			client.stop();
@@ -107,7 +104,7 @@ public class LiveReloadServerTests {
 			socket.getRemote().sendPing(NO_DATA);
 			Thread.sleep(200);
 			this.server.stop();
-			assertThat(driver.getPongCount(), equalTo(1));
+			assertThat(driver.getPongCount()).isEqualTo(1);
 		}
 		finally {
 			client.stop();
@@ -125,7 +122,7 @@ public class LiveReloadServerTests {
 			client.stop();
 		}
 		awaitClosedException();
-		assertThat(this.server.getClosedExceptions().size(), greaterThan(0));
+		assertThat(this.server.getClosedExceptions().size()).isGreaterThan(0);
 	}
 
 	private void awaitClosedException() throws InterruptedException {
@@ -144,7 +141,7 @@ public class LiveReloadServerTests {
 			Thread.sleep(200);
 			this.server.stop();
 			Thread.sleep(200);
-			assertThat(socket.getCloseStatus(), equalTo(1006));
+			assertThat(socket.getCloseStatus()).isEqualTo(1006);
 		}
 		finally {
 			client.stop();

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/remote/client/ClassPathChangeUploaderTests.java

@@ -44,8 +44,7 @@ import org.springframework.http.HttpStatus;
 import org.springframework.mock.http.client.MockClientHttpRequest;
 import org.springframework.util.FileCopyUtils;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link ClassPathChangeUploader}.
@@ -117,20 +116,20 @@ public class ClassPathChangeUploaderTests {
 		MockClientHttpRequest request = this.requestFactory.getExecutedRequests().get(0);
 		ClassLoaderFiles classLoaderFiles = deserialize(request.getBodyAsBytes());
 		Collection<SourceFolder> sourceFolders = classLoaderFiles.getSourceFolders();
-		assertThat(sourceFolders.size(), equalTo(1));
+		assertThat(sourceFolders.size()).isEqualTo(1);
 		SourceFolder classSourceFolder = sourceFolders.iterator().next();
-		assertThat(classSourceFolder.getName(), equalTo(sourceFolder.getAbsolutePath()));
+		assertThat(classSourceFolder.getName()).isEqualTo(sourceFolder.getAbsolutePath());
 		Iterator<ClassLoaderFile> classFiles = classSourceFolder.getFiles().iterator();
 		assertClassFile(classFiles.next(), "File1", ClassLoaderFile.Kind.ADDED);
 		assertClassFile(classFiles.next(), "File2", ClassLoaderFile.Kind.MODIFIED);
 		assertClassFile(classFiles.next(), null, ClassLoaderFile.Kind.DELETED);
-		assertThat(classFiles.hasNext(), equalTo(false));
+		assertThat(classFiles.hasNext()).isFalse();
 	}
 
 	private void assertClassFile(ClassLoaderFile file, String content, Kind kind) {
-		assertThat(file.getContents(),
-				equalTo(content == null ? null : content.getBytes()));
-		assertThat(file.getKind(), equalTo(kind));
+		assertThat(file.getContents())
+				.isEqualTo(content == null ? null : content.getBytes());
+		assertThat(file.getKind()).isEqualTo(kind);
 	}
 
 	private File createFile(File sourceFolder, String name) throws IOException {

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/remote/client/DelayedLiveReloadTriggerTests.java

@@ -33,8 +33,7 @@ import org.springframework.http.client.ClientHttpRequest;
 import org.springframework.http.client.ClientHttpRequestFactory;
 import org.springframework.http.client.ClientHttpResponse;
 
-import static org.hamcrest.Matchers.greaterThan;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
@@ -119,7 +118,7 @@ public class DelayedLiveReloadTriggerTests {
 		long startTime = System.currentTimeMillis();
 		this.trigger.setTimings(10, 200, 30000);
 		this.trigger.run();
-		assertThat(System.currentTimeMillis() - startTime, greaterThan(300L));
+		assertThat(System.currentTimeMillis() - startTime).isGreaterThan(300L);
 		verify(this.liveReloadServer).triggerReload();
 	}
 

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/remote/client/HttpHeaderInterceptorTests.java

@@ -32,8 +32,7 @@ import org.springframework.http.client.ClientHttpResponse;
 import org.springframework.http.server.ServletServerHttpRequest;
 import org.springframework.mock.web.MockHttpServletRequest;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.BDDMockito.given;
 
 /**
@@ -109,8 +108,8 @@ public class HttpHeaderInterceptorTests {
 	public void intercept() throws IOException {
 		ClientHttpResponse result = this.interceptor.intercept(this.request, this.body,
 				this.execution);
-		assertThat(this.request.getHeaders().getFirst(this.name), equalTo(this.value));
-		assertThat(result, equalTo(this.response));
+		assertThat(this.request.getHeaders().getFirst(this.name)).isEqualTo(this.value);
+		assertThat(result).isEqualTo(this.response);
 	}
 
 }

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/remote/client/LocalDebugPortAvailableConditionTests.java

@@ -28,8 +28,7 @@ import org.springframework.context.annotation.ConditionContext;
 import org.springframework.mock.env.MockEnvironment;
 import org.springframework.util.SocketUtils;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
 
@@ -47,8 +46,8 @@ public class LocalDebugPortAvailableConditionTests {
 	@Test
 	public void portAvailable() throws Exception {
 		ConditionOutcome outcome = getOutcome();
-		assertThat(outcome.isMatch(), equalTo(true));
-		assertThat(outcome.getMessage(), equalTo("Local debug port available"));
+		assertThat(outcome.isMatch()).isTrue();
+		assertThat(outcome.getMessage()).isEqualTo("Local debug port available");
 	}
 
 	@Test
@@ -57,8 +56,8 @@ public class LocalDebugPortAvailableConditionTests {
 				.createServerSocket(this.port);
 		ConditionOutcome outcome = getOutcome();
 		serverSocket.close();
-		assertThat(outcome.isMatch(), equalTo(false));
-		assertThat(outcome.getMessage(), equalTo("Local debug port unavailable"));
+		assertThat(outcome.isMatch()).isFalse();
+		assertThat(outcome.getMessage()).isEqualTo("Local debug port unavailable");
 	}
 
 	private ConditionOutcome getOutcome() {

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/remote/client/RemoteClientConfigurationTests.java

@@ -49,9 +49,7 @@ import org.springframework.http.server.ServerHttpRequest;
 import org.springframework.http.server.ServerHttpResponse;
 import org.springframework.util.SocketUtils;
 
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.not;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.mock;
@@ -88,20 +86,20 @@ public class RemoteClientConfigurationTests {
 	public void warnIfDebugAndRestartDisabled() throws Exception {
 		configure("spring.devtools.remote.debug.enabled:false",
 				"spring.devtools.remote.restart.enabled:false");
-		assertThat(this.output.toString(),
-				containsString("Remote restart and debug are both disabled"));
+		assertThat(this.output.toString())
+				.contains("Remote restart and debug are both disabled");
 	}
 
 	@Test
 	public void warnIfNotHttps() throws Exception {
 		configure("http://localhost", true);
-		assertThat(this.output.toString(), containsString("is insecure"));
+		assertThat(this.output.toString()).contains("is insecure");
 	}
 
 	@Test
 	public void doesntWarnIfUsingHttps() throws Exception {
 		configure("https://localhost", true);
-		assertThat(this.output.toString(), not(containsString("is insecure")));
+		assertThat(this.output.toString()).doesNotContain("is insecure");
 	}
 
 	@Test

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/remote/server/DispatcherFilterTests.java

@@ -38,8 +38,7 @@ import org.springframework.http.server.ServletServerHttpResponse;
 import org.springframework.mock.web.MockHttpServletRequest;
 import org.springframework.mock.web.MockHttpServletResponse;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.BDDMockito.willReturn;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.mock;
@@ -114,8 +113,8 @@ public class DispatcherFilterTests {
 		ServletServerHttpRequest actualRequest = (ServletServerHttpRequest) dispatcherRequest;
 		ServerHttpResponse dispatcherResponse = this.serverResponseCaptor.getValue();
 		ServletServerHttpResponse actualResponse = (ServletServerHttpResponse) dispatcherResponse;
-		assertThat(actualRequest.getServletRequest(), equalTo(request));
-		assertThat(actualResponse.getServletResponse(), equalTo(response));
+		assertThat(actualRequest.getServletRequest()).isEqualTo(request);
+		assertThat(actualResponse.getServletResponse()).isEqualTo(response);
 	}
 
 }

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/remote/server/DispatcherTests.java

@@ -36,8 +36,7 @@ import org.springframework.http.server.ServletServerHttpResponse;
 import org.springframework.mock.web.MockHttpServletRequest;
 import org.springframework.mock.web.MockHttpServletResponse;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.inOrder;
@@ -101,7 +100,7 @@ public class DispatcherTests {
 				Collections.singleton(mapper));
 		dispatcher.handle(this.serverRequest, this.serverResponse);
 		verifyZeroInteractions(handler);
-		assertThat(this.response.getStatus(), equalTo(403));
+		assertThat(this.response.getStatus()).isEqualTo(403);
 	}
 
 	@Test

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/remote/server/HttpHeaderAccessManagerTests.java

@@ -25,8 +25,7 @@ import org.springframework.http.server.ServerHttpRequest;
 import org.springframework.http.server.ServletServerHttpRequest;
 import org.springframework.mock.web.MockHttpServletRequest;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link HttpHeaderAccessManager}.
@@ -87,24 +86,24 @@ public class HttpHeaderAccessManagerTests {
 	@Test
 	public void allowsMatching() throws Exception {
 		this.request.addHeader(HEADER, SECRET);
-		assertThat(this.manager.isAllowed(this.serverRequest), equalTo(true));
+		assertThat(this.manager.isAllowed(this.serverRequest)).isTrue();
 	}
 
 	@Test
 	public void disallowsWrongSecret() throws Exception {
 		this.request.addHeader(HEADER, "wrong");
-		assertThat(this.manager.isAllowed(this.serverRequest), equalTo(false));
+		assertThat(this.manager.isAllowed(this.serverRequest)).isFalse();
 	}
 
 	@Test
 	public void disallowsNoSecret() throws Exception {
-		assertThat(this.manager.isAllowed(this.serverRequest), equalTo(false));
+		assertThat(this.manager.isAllowed(this.serverRequest)).isFalse();
 	}
 
 	@Test
 	public void disallowsWrongHeader() throws Exception {
 		this.request.addHeader("X-WRONG", SECRET);
-		assertThat(this.manager.isAllowed(this.serverRequest), equalTo(false));
+		assertThat(this.manager.isAllowed(this.serverRequest)).isFalse();
 	}
 
 }

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/remote/server/HttpStatusHandlerTests.java

@@ -29,8 +29,7 @@ import org.springframework.http.server.ServletServerHttpResponse;
 import org.springframework.mock.web.MockHttpServletRequest;
 import org.springframework.mock.web.MockHttpServletResponse;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link HttpStatusHandler}.
@@ -69,14 +68,14 @@ public class HttpStatusHandlerTests {
 	public void respondsOk() throws Exception {
 		HttpStatusHandler handler = new HttpStatusHandler();
 		handler.handle(this.request, this.response);
-		assertThat(this.servletResponse.getStatus(), equalTo(200));
+		assertThat(this.servletResponse.getStatus()).isEqualTo(200);
 	}
 
 	@Test
 	public void respondsWithStatus() throws Exception {
 		HttpStatusHandler handler = new HttpStatusHandler(HttpStatus.I_AM_A_TEAPOT);
 		handler.handle(this.request, this.response);
-		assertThat(this.servletResponse.getStatus(), equalTo(418));
+		assertThat(this.servletResponse.getStatus()).isEqualTo(418);
 	}
 
 }

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/remote/server/UrlHandlerMapperTests.java

@@ -26,9 +26,7 @@ import org.springframework.http.server.ServerHttpRequest;
 import org.springframework.http.server.ServletServerHttpRequest;
 import org.springframework.mock.web.MockHttpServletRequest;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 
 /**
@@ -70,7 +68,7 @@ public class UrlHandlerMapperTests {
 		UrlHandlerMapper mapper = new UrlHandlerMapper("/tunnel", this.handler);
 		HttpServletRequest servletRequest = new MockHttpServletRequest("GET", "/tunnel");
 		ServerHttpRequest request = new ServletServerHttpRequest(servletRequest);
-		assertThat(mapper.getHandler(request), equalTo(this.handler));
+		assertThat(mapper.getHandler(request)).isEqualTo(this.handler);
 	}
 
 	@Test
@@ -79,7 +77,7 @@ public class UrlHandlerMapperTests {
 		HttpServletRequest servletRequest = new MockHttpServletRequest("GET",
 				"/tunnel/other");
 		ServerHttpRequest request = new ServletServerHttpRequest(servletRequest);
-		assertThat(mapper.getHandler(request), nullValue());
+		assertThat(mapper.getHandler(request)).isNull();
 	}
 
 }

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/ChangeableUrlsTests.java

@@ -24,8 +24,7 @@ import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link ChangeableUrls}.
@@ -40,19 +39,19 @@ public class ChangeableUrlsTests {
 	@Test
 	public void folderUrl() throws Exception {
 		URL url = makeUrl("myproject");
-		assertThat(ChangeableUrls.fromUrls(url).size(), equalTo(1));
+		assertThat(ChangeableUrls.fromUrls(url).size()).isEqualTo(1);
 	}
 
 	@Test
 	public void fileUrl() throws Exception {
 		URL url = this.temporaryFolder.newFile().toURI().toURL();
-		assertThat(ChangeableUrls.fromUrls(url).size(), equalTo(0));
+		assertThat(ChangeableUrls.fromUrls(url).size()).isEqualTo(0);
 	}
 
 	@Test
 	public void httpUrl() throws Exception {
 		URL url = new URL("http://spring.io");
-		assertThat(ChangeableUrls.fromUrls(url).size(), equalTo(0));
+		assertThat(ChangeableUrls.fromUrls(url).size()).isEqualTo(0);
 	}
 
 	@Test
@@ -61,7 +60,7 @@ public class ChangeableUrlsTests {
 				makeUrl("spring-boot-autoconfigure"), makeUrl("spring-boot-actuator"),
 				makeUrl("spring-boot-starter"),
 				makeUrl("spring-boot-starter-some-thing"));
-		assertThat(urls.size(), equalTo(0));
+		assertThat(urls.size()).isEqualTo(0);
 	}
 
 	private URL makeUrl(String name) throws IOException {

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/DefaultRestartInitializerTests.java

@@ -20,10 +20,8 @@ import java.net.URL;
 
 import org.junit.Test;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.not;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
 
 /**
  * Tests for {@link DefaultRestartInitializer}.
@@ -35,7 +33,7 @@ public class DefaultRestartInitializerTests {
 	@Test
 	public void nullForTests() throws Exception {
 		MockRestartInitializer initializer = new MockRestartInitializer(true);
-		assertThat(initializer.getInitialUrls(Thread.currentThread()), nullValue());
+		assertThat(initializer.getInitialUrls(Thread.currentThread())).isNull();
 	}
 
 	@Test
@@ -45,8 +43,8 @@ public class DefaultRestartInitializerTests {
 		Thread thread = new Thread();
 		thread.setName("main");
 		thread.setContextClassLoader(classLoader);
-		assertThat(initializer.isMain(thread), equalTo(true));
-		assertThat(initializer.getInitialUrls(thread), not(nullValue()));
+		assertThat(initializer.isMain(thread)).isTrue();
+		assertThat(initializer.getInitialUrls(thread)).isNotEqualTo(nullValue());
 	}
 
 	@Test
@@ -56,8 +54,8 @@ public class DefaultRestartInitializerTests {
 		Thread thread = new Thread();
 		thread.setName("buscuit");
 		thread.setContextClassLoader(classLoader);
-		assertThat(initializer.isMain(thread), equalTo(false));
-		assertThat(initializer.getInitialUrls(thread), nullValue());
+		assertThat(initializer.isMain(thread)).isFalse();
+		assertThat(initializer.getInitialUrls(thread)).isNull();
 	}
 
 	@Test
@@ -68,8 +66,8 @@ public class DefaultRestartInitializerTests {
 		Thread thread = new Thread();
 		thread.setName("main");
 		thread.setContextClassLoader(classLoader);
-		assertThat(initializer.isMain(thread), equalTo(false));
-		assertThat(initializer.getInitialUrls(thread), nullValue());
+		assertThat(initializer.isMain(thread)).isFalse();
+		assertThat(initializer.getInitialUrls(thread)).isNull();
 	}
 
 	@Test
@@ -86,7 +84,7 @@ public class DefaultRestartInitializerTests {
 		MockRestartInitializer initializer = new MockRestartInitializer(true);
 		StackTraceElement element = new StackTraceElement(className, "someMethod",
 				"someFile", 123);
-		assertThat(initializer.isSkippedStackElement(element), equalTo(expected));
+		assertThat(initializer.isSkippedStackElement(element)).isEqualTo(expected);
 	}
 
 	private static class MockAppClassLoader extends ClassLoader {

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/MainMethodTests.java

@@ -25,8 +25,7 @@ import org.junit.rules.ExpectedException;
 
 import org.springframework.util.ReflectionUtils;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link MainMethod}.
@@ -62,9 +61,9 @@ public class MainMethodTests {
 				Valid.main();
 			}
 		}).test();
-		assertThat(method.getMethod(), equalTo(this.actualMain));
-		assertThat(method.getDeclaringClassName(),
-				equalTo(this.actualMain.getDeclaringClass().getName()));
+		assertThat(method.getMethod()).isEqualTo(this.actualMain);
+		assertThat(method.getDeclaringClassName())
+				.isEqualTo(this.actualMain.getDeclaringClass().getName());
 	}
 
 	@Test

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/OnInitializedRestarterConditionTests.java

@@ -27,8 +27,7 @@ import org.springframework.context.annotation.AnnotationConfigApplicationContext
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.mock;
@@ -53,7 +52,7 @@ public class OnInitializedRestarterConditionTests {
 		Restarter.clearInstance();
 		ConfigurableApplicationContext context = new AnnotationConfigApplicationContext(
 				Config.class);
-		assertThat(context.containsBean("bean"), equalTo(false));
+		assertThat(context.containsBean("bean")).isFalse();
 		context.close();
 	}
 
@@ -62,7 +61,7 @@ public class OnInitializedRestarterConditionTests {
 		Restarter.initialize(new String[0], false, RestartInitializer.NONE);
 		ConfigurableApplicationContext context = new AnnotationConfigApplicationContext(
 				Config.class);
-		assertThat(context.containsBean("bean"), equalTo(false));
+		assertThat(context.containsBean("bean")).isFalse();
 		context.close();
 	}
 
@@ -90,7 +89,7 @@ public class OnInitializedRestarterConditionTests {
 			Restarter.initialize(new String[0], false, initializer);
 			ConfigurableApplicationContext context = new AnnotationConfigApplicationContext(
 					Config.class);
-			assertThat(context.containsBean("bean"), equalTo(true));
+			assertThat(context.containsBean("bean")).isTrue();
 			context.close();
 			synchronized (wait) {
 				wait.notify();

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/RestartApplicationListenerTests.java

@@ -28,10 +28,8 @@ import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.core.Ordered;
 import org.springframework.test.util.ReflectionTestUtils;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.not;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
 import static org.mockito.Mockito.mock;
 
 /**
@@ -54,32 +52,32 @@ public class RestartApplicationListenerTests {
 
 	@Test
 	public void isHighestPriority() throws Exception {
-		assertThat(new RestartApplicationListener().getOrder(),
-				equalTo(Ordered.HIGHEST_PRECEDENCE));
+		assertThat(new RestartApplicationListener().getOrder())
+				.isEqualTo(Ordered.HIGHEST_PRECEDENCE);
 	}
 
 	@Test
 	public void initializeWithReady() throws Exception {
 		testInitialize(false);
-		assertThat(ReflectionTestUtils.getField(Restarter.getInstance(), "args"),
-				equalTo((Object) ARGS));
-		assertThat(Restarter.getInstance().isFinished(), equalTo(true));
+		assertThat(ReflectionTestUtils.getField(Restarter.getInstance(), "args"))
+				.isEqualTo(ARGS);
+		assertThat(Restarter.getInstance().isFinished()).isTrue();
 	}
 
 	@Test
 	public void initializeWithFail() throws Exception {
 		testInitialize(true);
-		assertThat(ReflectionTestUtils.getField(Restarter.getInstance(), "args"),
-				equalTo((Object) ARGS));
-		assertThat(Restarter.getInstance().isFinished(), equalTo(true));
+		assertThat(ReflectionTestUtils.getField(Restarter.getInstance(), "args"))
+				.isEqualTo(ARGS);
+		assertThat(Restarter.getInstance().isFinished()).isTrue();
 	}
 
 	@Test
 	public void disableWithSystemProperty() throws Exception {
 		System.setProperty(ENABLED_PROPERTY, "false");
 		testInitialize(false);
-		assertThat(ReflectionTestUtils.getField(Restarter.getInstance(), "enabled"),
-				equalTo((Object) false));
+		assertThat(ReflectionTestUtils.getField(Restarter.getInstance(), "enabled"))
+				.isEqualTo(false);
 	}
 
 	private void testInitialize(boolean failed) {
@@ -89,8 +87,8 @@ public class RestartApplicationListenerTests {
 		ConfigurableApplicationContext context = mock(
 				ConfigurableApplicationContext.class);
 		listener.onApplicationEvent(new ApplicationStartedEvent(application, ARGS));
-		assertThat(Restarter.getInstance(), not(nullValue()));
-		assertThat(Restarter.getInstance().isFinished(), equalTo(false));
+		assertThat(Restarter.getInstance()).isNotEqualTo(nullValue());
+		assertThat(Restarter.getInstance().isFinished()).isFalse();
 		if (failed) {
 			listener.onApplicationEvent(new ApplicationFailedEvent(application, ARGS,
 					context, new RuntimeException()));

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/RestartScopeInitializerTests.java

@@ -27,8 +27,7 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.event.ContextRefreshedEvent;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link RestartScopeInitializer}.
@@ -49,8 +48,8 @@ public class RestartScopeInitializerTests {
 		context.close();
 		context = runApplication();
 		context.close();
-		assertThat(createCount.get(), equalTo(1));
-		assertThat(refreshCount.get(), equalTo(2));
+		assertThat(createCount.get()).isEqualTo(1);
+		assertThat(refreshCount.get()).isEqualTo(2);
 	}
 
 	private ConfigurableApplicationContext runApplication() {

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/RestarterTests.java

@@ -41,9 +41,7 @@ import org.springframework.stereotype.Component;
 import org.springframework.util.FileCopyUtils;
 import org.springframework.util.StringUtils;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.greaterThan;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.mock;
@@ -94,9 +92,9 @@ public class RestarterTests {
 		thread.start();
 		Thread.sleep(2600);
 		String output = this.out.toString();
-		assertThat(StringUtils.countOccurrencesOf(output, "Tick 0"), greaterThan(1));
-		assertThat(StringUtils.countOccurrencesOf(output, "Tick 1"), greaterThan(1));
-		assertThat(TestRestartListener.restarts, greaterThan(0));
+		assertThat(StringUtils.countOccurrencesOf(output, "Tick 0")).isGreaterThan(1);
+		assertThat(StringUtils.countOccurrencesOf(output, "Tick 1")).isGreaterThan(1);
+		assertThat(TestRestartListener.restarts).isGreaterThan(0);
 	}
 
 	@Test
@@ -105,7 +103,7 @@ public class RestarterTests {
 		ObjectFactory objectFactory = mock(ObjectFactory.class);
 		given(objectFactory.getObject()).willReturn("abc");
 		Object attribute = Restarter.getInstance().getOrAddAttribute("x", objectFactory);
-		assertThat(attribute, equalTo((Object) "abc"));
+		assertThat(attribute).isEqualTo("abc");
 	}
 
 	public void addUrlsMustNotBeNull() throws Exception {
@@ -123,7 +121,7 @@ public class RestarterTests {
 		restarter.restart();
 		ClassLoader classLoader = ((TestableRestarter) restarter)
 				.getRelaunchClassLoader();
-		assertThat(((URLClassLoader) classLoader).getURLs()[0], equalTo(url));
+		assertThat(((URLClassLoader) classLoader).getURLs()[0]).isEqualTo(url);
 	}
 
 	@Test
@@ -142,8 +140,8 @@ public class RestarterTests {
 		restarter.restart();
 		ClassLoader classLoader = ((TestableRestarter) restarter)
 				.getRelaunchClassLoader();
-		assertThat(FileCopyUtils.copyToByteArray(classLoader.getResourceAsStream("f")),
-				equalTo("abc".getBytes()));
+		assertThat(FileCopyUtils.copyToByteArray(classLoader.getResourceAsStream("f")))
+				.isEqualTo("abc".getBytes());
 	}
 
 	@Test
@@ -157,7 +155,7 @@ public class RestarterTests {
 		});
 		ObjectFactory objectFactory = mock(ObjectFactory.class);
 		Object attribute = Restarter.getInstance().getOrAddAttribute("x", objectFactory);
-		assertThat(attribute, equalTo((Object) "abc"));
+		assertThat(attribute).isEqualTo("abc");
 		verifyZeroInteractions(objectFactory);
 	}
 
@@ -173,9 +171,9 @@ public class RestarterTests {
 				ThreadFactory factory = Restarter.getInstance().getThreadFactory();
 				Thread viaFactory = factory.newThread(runnable);
 				// Regular threads will inherit the current thread
-				assertThat(regular.getContextClassLoader(), equalTo(contextClassLoader));
+				assertThat(regular.getContextClassLoader()).isEqualTo(contextClassLoader);
 				// Factory threads should should inherit from the initial thread
-				assertThat(viaFactory.getContextClassLoader(), equalTo(parentLoader));
+				assertThat(viaFactory.getContextClassLoader()).isEqualTo(parentLoader);
 			};
 		};
 		thread.setContextClassLoader(contextClassLoader);
@@ -190,7 +188,7 @@ public class RestarterTests {
 		URL[] urls = new URL[] { new URL("file:/proj/module-a.jar!/") };
 		given(initializer.getInitialUrls(any(Thread.class))).willReturn(urls);
 		Restarter.initialize(new String[0], false, initializer, false);
-		assertThat(Restarter.getInstance().getInitialUrls(), equalTo(urls));
+		assertThat(Restarter.getInstance().getInitialUrls()).isEqualTo(urls);
 	}
 
 	@Component

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/SilentExitExceptionHandlerTests.java

@@ -18,9 +18,7 @@ package org.springframework.boot.devtools.restart;
 
 import org.junit.Test;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.fail;
 
 /**
@@ -41,7 +39,7 @@ public class SilentExitExceptionHandlerTests {
 		};
 		SilentExitExceptionHandler.setup(testThread);
 		testThread.startAndJoin();
-		assertThat(testThread.getThrown(), nullValue());
+		assertThat(testThread.getThrown()).isNull();
 	}
 
 	@Test
@@ -54,7 +52,7 @@ public class SilentExitExceptionHandlerTests {
 		};
 		SilentExitExceptionHandler.setup(testThread);
 		testThread.startAndJoin();
-		assertThat(testThread.getThrown().getMessage(), equalTo("Expected"));
+		assertThat(testThread.getThrown().getMessage()).isEqualTo("Expected");
 	}
 
 	private static abstract class TestThread extends Thread {

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/classloader/ClassLoaderFileTests.java

@@ -22,9 +22,7 @@ import org.junit.rules.ExpectedException;
 
 import org.springframework.boot.devtools.restart.classloader.ClassLoaderFile.Kind;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link ClassLoaderFile}.
@@ -69,22 +67,22 @@ public class ClassLoaderFileTests {
 	@Test
 	public void added() throws Exception {
 		ClassLoaderFile file = new ClassLoaderFile(Kind.ADDED, BYTES);
-		assertThat(file.getKind(), equalTo(ClassLoaderFile.Kind.ADDED));
-		assertThat(file.getContents(), equalTo(BYTES));
+		assertThat(file.getKind()).isEqualTo(ClassLoaderFile.Kind.ADDED);
+		assertThat(file.getContents()).isEqualTo(BYTES);
 	}
 
 	@Test
 	public void modified() throws Exception {
 		ClassLoaderFile file = new ClassLoaderFile(Kind.MODIFIED, BYTES);
-		assertThat(file.getKind(), equalTo(ClassLoaderFile.Kind.MODIFIED));
-		assertThat(file.getContents(), equalTo(BYTES));
+		assertThat(file.getKind()).isEqualTo(ClassLoaderFile.Kind.MODIFIED);
+		assertThat(file.getContents()).isEqualTo(BYTES);
 	}
 
 	@Test
 	public void deleted() throws Exception {
 		ClassLoaderFile file = new ClassLoaderFile(Kind.DELETED, null);
-		assertThat(file.getKind(), equalTo(ClassLoaderFile.Kind.DELETED));
-		assertThat(file.getContents(), nullValue());
+		assertThat(file.getKind()).isEqualTo(ClassLoaderFile.Kind.DELETED);
+		assertThat(file.getContents()).isNull();
 	}
 
 }

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/classloader/ClassLoaderFilesTests.java

@@ -20,8 +20,6 @@ import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
-import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Iterator;
 
 import org.junit.Rule;
@@ -31,10 +29,7 @@ import org.junit.rules.ExpectedException;
 import org.springframework.boot.devtools.restart.classloader.ClassLoaderFile.Kind;
 import org.springframework.boot.devtools.restart.classloader.ClassLoaderFiles.SourceFolder;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.notNullValue;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 
 /**
@@ -65,19 +60,19 @@ public class ClassLoaderFilesTests {
 
 	@Test
 	public void getFileWithNullName() throws Exception {
-		assertThat(this.files.getFile(null), nullValue());
+		assertThat(this.files.getFile(null)).isNull();
 	}
 
 	@Test
 	public void addAndGet() throws Exception {
 		ClassLoaderFile file = new ClassLoaderFile(Kind.ADDED, new byte[10]);
 		this.files.addFile("myfile", file);
-		assertThat(this.files.getFile("myfile"), equalTo(file));
+		assertThat(this.files.getFile("myfile")).isEqualTo(file);
 	}
 
 	@Test
 	public void getMissing() throws Exception {
-		assertThat(this.files.getFile("missing"), nullValue());
+		assertThat(this.files.getFile("missing")).isNull();
 	}
 
 	@Test
@@ -86,7 +81,7 @@ public class ClassLoaderFilesTests {
 		ClassLoaderFile file2 = new ClassLoaderFile(Kind.MODIFIED, new byte[10]);
 		this.files.addFile("myfile", file1);
 		this.files.addFile("myfile", file2);
-		assertThat(this.files.getFile("myfile"), equalTo(file2));
+		assertThat(this.files.getFile("myfile")).isEqualTo(file2);
 	}
 
 	@Test
@@ -95,9 +90,11 @@ public class ClassLoaderFilesTests {
 		ClassLoaderFile file2 = new ClassLoaderFile(Kind.MODIFIED, new byte[10]);
 		this.files.addFile("a", "myfile", file1);
 		this.files.addFile("b", "myfile", file2);
-		assertThat(this.files.getFile("myfile"), equalTo(file2));
-		assertThat(this.files.getOrCreateSourceFolder("a").getFiles().size(), equalTo(0));
-		assertThat(this.files.getOrCreateSourceFolder("b").getFiles().size(), equalTo(1));
+		assertThat(this.files.getFile("myfile")).isEqualTo(file2);
+		assertThat(this.files.getOrCreateSourceFolder("a").getFiles().size())
+				.isEqualTo(0);
+		assertThat(this.files.getOrCreateSourceFolder("b").getFiles().size())
+				.isEqualTo(1);
 	}
 
 	@Test
@@ -113,13 +110,11 @@ public class ClassLoaderFilesTests {
 		Iterator<SourceFolder> sourceFolders = this.files.getSourceFolders().iterator();
 		SourceFolder sourceFolder1 = sourceFolders.next();
 		SourceFolder sourceFolder2 = sourceFolders.next();
-		assertThat(sourceFolders.hasNext(), equalTo(false));
-		assertThat(sourceFolder1.getName(), equalTo("a"));
-		assertThat(sourceFolder2.getName(), equalTo("b"));
-		assertThat(new ArrayList<ClassLoaderFile>(sourceFolder1.getFiles()),
-				equalTo(Arrays.asList(file1, file2)));
-		assertThat(new ArrayList<ClassLoaderFile>(sourceFolder2.getFiles()),
-				equalTo(Arrays.asList(file3, file4)));
+		assertThat(sourceFolders.hasNext()).isFalse();
+		assertThat(sourceFolder1.getName()).isEqualTo("a");
+		assertThat(sourceFolder2.getName()).isEqualTo("b");
+		assertThat(sourceFolder1.getFiles()).containsOnly(file1, file2);
+		assertThat(sourceFolder2.getFiles()).containsOnly(file3, file4);
 	}
 
 	@Test
@@ -133,7 +128,7 @@ public class ClassLoaderFilesTests {
 		ObjectInputStream ois = new ObjectInputStream(
 				new ByteArrayInputStream(bos.toByteArray()));
 		ClassLoaderFiles readObject = (ClassLoaderFiles) ois.readObject();
-		assertThat(readObject.getFile("myfile"), notNullValue());
+		assertThat(readObject.getFile("myfile")).isNotNull();
 	}
 
 	@Test
@@ -149,11 +144,10 @@ public class ClassLoaderFilesTests {
 		Iterator<SourceFolder> sourceFolders = this.files.getSourceFolders().iterator();
 		SourceFolder sourceFolder1 = sourceFolders.next();
 		SourceFolder sourceFolder2 = sourceFolders.next();
-		assertThat(sourceFolders.hasNext(), equalTo(false));
-		assertThat(sourceFolder1.getName(), equalTo("a"));
-		assertThat(sourceFolder2.getName(), equalTo("b"));
-		assertThat(new ArrayList<ClassLoaderFile>(sourceFolder1.getFiles()),
-				equalTo(Arrays.asList(file1, file2)));
+		assertThat(sourceFolders.hasNext()).isFalse();
+		assertThat(sourceFolder1.getName()).isEqualTo("a");
+		assertThat(sourceFolder2.getName()).isEqualTo("b");
+		assertThat(sourceFolder1.getFiles()).containsOnly(file1, file2);
 	}
 
 	@Test
@@ -162,7 +156,7 @@ public class ClassLoaderFilesTests {
 		this.files.addFile("s1", "n2", mock(ClassLoaderFile.class));
 		this.files.addFile("s2", "n3", mock(ClassLoaderFile.class));
 		this.files.addFile("s2", "n1", mock(ClassLoaderFile.class));
-		assertThat(this.files.size(), equalTo(3));
+		assertThat(this.files.size()).isEqualTo(3);
 	}
 
 	@Test
@@ -178,8 +172,8 @@ public class ClassLoaderFilesTests {
 		this.files.addFile("s1", "n2", mock(ClassLoaderFile.class));
 		ClassLoaderFiles copy = new ClassLoaderFiles(this.files);
 		this.files.addFile("s2", "n3", mock(ClassLoaderFile.class));
-		assertThat(this.files.size(), equalTo(3));
-		assertThat(copy.size(), equalTo(2));
+		assertThat(this.files.size()).isEqualTo(3);
+		assertThat(copy.size()).isEqualTo(2);
 	}
 
 }

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/classloader/RestartClassLoaderTests.java

@@ -39,9 +39,7 @@ import org.springframework.boot.devtools.restart.classloader.ClassLoaderFile.Kin
 import org.springframework.util.FileCopyUtils;
 import org.springframework.util.StreamUtils;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.startsWith;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link RestartClassLoader}.
@@ -115,48 +113,47 @@ public class RestartClassLoaderTests {
 	public void getResourceFromReloadableUrl() throws Exception {
 		String content = readString(
 				this.reloadClassLoader.getResourceAsStream(PACKAGE_PATH + "/Sample.txt"));
-		assertThat(content, startsWith("fromchild"));
+		assertThat(content).startsWith("fromchild");
 	}
 
 	@Test
 	public void getResourceFromParent() throws Exception {
 		String content = readString(
 				this.reloadClassLoader.getResourceAsStream(PACKAGE_PATH + "/Parent.txt"));
-		assertThat(content, startsWith("fromparent"));
+		assertThat(content).startsWith("fromparent");
 	}
 
 	@Test
 	public void getResourcesFiltersDuplicates() throws Exception {
 		List<URL> resources = toList(
 				this.reloadClassLoader.getResources(PACKAGE_PATH + "/Sample.txt"));
-		assertThat(resources.size(), equalTo(1));
+		assertThat(resources.size()).isEqualTo(1);
 	}
 
 	@Test
 	public void loadClassFromReloadableUrl() throws Exception {
 		Class<?> loaded = this.reloadClassLoader.loadClass(PACKAGE + ".Sample");
-		assertThat(loaded.getClassLoader(),
-				equalTo((ClassLoader) this.reloadClassLoader));
+		assertThat(loaded.getClassLoader()).isEqualTo(this.reloadClassLoader);
 	}
 
 	@Test
 	public void loadClassFromParent() throws Exception {
 		Class<?> loaded = this.reloadClassLoader.loadClass(PACKAGE + ".SampleParent");
-		assertThat(loaded.getClassLoader(), equalTo(getClass().getClassLoader()));
+		assertThat(loaded.getClassLoader()).isEqualTo(getClass().getClassLoader());
 	}
 
 	@Test
 	public void getDeletedResource() throws Exception {
 		String name = PACKAGE_PATH + "/Sample.txt";
 		this.updatedFiles.addFile(name, new ClassLoaderFile(Kind.DELETED, null));
-		assertThat(this.reloadClassLoader.getResource(name), equalTo(null));
+		assertThat(this.reloadClassLoader.getResource(name)).isEqualTo(null);
 	}
 
 	@Test
 	public void getDeletedResourceAsStream() throws Exception {
 		String name = PACKAGE_PATH + "/Sample.txt";
 		this.updatedFiles.addFile(name, new ClassLoaderFile(Kind.DELETED, null));
-		assertThat(this.reloadClassLoader.getResourceAsStream(name), equalTo(null));
+		assertThat(this.reloadClassLoader.getResourceAsStream(name)).isEqualTo(null);
 	}
 
 	@Test
@@ -165,7 +162,7 @@ public class RestartClassLoaderTests {
 		byte[] bytes = "abc".getBytes();
 		this.updatedFiles.addFile(name, new ClassLoaderFile(Kind.MODIFIED, bytes));
 		URL resource = this.reloadClassLoader.getResource(name);
-		assertThat(FileCopyUtils.copyToByteArray(resource.openStream()), equalTo(bytes));
+		assertThat(FileCopyUtils.copyToByteArray(resource.openStream())).isEqualTo(bytes);
 	}
 
 	@Test
@@ -173,7 +170,7 @@ public class RestartClassLoaderTests {
 		String name = PACKAGE_PATH + "/Sample.txt";
 		this.updatedFiles.addFile(name, new ClassLoaderFile(Kind.DELETED, null));
 		List<URL> resources = toList(this.reloadClassLoader.getResources(name));
-		assertThat(resources.size(), equalTo(0));
+		assertThat(resources.size()).isEqualTo(0);
 	}
 
 	@Test
@@ -182,8 +179,8 @@ public class RestartClassLoaderTests {
 		byte[] bytes = "abc".getBytes();
 		this.updatedFiles.addFile(name, new ClassLoaderFile(Kind.MODIFIED, bytes));
 		List<URL> resources = toList(this.reloadClassLoader.getResources(name));
-		assertThat(FileCopyUtils.copyToByteArray(resources.get(0).openStream()),
-				equalTo(bytes));
+		assertThat(FileCopyUtils.copyToByteArray(resources.get(0).openStream()))
+				.isEqualTo(bytes);
 	}
 
 	@Test
@@ -209,8 +206,7 @@ public class RestartClassLoaderTests {
 				.copyToByteArray(getClass().getResourceAsStream("SampleParent.class"));
 		this.updatedFiles.addFile(name, new ClassLoaderFile(Kind.ADDED, bytes));
 		Class<?> loaded = this.reloadClassLoader.loadClass(PACKAGE + ".SampleParent");
-		assertThat(loaded.getClassLoader(),
-				equalTo((ClassLoader) this.reloadClassLoader));
+		assertThat(loaded.getClassLoader()).isEqualTo(this.reloadClassLoader);
 	}
 
 	private String readString(InputStream in) throws IOException {

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/server/DefaultSourceFolderUrlFilterTests.java

@@ -24,8 +24,7 @@ import java.util.List;
 
 import org.junit.Test;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link DefaultSourceFolderUrlFilter}.
@@ -76,14 +75,14 @@ public class DefaultSourceFolderUrlFilterTests {
 				+ "spring-boot-sample-devtools";
 		URL jarUrl = new URL("jar:file:/Users/me/tmp/"
 				+ "spring-boot-sample-devtools-1.3.0.BUILD-SNAPSHOT.jar!/");
-		assertThat(this.filter.isMatch(sourceFolder, jarUrl), equalTo(true));
+		assertThat(this.filter.isMatch(sourceFolder, jarUrl)).isTrue();
 		URL nestedJarUrl = new URL("jar:file:/Users/me/tmp/"
 				+ "spring-boot-sample-devtools-1.3.0.BUILD-SNAPSHOT.jar!/"
 				+ "lib/spring-boot-1.3.0.BUILD-SNAPSHOT.jar!/");
-		assertThat(this.filter.isMatch(sourceFolder, nestedJarUrl), equalTo(false));
+		assertThat(this.filter.isMatch(sourceFolder, nestedJarUrl)).isFalse();
 		URL fileUrl = new URL("file:/Users/me/tmp/"
 				+ "spring-boot-sample-devtools-1.3.0.BUILD-SNAPSHOT.jar");
-		assertThat(this.filter.isMatch(sourceFolder, fileUrl), equalTo(true));
+		assertThat(this.filter.isMatch(sourceFolder, fileUrl)).isTrue();
 	}
 
 	private void doTest(String sourcePostfix) throws MalformedURLException {
@@ -99,7 +98,8 @@ public class DefaultSourceFolderUrlFilterTests {
 		for (String postfix : COMMON_POSTFIXES) {
 			for (URL url : getUrls(moduleRoot + postfix)) {
 				boolean match = this.filter.isMatch(sourceFolder, url);
-				assertThat(url + " against " + sourceFolder, match, equalTo(expected));
+				assertThat(match).as(url + " against " + sourceFolder)
+						.isEqualTo(expected);
 			}
 		}
 	}

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/server/HttpRestartServerTests.java

@@ -37,9 +37,7 @@ import org.springframework.http.server.ServletServerHttpResponse;
 import org.springframework.mock.web.MockHttpServletRequest;
 import org.springframework.mock.web.MockHttpServletResponse;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.notNullValue;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyZeroInteractions;
 
@@ -92,8 +90,8 @@ public class HttpRestartServerTests {
 		this.server.handle(new ServletServerHttpRequest(request),
 				new ServletServerHttpResponse(response));
 		verify(this.delegate).updateAndRestart(this.filesCaptor.capture());
-		assertThat(this.filesCaptor.getValue().getFile("name"), notNullValue());
-		assertThat(response.getStatus(), equalTo(200));
+		assertThat(this.filesCaptor.getValue().getFile("name")).isNotNull();
+		assertThat(response.getStatus()).isEqualTo(200);
 	}
 
 	@Test
@@ -103,7 +101,7 @@ public class HttpRestartServerTests {
 		this.server.handle(new ServletServerHttpRequest(request),
 				new ServletServerHttpResponse(response));
 		verifyZeroInteractions(this.delegate);
-		assertThat(response.getStatus(), equalTo(500));
+		assertThat(response.getStatus()).isEqualTo(500);
 
 	}
 
@@ -115,7 +113,7 @@ public class HttpRestartServerTests {
 		this.server.handle(new ServletServerHttpRequest(request),
 				new ServletServerHttpResponse(response));
 		verifyZeroInteractions(this.delegate);
-		assertThat(response.getStatus(), equalTo(500));
+		assertThat(response.getStatus()).isEqualTo(500);
 	}
 
 	private byte[] serialize(Object object) throws IOException {

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/restart/server/RestartServerTests.java

@@ -34,9 +34,7 @@ import org.springframework.boot.devtools.restart.classloader.ClassLoaderFile.Kin
 import org.springframework.boot.devtools.restart.classloader.ClassLoaderFiles;
 import org.springframework.util.FileCopyUtils;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.greaterThan;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link RestartServer}.
@@ -76,8 +74,8 @@ public class RestartServerTests {
 		files.addFile("my/module-c", "ClassB.class", fileB);
 		server.updateAndRestart(files);
 		Set<URL> expectedUrls = new LinkedHashSet<URL>(Arrays.asList(url1, url3));
-		assertThat(server.restartUrls, equalTo(expectedUrls));
-		assertThat(server.restartFiles, equalTo(files));
+		assertThat(server.restartUrls).isEqualTo(expectedUrls);
+		assertThat(server.restartFiles).isEqualTo(files);
 	}
 
 	@Test
@@ -95,7 +93,7 @@ public class RestartServerTests {
 		ClassLoaderFile fileA = new ClassLoaderFile(Kind.ADDED, new byte[0]);
 		files.addFile("my/module-a", "ClassA.class", fileA);
 		server.updateAndRestart(files);
-		assertThat(jarFile.lastModified(), greaterThan(startTime - 1000));
+		assertThat(jarFile.lastModified()).isGreaterThan(startTime - 1000);
 	}
 
 	@Test
@@ -114,7 +112,7 @@ public class RestartServerTests {
 		ClassLoaderFile fileA = new ClassLoaderFile(Kind.ADDED, "def".getBytes());
 		files.addFile("my/module-a", "ClassA.class", fileA);
 		server.updateAndRestart(files);
-		assertThat(FileCopyUtils.copyToByteArray(classFile), equalTo("def".getBytes()));
+		assertThat(FileCopyUtils.copyToByteArray(classFile)).isEqualTo("def".getBytes());
 	}
 
 	private static class MockRestartServer extends RestartServer {

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/settings/DevToolsSettingsTests.java

@@ -24,9 +24,7 @@ import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link DevToolsSettings}.
@@ -45,28 +43,30 @@ public class DevToolsSettingsTests {
 	public void includePatterns() throws Exception {
 		DevToolsSettings settings = DevToolsSettings
 				.load(ROOT + "spring-devtools-include.properties");
-		assertThat(settings.isRestartInclude(new URL("file://test/a")), equalTo(true));
-		assertThat(settings.isRestartInclude(new URL("file://test/b")), equalTo(true));
-		assertThat(settings.isRestartInclude(new URL("file://test/c")), equalTo(false));
+		assertThat(settings.isRestartInclude(new URL("file://test/a"))).isTrue();
+		assertThat(settings.isRestartInclude(new URL("file://test/b"))).isTrue();
+		assertThat(settings.isRestartInclude(new URL("file://test/c"))).isFalse();
 	}
 
 	@Test
 	public void excludePatterns() throws Exception {
 		DevToolsSettings settings = DevToolsSettings
 				.load(ROOT + "spring-devtools-exclude.properties");
-		assertThat(settings.isRestartExclude(new URL("file://test/a")), equalTo(true));
-		assertThat(settings.isRestartExclude(new URL("file://test/b")), equalTo(true));
-		assertThat(settings.isRestartExclude(new URL("file://test/c")), equalTo(false));
+		assertThat(settings.isRestartExclude(new URL("file://test/a"))).isTrue();
+		assertThat(settings.isRestartExclude(new URL("file://test/b"))).isTrue();
+		assertThat(settings.isRestartExclude(new URL("file://test/c"))).isFalse();
 	}
 
 	@Test
 	public void defaultIncludePatterns() throws Exception {
 		DevToolsSettings settings = DevToolsSettings.get();
-		assertTrue(settings.isRestartExclude(makeUrl("spring-boot")));
-		assertTrue(settings.isRestartExclude(makeUrl("spring-boot-autoconfigure")));
-		assertTrue(settings.isRestartExclude(makeUrl("spring-boot-actuator")));
-		assertTrue(settings.isRestartExclude(makeUrl("spring-boot-starter")));
-		assertTrue(settings.isRestartExclude(makeUrl("spring-boot-starter-some-thing")));
+		assertThat(settings.isRestartExclude(makeUrl("spring-boot"))).isTrue();
+		assertThat(settings.isRestartExclude(makeUrl("spring-boot-autoconfigure")))
+				.isTrue();
+		assertThat(settings.isRestartExclude(makeUrl("spring-boot-actuator"))).isTrue();
+		assertThat(settings.isRestartExclude(makeUrl("spring-boot-starter"))).isTrue();
+		assertThat(settings.isRestartExclude(makeUrl("spring-boot-starter-some-thing")))
+				.isTrue();
 	}
 
 	private URL makeUrl(String name) throws IOException {

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/tunnel/client/HttpTunnelConnectionTests.java

@@ -36,9 +36,7 @@ import org.springframework.boot.devtools.tunnel.client.HttpTunnelConnection.Tunn
 import org.springframework.http.HttpStatus;
 import org.springframework.util.SocketUtils;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.greaterThan;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
@@ -107,9 +105,9 @@ public class HttpTunnelConnectionTests {
 	public void closeTunnelChangesIsOpen() throws Exception {
 		this.requestFactory.willRespondAfterDelay(1000, HttpStatus.GONE);
 		WritableByteChannel channel = openTunnel(false);
-		assertThat(channel.isOpen(), equalTo(true));
+		assertThat(channel.isOpen()).isTrue();
 		channel.close();
-		assertThat(channel.isOpen(), equalTo(false));
+		assertThat(channel.isOpen()).isFalse();
 	}
 
 	@Test
@@ -129,7 +127,7 @@ public class HttpTunnelConnectionTests {
 		write(channel, "hello");
 		write(channel, "1+1");
 		write(channel, "1+2");
-		assertThat(this.incomingData.toString(), equalTo("hi=2=3"));
+		assertThat(this.incomingData.toString()).isEqualTo("hi=2=3");
 	}
 
 	@Test
@@ -140,8 +138,8 @@ public class HttpTunnelConnectionTests {
 		this.requestFactory.willRespond("hi");
 		TunnelChannel channel = openTunnel(true);
 		write(channel, "hello");
-		assertThat(this.incomingData.toString(), equalTo("hi"));
-		assertThat(this.requestFactory.getExecutedRequests().size(), greaterThan(10));
+		assertThat(this.incomingData.toString()).isEqualTo("hi");
+		assertThat(this.requestFactory.getExecutedRequests().size()).isGreaterThan(10);
 	}
 
 	private void write(TunnelChannel channel, String string) throws IOException {

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/tunnel/client/TunnelClientTests.java

@@ -31,8 +31,7 @@ import org.junit.rules.ExpectedException;
 
 import org.springframework.util.SocketUtils;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
@@ -76,7 +75,7 @@ public class TunnelClientTests {
 		channel.read(buffer);
 		channel.close();
 		this.tunnelConnection.verifyWritten("hello");
-		assertThat(new String(buffer.array()), equalTo("olleh"));
+		assertThat(new String(buffer.array())).isEqualTo("olleh");
 	}
 
 	@Test
@@ -89,8 +88,8 @@ public class TunnelClientTests {
 		channel.close();
 		client.getServerThread().stopAcceptingConnections();
 		client.getServerThread().join(2000);
-		assertThat(this.tunnelConnection.getOpenedTimes(), equalTo(1));
-		assertThat(this.tunnelConnection.isOpen(), equalTo(false));
+		assertThat(this.tunnelConnection.getOpenedTimes()).isEqualTo(1);
+		assertThat(this.tunnelConnection.isOpen()).isFalse();
 	}
 
 	@Test
@@ -101,9 +100,9 @@ public class TunnelClientTests {
 				.open(new InetSocketAddress(this.listenPort));
 		Thread.sleep(200);
 		client.stop();
-		assertThat(this.tunnelConnection.getOpenedTimes(), equalTo(1));
-		assertThat(this.tunnelConnection.isOpen(), equalTo(false));
-		assertThat(channel.read(ByteBuffer.allocate(1)), equalTo(-1));
+		assertThat(this.tunnelConnection.getOpenedTimes()).isEqualTo(1);
+		assertThat(this.tunnelConnection.isOpen()).isFalse();
+		assertThat(channel.read(ByteBuffer.allocate(1))).isEqualTo(-1);
 	}
 
 	@Test
@@ -144,7 +143,7 @@ public class TunnelClientTests {
 
 		public void verifyWritten(byte[] expected) {
 			synchronized (this.written) {
-				assertThat(this.written.toByteArray(), equalTo(expected));
+				assertThat(this.written.toByteArray()).isEqualTo(expected);
 				this.written.reset();
 			}
 		}

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/tunnel/payload/HttpTunnelPayloadForwarderTests.java

@@ -25,8 +25,7 @@ import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link HttpTunnelPayloadForwarder}.
@@ -53,7 +52,7 @@ public class HttpTunnelPayloadForwarderTests {
 		forwarder.forward(payload(1, "he"));
 		forwarder.forward(payload(2, "ll"));
 		forwarder.forward(payload(3, "o"));
-		assertThat(out.toByteArray(), equalTo("hello".getBytes()));
+		assertThat(out.toByteArray()).isEqualTo("hello".getBytes());
 	}
 
 	@Test
@@ -64,7 +63,7 @@ public class HttpTunnelPayloadForwarderTests {
 		forwarder.forward(payload(3, "o"));
 		forwarder.forward(payload(2, "ll"));
 		forwarder.forward(payload(1, "he"));
-		assertThat(out.toByteArray(), equalTo("hello".getBytes()));
+		assertThat(out.toByteArray()).isEqualTo("hello".getBytes());
 	}
 
 	@Test

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/tunnel/payload/HttpTunnelPayloadTests.java

@@ -36,9 +36,7 @@ import org.springframework.http.server.ServletServerHttpResponse;
 import org.springframework.mock.web.MockHttpServletRequest;
 import org.springframework.mock.web.MockHttpServletResponse;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.mock;
@@ -70,14 +68,14 @@ public class HttpTunnelPayloadTests {
 	@Test
 	public void getSequence() throws Exception {
 		HttpTunnelPayload payload = new HttpTunnelPayload(1, ByteBuffer.allocate(1));
-		assertThat(payload.getSequence(), equalTo(1L));
+		assertThat(payload.getSequence()).isEqualTo(1L);
 	}
 
 	@Test
 	public void getData() throws Exception {
 		ByteBuffer data = ByteBuffer.wrap("hello".getBytes());
 		HttpTunnelPayload payload = new HttpTunnelPayload(1, data);
-		assertThat(getData(payload), equalTo(data.array()));
+		assertThat(getData(payload)).isEqualTo(data.array());
 	}
 
 	@Test
@@ -87,8 +85,8 @@ public class HttpTunnelPayloadTests {
 		MockHttpServletResponse servletResponse = new MockHttpServletResponse();
 		HttpOutputMessage response = new ServletServerHttpResponse(servletResponse);
 		payload.assignTo(response);
-		assertThat(servletResponse.getHeader("x-seq"), equalTo("2"));
-		assertThat(servletResponse.getContentAsString(), equalTo("hello"));
+		assertThat(servletResponse.getHeader("x-seq")).isEqualTo("2");
+		assertThat(servletResponse.getContentAsString()).isEqualTo("hello");
 	}
 
 	@Test
@@ -96,7 +94,7 @@ public class HttpTunnelPayloadTests {
 		MockHttpServletRequest servletRequest = new MockHttpServletRequest();
 		HttpInputMessage request = new ServletServerHttpRequest(servletRequest);
 		HttpTunnelPayload payload = HttpTunnelPayload.get(request);
-		assertThat(payload, nullValue());
+		assertThat(payload).isNull();
 	}
 
 	@Test
@@ -116,8 +114,8 @@ public class HttpTunnelPayloadTests {
 		servletRequest.addHeader("x-seq", 123);
 		HttpInputMessage request = new ServletServerHttpRequest(servletRequest);
 		HttpTunnelPayload payload = HttpTunnelPayload.get(request);
-		assertThat(payload.getSequence(), equalTo(123L));
-		assertThat(getData(payload), equalTo("hello".getBytes()));
+		assertThat(payload.getSequence()).isEqualTo(123L);
+		assertThat(getData(payload)).isEqualTo("hello".getBytes());
 	}
 
 	@Test
@@ -130,7 +128,7 @@ public class HttpTunnelPayloadTests {
 		while (payloadData.hasRemaining()) {
 			writeChannel.write(payloadData);
 		}
-		assertThat(out.toByteArray(), equalTo("hello".getBytes()));
+		assertThat(out.toByteArray()).isEqualTo("hello".getBytes());
 	}
 
 	@Test
@@ -139,7 +137,7 @@ public class HttpTunnelPayloadTests {
 		given(channel.read(any(ByteBuffer.class)))
 				.willThrow(new SocketTimeoutException());
 		ByteBuffer payload = HttpTunnelPayload.getPayloadData(channel);
-		assertThat(payload, nullValue());
+		assertThat(payload).isNull();
 	}
 
 	private byte[] getData(HttpTunnelPayload payload) throws IOException {

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/tunnel/server/HttpTunnelServerTests.java

@@ -47,8 +47,7 @@ import org.springframework.http.server.ServletServerHttpResponse;
 import org.springframework.mock.web.MockHttpServletRequest;
 import org.springframework.mock.web.MockHttpServletResponse;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Matchers.anyInt;
 import static org.mockito.Mockito.mock;
@@ -154,7 +153,7 @@ public class HttpTunnelServerTests {
 		this.serverChannel.send("hello");
 		this.serverChannel.disconnect();
 		this.server.getServerThread().join();
-		assertThat(this.servletResponse.getContentAsString(), equalTo("hello"));
+		assertThat(this.servletResponse.getContentAsString()).isEqualTo("hello");
 		this.serverChannel.verifyReceived("hello");
 	}
 
@@ -193,7 +192,7 @@ public class HttpTunnelServerTests {
 		this.server.handle(h1);
 		this.serverChannel.disconnect();
 		this.server.getServerThread().join();
-		assertThat(h1.getServletResponse().getStatus(), equalTo(410));
+		assertThat(h1.getServletResponse().getStatus()).isEqualTo(410);
 	}
 
 	@Test
@@ -204,8 +203,8 @@ public class HttpTunnelServerTests {
 		h2.getServletRequest().addHeader("Content-Type", "application/x-disconnect");
 		this.server.handle(h2);
 		this.server.getServerThread().join();
-		assertThat(h1.getServletResponse().getStatus(), equalTo(410));
-		assertThat(this.serverChannel.isOpen(), equalTo(false));
+		assertThat(h1.getServletResponse().getStatus()).isEqualTo(410);
+		assertThat(this.serverChannel.isOpen()).isFalse();
 	}
 
 	@Test
@@ -217,7 +216,7 @@ public class HttpTunnelServerTests {
 		MockHttpConnection h3 = new MockHttpConnection("2", 3);
 		this.server.handle(h3);
 		h1.waitForResponse();
-		assertThat(h1.getServletResponse().getStatus(), equalTo(429));
+		assertThat(h1.getServletResponse().getStatus()).isEqualTo(429);
 		this.serverChannel.disconnect();
 		this.server.getServerThread().join();
 	}
@@ -246,8 +245,8 @@ public class HttpTunnelServerTests {
 		Thread.sleep(400);
 		this.serverChannel.disconnect();
 		this.server.getServerThread().join();
-		assertThat(h1.getServletResponse().getStatus(), equalTo(204));
-		assertThat(h2.getServletResponse().getStatus(), equalTo(204));
+		assertThat(h1.getServletResponse().getStatus()).isEqualTo(204);
+		assertThat(h2.getServletResponse().getStatus()).isEqualTo(204);
 	}
 
 	@Test
@@ -258,7 +257,7 @@ public class HttpTunnelServerTests {
 		this.server.handle(h1);
 		this.serverChannel.send("hello");
 		this.server.getServerThread().join();
-		assertThat(this.serverChannel.isOpen(), equalTo(false));
+		assertThat(this.serverChannel.isOpen()).isFalse();
 	}
 
 	@Test
@@ -273,9 +272,9 @@ public class HttpTunnelServerTests {
 		HttpConnection connection = new HttpConnection(this.request, this.response);
 		connection.waitForResponse();
 		connection.respond(new HttpTunnelPayload(1, ByteBuffer.wrap("hello".getBytes())));
-		assertThat(this.servletResponse.getStatus(), equalTo(200));
-		assertThat(this.servletResponse.getContentAsString(), equalTo("hello"));
-		assertThat(this.servletResponse.getHeader(SEQ_HEADER), equalTo("1"));
+		assertThat(this.servletResponse.getStatus()).isEqualTo(200);
+		assertThat(this.servletResponse.getContentAsString()).isEqualTo("hello");
+		assertThat(this.servletResponse.getHeader(SEQ_HEADER)).isEqualTo("1");
 	}
 
 	@Test
@@ -283,8 +282,8 @@ public class HttpTunnelServerTests {
 		HttpConnection connection = new HttpConnection(this.request, this.response);
 		connection.waitForResponse();
 		connection.respond(HttpStatus.I_AM_A_TEAPOT);
-		assertThat(this.servletResponse.getStatus(), equalTo(418));
-		assertThat(this.servletResponse.getContentLength(), equalTo(0));
+		assertThat(this.servletResponse.getStatus()).isEqualTo(418);
+		assertThat(this.servletResponse.getContentLength()).isEqualTo(0);
 	}
 
 	@Test
@@ -322,19 +321,19 @@ public class HttpTunnelServerTests {
 
 		};
 		connectionThread.start();
-		assertThat(responded.get(), equalTo(false));
+		assertThat(responded.get()).isFalse();
 		Thread.sleep(sleepBeforeResponse);
 		connection.respond(HttpStatus.NO_CONTENT);
 		connectionThread.join();
-		assertThat(responded.get(), equalTo(true));
+		assertThat(responded.get()).isTrue();
 	}
 
 	@Test
 	public void httpConnectionRunning() throws Exception {
 		HttpConnection connection = new HttpConnection(this.request, this.response);
-		assertThat(connection.isOlderThan(100), equalTo(false));
+		assertThat(connection.isOlderThan(100)).isFalse();
 		Thread.sleep(200);
-		assertThat(connection.isOlderThan(100), equalTo(true));
+		assertThat(connection.isOlderThan(100)).isTrue();
 	}
 
 	/**
@@ -374,7 +373,7 @@ public class HttpTunnelServerTests {
 
 		public void verifyReceived(byte[] expected) {
 			synchronized (this.written) {
-				assertThat(this.written.toByteArray(), equalTo(expected));
+				assertThat(this.written.toByteArray()).isEqualTo(expected);
 				this.written.reset();
 			}
 		}
@@ -466,8 +465,8 @@ public class HttpTunnelServerTests {
 				throws Exception {
 			waitForServletResponse();
 			MockHttpServletResponse resp = getServletResponse();
-			assertThat(resp.getContentAsString(), equalTo(expectedContent));
-			assertThat(resp.getHeader(SEQ_HEADER), equalTo(String.valueOf(expectedSeq)));
+			assertThat(resp.getContentAsString()).isEqualTo(expectedContent);
+			assertThat(resp.getHeader(SEQ_HEADER)).isEqualTo(String.valueOf(expectedSeq));
 		}
 
 		public void waitForServletResponse() throws InterruptedException {

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/tunnel/server/SocketTargetServerConnectionTests.java

@@ -29,10 +29,7 @@ import org.junit.Test;
 
 import org.springframework.util.SocketUtils;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.greaterThanOrEqualTo;
-import static org.hamcrest.Matchers.lessThan;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.fail;
 
 /**
@@ -65,7 +62,7 @@ public class SocketTargetServerConnectionTests {
 		ByteChannel channel = this.connection.open(DEFAULT_TIMEOUT);
 		ByteBuffer buffer = ByteBuffer.allocate(5);
 		channel.read(buffer);
-		assertThat(buffer.array(), equalTo("hello".getBytes()));
+		assertThat(buffer.array()).isEqualTo("hello".getBytes());
 	}
 
 	@Test
@@ -91,8 +88,8 @@ public class SocketTargetServerConnectionTests {
 		catch (SocketTimeoutException ex) {
 			// Expected
 			long runTime = System.currentTimeMillis() - startTime;
-			assertThat(runTime, greaterThanOrEqualTo(10L));
-			assertThat(runTime, lessThan(10000L));
+			assertThat(runTime).isGreaterThanOrEqualTo(10L);
+			assertThat(runTime).isLessThan(10000L);
 		}
 	}
 
@@ -134,7 +131,7 @@ public class SocketTargetServerConnectionTests {
 
 		public void closeAndVerify() throws InterruptedException {
 			close();
-			assertThat(this.actualRead.array(), equalTo(this.expect));
+			assertThat(this.actualRead.array()).isEqualTo(this.expect);
 		}
 
 		public void close() throws InterruptedException {

spring-boot-devtools/src/test/java/org/springframework/boot/devtools/tunnel/server/StaticPortProviderTests.java

@@ -20,8 +20,7 @@ import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link StaticPortProvider}.
@@ -43,7 +42,7 @@ public class StaticPortProviderTests {
 	@Test
 	public void getPort() throws Exception {
 		StaticPortProvider provider = new StaticPortProvider(123);
-		assertThat(provider.getPort(), equalTo(123));
+		assertThat(provider.getPort()).isEqualTo(123);
 	}
 
 }