diff --git a/build.gradle b/build.gradle
index 6e724239..3dfe6504 100644
--- a/build.gradle
+++ b/build.gradle
@@ -565,8 +565,6 @@ configure(sampleProjects()) {
 		}
 		testCompile 'org.springframework.boot:spring-boot-test'
 		testCompile 'org.springframework:spring-test'
-		testCompile 'org.hamcrest:hamcrest-core'
-		testCompile 'org.hamcrest:hamcrest-library'
 		testCompile("org.junit.jupiter:junit-jupiter-api")
 		testCompile("org.junit.jupiter:junit-jupiter-engine")
 	}
diff --git a/spring-statemachine-samples/cdplayer/src/test/java/demo/cdplayer/CdPlayerTests.java b/spring-statemachine-samples/cdplayer/src/test/java/demo/cdplayer/CdPlayerTests.java
index 021f37ae..15867ca6 100644
--- a/spring-statemachine-samples/cdplayer/src/test/java/demo/cdplayer/CdPlayerTests.java
+++ b/spring-statemachine-samples/cdplayer/src/test/java/demo/cdplayer/CdPlayerTests.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2019 the original author or authors.
+ * Copyright 2015-2020 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,12 +15,7 @@
  */
 package demo.cdplayer;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.not;
-import static org.hamcrest.Matchers.startsWith;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.springframework.statemachine.TestUtils.doStartAndAssert;
 import static org.springframework.statemachine.TestUtils.doStopAndAssert;
 
@@ -63,9 +58,9 @@ public class CdPlayerTests {
 
 	@Test
 	public void testInitialState() throws InterruptedException {
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(2));
-		assertThat(machine.getState().getIds(), contains(States.IDLE, States.CLOSED));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(2);
+		assertThat(machine.getState().getIds()).containsExactly(States.IDLE, States.CLOSED);
 		assertLcdStatusStartsWith("No CD");
 	}
 
@@ -73,34 +68,34 @@ public class CdPlayerTests {
 	public void testEjectTwice() throws Exception {
 		listener.reset(1, 0, 0);
 		player.eject();
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(1));
-		assertThat(machine.getState().getIds(), contains(States.IDLE, States.OPEN));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(1);
+		assertThat(machine.getState().getIds()).containsExactly(States.IDLE, States.OPEN);
 		listener.reset(1, 0, 0);
 		player.eject();
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(1));
-		assertThat(machine.getState().getIds(), contains(States.IDLE, States.CLOSED));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(1);
+		assertThat(machine.getState().getIds()).containsExactly(States.IDLE, States.CLOSED);
 	}
 
 	@Test
 	public void testPlayWithCdLoaded() throws Exception {
 		listener.reset(1, 0, 0);
 		player.eject();
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(1));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(1);
 
 		listener.reset(1, 0, 0);
 		player.load(library.getCollection().get(0));
 		player.eject();
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(1));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(1);
 
 		listener.reset(2, 0, 0);
 		player.play();
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(2));
-		assertThat(machine.getState().getIds(), contains(States.BUSY, States.PLAYING));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(2);
+		assertThat(machine.getState().getIds()).containsExactly(States.BUSY, States.PLAYING);
 		assertLcdStatusContains("cd1");
 	}
 
@@ -108,15 +103,15 @@ public class CdPlayerTests {
 	public void testPlayWithCdLoadedDeckOpen() throws Exception {
 		listener.reset(1, 0, 0);
 		player.eject();
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(1));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(1);
 
 		listener.reset(3, 0, 0);
 		player.load(library.getCollection().get(0));
 		player.play();
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(3));
-		assertThat(machine.getState().getIds(), contains(States.BUSY, States.PLAYING));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(3);
+		assertThat(machine.getState().getIds()).containsExactly(States.BUSY, States.PLAYING);
 		assertLcdStatusContains("cd1");
 	}
 
@@ -124,9 +119,9 @@ public class CdPlayerTests {
 	public void testPlayWithNoCdLoaded() throws Exception {
 		listener.reset(0, 0, 0);
 		player.play();
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(0));
-		assertThat(machine.getState().getIds(), contains(States.IDLE, States.CLOSED));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isZero();
+		assertThat(machine.getState().getIds()).containsExactly(States.IDLE, States.CLOSED);
 		assertLcdStatusStartsWith("No CD");
 	}
 
@@ -134,35 +129,35 @@ public class CdPlayerTests {
 	public void testPlayLcdTimeChanges() throws Exception {
 		listener.reset(1, 0, 0);
 		player.eject();
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(1));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(1);
 
 		listener.reset(1, 0, 0);
 		player.load(library.getCollection().get(0));
 		player.eject();
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(1));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(1);
 
 		listener.reset(2, 0, 0);
 		player.play();
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(2));
-		assertThat(machine.getState().getIds(), contains(States.BUSY, States.PLAYING));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(2);
+		assertThat(machine.getState().getIds()).containsExactly(States.BUSY, States.PLAYING);
 		assertLcdStatusContains("cd1");
 
 		listener.reset(0, 0, 0, 0, 1);
-		assertThat(listener.transitionTimerLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.transitionTimerCount, is(1));
+		assertThat(listener.transitionTimerLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.transitionTimerCount).isEqualTo(1);
 		assertLcdStatusContains("00:01");
 
 		listener.reset(0, 0, 0, 0, 1);
-		assertThat(listener.transitionTimerLatch.await(2, TimeUnit.SECONDS), is(true));
+		assertThat(listener.transitionTimerLatch.await(2, TimeUnit.SECONDS)).isTrue();
 		assertLcdStatusContains("00:02");
-		assertThat(listener.transitionTimerCount, is(1));
+		assertThat(listener.transitionTimerCount).isEqualTo(1);
 
 		listener.reset(0, 0, 0, 0, 2);
-		assertThat(listener.transitionTimerLatch.await(4, TimeUnit.SECONDS), is(true));
-		assertThat(listener.transitionTimerCount, is(2));
+		assertThat(listener.transitionTimerLatch.await(4, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.transitionTimerCount).isEqualTo(2);
 		// ok we have some timing problems with
 		// this test, so for now just check it's
 		// not previous
@@ -173,45 +168,45 @@ public class CdPlayerTests {
 	public void testPlayPause() throws Exception {
 		listener.reset(1, 0, 0);
 		player.eject();
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(1));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(1);
 
 		listener.reset(1, 0, 0);
 		player.load(library.getCollection().get(0));
 		player.eject();
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(1));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(1);
 
 		listener.reset(2, 0, 0, 0, 1);
 		player.play();
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(2));
-		assertThat(listener.transitionTimerLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.transitionTimerCount, is(1));
-		assertThat(machine.getState().getIds(), contains(States.BUSY, States.PLAYING));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(2);
+		assertThat(listener.transitionTimerLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.transitionTimerCount).isEqualTo(1);
+		assertThat(machine.getState().getIds()).containsExactly(States.BUSY, States.PLAYING);
 		assertLcdStatusContains("cd1");
 		assertLcdStatusContains("00:01");
 
 		listener.reset(0, 0, 0, 1, 1);
-		assertThat(listener.transitionTimerLatch.await(2, TimeUnit.SECONDS), is(true));
+		assertThat(listener.transitionTimerLatch.await(2, TimeUnit.SECONDS)).isTrue();
 		assertLcdStatusContains("00:02");
-		assertThat(listener.transitionTimerCount, is(1));
+		assertThat(listener.transitionTimerCount).isEqualTo(1);
 
 		listener.reset(1, 0, 0, 0);
 		player.pause();
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(1));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(1);
 		assertLcdStatusContains("00:02");
 
 		listener.reset(1, 0, 0, 1);
 		player.pause();
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(1));
-		assertThat(listener.transitionLatch.await(2, TimeUnit.SECONDS), is(true));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(1);
+		assertThat(listener.transitionLatch.await(2, TimeUnit.SECONDS)).isTrue();
 
 		listener.reset(0, 0, 0, 2, 2);
-		assertThat(listener.transitionTimerLatch.await(2100, TimeUnit.MILLISECONDS), is(true));
-		assertThat(listener.transitionTimerCount, is(2));
+		assertThat(listener.transitionTimerLatch.await(2100, TimeUnit.MILLISECONDS)).isTrue();
+		assertThat(listener.transitionTimerCount).isEqualTo(2);
 		assertLcdStatusNotContains("00:02");
 	}
 
@@ -219,26 +214,26 @@ public class CdPlayerTests {
 	public void testPlayStop() throws Exception {
 		listener.reset(1, 0, 0);
 		player.eject();
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(1));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(1);
 
 		listener.reset(1, 0, 0);
 		player.load(library.getCollection().get(0));
 		player.eject();
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(1));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(1);
 
 		listener.reset(2, 0, 0);
 		player.play();
 
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(2));
-		assertThat(machine.getState().getIds(), contains(States.BUSY, States.PLAYING));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(2);
+		assertThat(machine.getState().getIds()).containsExactly(States.BUSY, States.PLAYING);
 
 		listener.reset(2, 0, 0);
 		player.stop();
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(2));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(2);
 		assertLcdStatusIs("cd1 ");
 	}
 
@@ -247,25 +242,25 @@ public class CdPlayerTests {
 		listener.reset(2, 0, 0);
 		player.eject();
 		player.play();
-		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(2));
-		assertThat(machine.getState().getIds(), contains(States.IDLE, States.CLOSED));
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(2);
+		assertThat(machine.getState().getIds()).containsExactly(States.IDLE, States.CLOSED);
 	}
 
 	private void assertLcdStatusIs(String text) {
-		assertThat(player.getLdcStatus(), is(text));
+		assertThat(player.getLdcStatus()).isEqualTo(text);
 	}
 
 	private void assertLcdStatusStartsWith(String text) {
-		assertThat(player.getLdcStatus(), startsWith(text));
+		assertThat(player.getLdcStatus()).startsWith(text);
 	}
 
 	private void assertLcdStatusContains(String text) {
-		assertThat(player.getLdcStatus(), containsString(text));
+		assertThat(player.getLdcStatus()).contains(text);
 	}
 
 	private void assertLcdStatusNotContains(String text) {
-		assertThat(player.getLdcStatus(), not(containsString(text)));
+		assertThat(player.getLdcStatus()).doesNotContain(text);
 	}
 
 	@SuppressWarnings("unchecked")
@@ -279,7 +274,7 @@ public class CdPlayerTests {
 		library = context.getBean(Library.class);
 		listener = context.getBean(TestListener.class);
 		doStartAndAssert(machine);
-		assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS), is(true));
+		assertThat(listener.stateMachineStartedLatch.await(2, TimeUnit.SECONDS)).isTrue();
 	}
 
 	@AfterEach
diff --git a/spring-statemachine-samples/persist/src/test/java/demo/persist/PersistTests.java b/spring-statemachine-samples/persist/src/test/java/demo/persist/PersistTests.java
index 37842125..bcb3ccf4 100644
--- a/spring-statemachine-samples/persist/src/test/java/demo/persist/PersistTests.java
+++ b/spring-statemachine-samples/persist/src/test/java/demo/persist/PersistTests.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2019 the original author or authors.
+ * Copyright 2015-2020 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,10 +15,7 @@
  */
 package demo.persist;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.is;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.springframework.statemachine.TestUtils.doStartAndAssert;
 
 import java.util.ArrayList;
@@ -56,7 +53,7 @@ public class PersistTests {
 
 	@Test
 	public void testNotStarted() throws Exception {
-		assertThat(commands.state(), is("No state"));
+		assertThat(commands.state()).isEqualTo("No state");
 	}
 
 	@Test
@@ -64,30 +61,30 @@ public class PersistTests {
 		TestListener listener = new TestListener();
 		machine.addStateListener(listener);
 		doStartAndAssert(machine);
-		assertThat(listener.stateChangedLatch.await(3, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateEnteredLatch.await(3, TimeUnit.SECONDS), is(true));
-		assertThat(machine.getState().getIds(), contains("PLACED"));
-		assertThat(listener.statesEntered.size(), is(1));
-		assertThat(listener.statesEntered.get(0).getId(), is("PLACED"));
-		assertThat(listener.statesExited.size(), is(0));
+		assertThat(listener.stateChangedLatch.await(3, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateEnteredLatch.await(3, TimeUnit.SECONDS)).isTrue();
+		assertThat(machine.getState().getIds()).containsExactly("PLACED");
+		assertThat(listener.statesEntered).hasSize(1);
+		assertThat(listener.statesEntered.get(0).getId()).isEqualTo("PLACED");
+		assertThat(listener.statesExited).isEmpty();
 	}
 
 	@Test
 	public void testInitialDbList() {
 		// dataOrder [id=1, state=PLACED]Order [id=2, state=PROCESSING]Order [id=3, state=SENT]Order [id=4, state=DELIVERED]
-		assertThat(persist.listDbEntries(), containsString("PLACED"));
+		assertThat(persist.listDbEntries()).contains("PLACED");
 	}
 
 	@Test
 	public void testUpdate1() {
 		persist.change(1, "PROCESS");
-		assertThat(persist.listDbEntries(), containsString("id=1, state=PROCESSING"));
+		assertThat(persist.listDbEntries()).contains("id=1, state=PROCESSING");
 	}
 
 	@Test
 	public void testUpdate2() {
 		persist.change(2, "SEND");
-		assertThat(persist.listDbEntries(), containsString("id=2, state=SENT"));
+		assertThat(persist.listDbEntries()).contains("id=2, state=SENT");
 	}
 
 	private static class TestListener extends StateMachineListenerAdapter<String, String> {
diff --git a/spring-statemachine-samples/showcase/src/test/java/demo/showcase/ShowcaseTests.java b/spring-statemachine-samples/showcase/src/test/java/demo/showcase/ShowcaseTests.java
index a48356d4..71a659ef 100644
--- a/spring-statemachine-samples/showcase/src/test/java/demo/showcase/ShowcaseTests.java
+++ b/spring-statemachine-samples/showcase/src/test/java/demo/showcase/ShowcaseTests.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2019 the original author or authors.
+ * Copyright 2015-2020 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,9 +15,7 @@
  */
 package demo.showcase;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.is;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll;
 import static org.springframework.statemachine.TestUtils.doStartAndAssert;
 import static org.springframework.statemachine.TestUtils.doStopAndAssert;
@@ -55,14 +53,14 @@ public class ShowcaseTests {
 
 	@Test
 	public void testInitialState() throws Exception {
-		assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(machine.getState().getIds(), contains(States.S0, States.S1, States.S11));
-		assertThat(listener.statesEntered.size(), is(3));
-		assertThat(listener.statesEntered.get(0).getId(), is(States.S0));
-		assertThat(listener.statesEntered.get(1).getId(), is(States.S1));
-		assertThat(listener.statesEntered.get(2).getId(), is(States.S11));
-		assertThat(listener.statesExited.size(), is(0));
+		assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S1, States.S11);
+		assertThat(listener.statesEntered).hasSize(3);
+		assertThat(listener.statesEntered.get(0).getId()).isEqualTo(States.S0);
+		assertThat(listener.statesEntered.get(1).getId()).isEqualTo(States.S1);
+		assertThat(listener.statesEntered.get(2).getId()).isEqualTo(States.S11);
+		assertThat(listener.statesExited).isEmpty();
 	}
 
 	@Test
@@ -72,10 +70,10 @@ public class ShowcaseTests {
 		doSendEventAndConsumeAll(machine, Events.A);
 		// machine.sendEvent(Events.A);
 		// variable foo is 0, guard denies transition
-		assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS), is(false));
-		assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS), is(false));
-		assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS), is(false));
-		assertThat(machine.getState().getIds(), contains(States.S0, States.S1, States.S11));
+		assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS)).isFalse();
+		assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS)).isFalse();
+		assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS)).isFalse();
+		assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S1, States.S11);
 	}
 
 	@Test
@@ -83,12 +81,12 @@ public class ShowcaseTests {
 		testInitialState();
 		listener.reset(1, 2, 2);
 		doSendEventAndConsumeAll(machine, Events.B);
-		assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(listener.statesExited.size(), is(2));
-		assertThat(listener.statesEntered.size(), is(2));
-		assertThat(machine.getState().getIds(), contains(States.S0, States.S1, States.S11));
+		assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.statesExited).hasSize(2);
+		assertThat(listener.statesEntered).hasSize(2);
+		assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S1, States.S11);
 	}
 
 	@Test
@@ -106,14 +104,14 @@ public class ShowcaseTests {
 		listener.stateEnteredLatch.await(1, TimeUnit.SECONDS);
 		listener.stateExitedLatch.await(1, TimeUnit.SECONDS);
 		listener.transitionLatch.await(1, TimeUnit.SECONDS);
-		assertThat(machine.getState().getIds(), contains(States.S0, States.S1, States.S11));
-		assertThat(listener.statesEntered.size(), is(2));
-		assertThat(listener.statesEntered.get(0).getId(), is(States.S1));
-		assertThat(listener.statesEntered.get(1).getId(), is(States.S11));
-		assertThat(listener.statesExited.size(), is(2));
-		assertThat(listener.statesExited.get(0).getId(), is(States.S11));
-		assertThat(listener.statesExited.get(1).getId(), is(States.S1));
-		assertThat(listener.transitionCount, is(2));
+		assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S1, States.S11);
+		assertThat(listener.statesEntered).hasSize(2);
+		assertThat(listener.statesEntered.get(0).getId()).isEqualTo(States.S1);
+		assertThat(listener.statesEntered.get(1).getId()).isEqualTo(States.S11);
+		assertThat(listener.statesExited).hasSize(2);
+		assertThat(listener.statesExited.get(0).getId()).isEqualTo(States.S11);
+		assertThat(listener.statesExited.get(1).getId()).isEqualTo(States.S1);
+		assertThat(listener.transitionCount).isEqualTo(2);
 	}
 
 	@Test
@@ -123,11 +121,11 @@ public class ShowcaseTests {
 		doSendEventAndConsumeAll(machine, Events.C);
 		listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
 		listener.stateEnteredLatch.await(1, TimeUnit.SECONDS);
-		assertThat(machine.getState().getIds(), contains(States.S0, States.S2, States.S21, States.S211));
-		assertThat(listener.statesEntered.size(), is(3));
-		assertThat(listener.statesEntered.get(0).getId(), is(States.S2));
-		assertThat(listener.statesEntered.get(1).getId(), is(States.S21));
-		assertThat(listener.statesEntered.get(2).getId(), is(States.S211));
+		assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S2, States.S21, States.S211);
+		assertThat(listener.statesEntered).hasSize(3);
+		assertThat(listener.statesEntered.get(0).getId()).isEqualTo(States.S2);
+		assertThat(listener.statesEntered.get(1).getId()).isEqualTo(States.S21);
+		assertThat(listener.statesEntered.get(2).getId()).isEqualTo(States.S211);
 	}
 
 	@Test
@@ -136,15 +134,15 @@ public class ShowcaseTests {
 		listener.reset(1, 3, 0);
 		doSendEventAndConsumeAll(machine, Events.C);
 		listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
-		assertThat(machine.getState().getIds(), contains(States.S0, States.S2, States.S21, States.S211));
+		assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S2, States.S21, States.S211);
 		listener.reset(1, 2, 0);
 		doSendEventAndConsumeAll(machine, Events.C);
 		listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
 		listener.stateEnteredLatch.await(1, TimeUnit.SECONDS);
-		assertThat(machine.getState().getIds(), contains(States.S0, States.S1, States.S11));
-		assertThat(listener.statesEntered.size(), is(2));
-		assertThat(listener.statesEntered.get(0).getId(), is(States.S1));
-		assertThat(listener.statesEntered.get(1).getId(), is(States.S11));
+		assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S1, States.S11);
+		assertThat(listener.statesEntered).hasSize(2);
+		assertThat(listener.statesEntered.get(0).getId()).isEqualTo(States.S1);
+		assertThat(listener.statesEntered.get(1).getId()).isEqualTo(States.S11);
 	}
 
 	@Test
@@ -154,12 +152,12 @@ public class ShowcaseTests {
 		doSendEventAndConsumeAll(machine, Events.D);
 		listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
 		listener.stateEnteredLatch.await(1, TimeUnit.SECONDS);
-		assertThat(machine.getState().getIds(), contains(States.S0, States.S1, States.S11));
-		assertThat(listener.statesEntered.size(), is(3));
-		assertThat(listener.statesEntered.get(0).getId(), is(States.S0));
-		assertThat(listener.statesEntered.get(1).getId(), is(States.S1));
-		assertThat(listener.statesEntered.get(2).getId(), is(States.S11));
-		assertThat(listener.statesExited.size(), is(3));
+		assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S1, States.S11);
+		assertThat(listener.statesEntered).hasSize(3);
+		assertThat(listener.statesEntered.get(0).getId()).isEqualTo(States.S0);
+		assertThat(listener.statesEntered.get(1).getId()).isEqualTo(States.S1);
+		assertThat(listener.statesEntered.get(2).getId()).isEqualTo(States.S11);
+		assertThat(listener.statesExited).hasSize(3);
 	}
 
 	@Test
@@ -172,10 +170,10 @@ public class ShowcaseTests {
 		doSendEventAndConsumeAll(machine, Events.D);
 		listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
 		listener.stateEnteredLatch.await(1, TimeUnit.SECONDS);
-		assertThat(machine.getState().getIds(), contains(States.S0, States.S2, States.S21, States.S211));
-		assertThat(listener.statesEntered.size(), is(2));
-		assertThat(listener.statesEntered.get(0).getId(), is(States.S21));
-		assertThat(listener.statesEntered.get(1).getId(), is(States.S211));
+		assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S2, States.S21, States.S211);
+		assertThat(listener.statesEntered).hasSize(2);
+		assertThat(listener.statesEntered.get(0).getId()).isEqualTo(States.S21);
+		assertThat(listener.statesEntered.get(1).getId()).isEqualTo(States.S211);
 	}
 
 	@Test
@@ -186,11 +184,11 @@ public class ShowcaseTests {
 		listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
 		listener.stateEnteredLatch.await(1, TimeUnit.SECONDS);
 		listener.stateExitedLatch.await(1, TimeUnit.SECONDS);
-		assertThat(machine.getState().getIds(), contains(States.S0, States.S1, States.S12));
-		assertThat(listener.statesEntered.size(), is(1));
-		assertThat(listener.statesEntered.get(0).getId(), is(States.S12));
-		assertThat(listener.statesExited.size(), is(1));
-		assertThat(listener.statesExited.get(0).getId(), is(States.S11));
+		assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S1, States.S12);
+		assertThat(listener.statesEntered).hasSize(1);
+		assertThat(listener.statesEntered.get(0).getId()).isEqualTo(States.S12);
+		assertThat(listener.statesExited).hasSize(1);
+		assertThat(listener.statesExited.get(0).getId()).isEqualTo(States.S11);
 	}
 
 	@Test
@@ -199,21 +197,21 @@ public class ShowcaseTests {
 		listener.reset(1, 1, 1);
 		doSendEventAndConsumeAll(machine, Events.I);
 		listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
-		assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(listener.statesEntered.size(), is(1));
-		assertThat(listener.statesExited.size(), is(1));
-		assertThat(machine.getState().getIds(), contains(States.S0, States.S1, States.S12));
+		assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.statesEntered).hasSize(1);
+		assertThat(listener.statesExited).hasSize(1);
+		assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S1, States.S12);
 
 		listener.reset(1, 3, 2);
 		doSendEventAndConsumeAll(machine, Events.I);
-		assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(listener.statesEntered.size(), is(3));
-		assertThat(listener.statesExited.size(), is(2));
-		assertThat(machine.getState().getIds(), contains(States.S0, States.S2, States.S21, States.S212));
+		assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.statesEntered).hasSize(3);
+		assertThat(listener.statesExited).hasSize(2);
+		assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S2, States.S21, States.S212);
 	}
 
 	@Test
@@ -222,8 +220,8 @@ public class ShowcaseTests {
 		listener.reset(0, 0, 0, 1);
 		doSendEventAndConsumeAll(machine, Events.H);
 		listener.transitionLatch.await(1, TimeUnit.SECONDS);
-		assertThat(listener.transitionCount, is(1));
-		assertThat(listener.transitions.get(0).getSource().getId(), is(States.S1));
+		assertThat(listener.transitionCount).isEqualTo(1);
+		assertThat(listener.transitions.get(0).getSource().getId()).isEqualTo(States.S1);
 	}
 
 	@Test
@@ -233,8 +231,8 @@ public class ShowcaseTests {
 		listener.reset(0, 0, 0, 1);
 		doSendEventAndConsumeAll(machine, Events.H);
 		listener.transitionLatch.await(1, TimeUnit.SECONDS);
-		assertThat(listener.transitionCount, is(1));
-		assertThat(listener.transitions.get(0).getSource().getId(), is(States.S0));
+		assertThat(listener.transitionCount).isEqualTo(1);
+		assertThat(listener.transitions.get(0).getSource().getId()).isEqualTo(States.S0);
 	}
 
 	@Test
@@ -246,8 +244,8 @@ public class ShowcaseTests {
 		doSendEventAndConsumeAll(machine, Events.H);
 		doSendEventAndConsumeAll(machine, Events.A);
 		listener.transitionLatch.await(1, TimeUnit.SECONDS);
-		assertThat(listener.transitionCount, is(1));
-		assertThat(listener.transitions.get(0).getSource().getId(), is(States.S0));
+		assertThat(listener.transitionCount).isEqualTo(1);
+		assertThat(listener.transitions.get(0).getSource().getId()).isEqualTo(States.S0);
 	}
 
 	@Test
@@ -256,12 +254,12 @@ public class ShowcaseTests {
 		listener.reset(1, 4, 3, 0);
 		doSendEventAndConsumeAll(machine, Events.E);
 		listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
-		assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(machine.getState().getIds(), contains(States.S0, States.S2, States.S21, States.S211));
-		assertThat(listener.statesExited.size(), is(3));
-		assertThat(listener.statesEntered.size(), is(4));
+		assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S2, States.S21, States.S211);
+		assertThat(listener.statesExited).hasSize(3);
+		assertThat(listener.statesEntered).hasSize(4);
 	}
 
 	@Test
@@ -269,12 +267,12 @@ public class ShowcaseTests {
 		testInitialState();
 		listener.reset(1, 3, 2, 0);
 		doSendEventAndConsumeAll(machine, Events.F);
-		assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(machine.getState().getIds(), contains(States.S0, States.S2, States.S21, States.S211));
-		assertThat(listener.statesExited.size(), is(2));
-		assertThat(listener.statesEntered.size(), is(3));
+		assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S2, States.S21, States.S211);
+		assertThat(listener.statesExited).hasSize(2);
+		assertThat(listener.statesEntered).hasSize(3);
 	}
 
 	@Test
@@ -282,12 +280,12 @@ public class ShowcaseTests {
 		testInitialState();
 		listener.reset(1, 3, 2, 0);
 		doSendEventAndConsumeAll(machine, Events.G);
-		assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(machine.getState().getIds(), contains(States.S0, States.S2, States.S21, States.S211));
-		assertThat(listener.statesExited.size(), is(2));
-		assertThat(listener.statesEntered.size(), is(3));
+		assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateEnteredLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateExitedLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(machine.getState().getIds()).containsExactly(States.S0, States.S2, States.S21, States.S211);
+		assertThat(listener.statesExited).hasSize(2);
+		assertThat(listener.statesEntered).hasSize(3);
 	}
 
 	static class Config {
diff --git a/spring-statemachine-samples/tasks/src/test/java/demo/tasks/TasksTests.java b/spring-statemachine-samples/tasks/src/test/java/demo/tasks/TasksTests.java
index 62eabd5b..08669f96 100644
--- a/spring-statemachine-samples/tasks/src/test/java/demo/tasks/TasksTests.java
+++ b/spring-statemachine-samples/tasks/src/test/java/demo/tasks/TasksTests.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2019 the original author or authors.
+ * Copyright 2015-2020 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,9 +15,7 @@
  */
 package demo.tasks;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.is;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.springframework.statemachine.TestUtils.doStartAndAssert;
 import static org.springframework.statemachine.TestUtils.doStopAndAssert;
 
@@ -64,36 +62,36 @@ public class TasksTests {
 	@Test
 	public void testInitialState() throws InterruptedException {
 		Map<Object, Object> variables = machine.getExtendedState().getVariables();
-		assertThat(variables.size(), is(0));
+		assertThat(variables).isEmpty();
 	}
 
 	@Test
 	public void testRunOnce() throws InterruptedException {
 		listener.reset(8, 8, 0);
 		tasks.run();
-		assertThat(listener.stateEnteredLatch.await(8, TimeUnit.SECONDS), is(true));
-		assertThat(machine.getState().getIds(), contains(States.READY));
+		assertThat(listener.stateEnteredLatch.await(8, TimeUnit.SECONDS)).isTrue();
+		assertThat(machine.getState().getIds()).containsExactly(States.READY);
 		Map<Object, Object> variables = machine.getExtendedState().getVariables();
-		assertThat(variables.size(), is(3));
+		assertThat(variables).hasSize(3);
 	}
 
 	@Test
 	public void testRunTwice() throws InterruptedException {
 		listener.reset(8, 8, 0);
 		tasks.run();
-		assertThat(listener.stateEnteredLatch.await(8, TimeUnit.SECONDS), is(true));
-		assertThat(machine.getState().getIds(), contains(States.READY));
+		assertThat(listener.stateEnteredLatch.await(8, TimeUnit.SECONDS)).isTrue();
+		assertThat(machine.getState().getIds()).containsExactly(States.READY);
 
 		Map<Object, Object> variables = machine.getExtendedState().getVariables();
-		assertThat(variables.size(), is(3));
+		assertThat(variables).hasSize(3);
 
 		listener.reset(8, 8, 0);
 		tasks.run();
-		assertThat(listener.stateEnteredLatch.await(8, TimeUnit.SECONDS), is(true));
-		assertThat(machine.getState().getIds(), contains(States.READY));
+		assertThat(listener.stateEnteredLatch.await(8, TimeUnit.SECONDS)).isTrue();
+		assertThat(machine.getState().getIds()).containsExactly(States.READY);
 
 		variables = machine.getExtendedState().getVariables();
-		assertThat(variables.size(), is(3));
+		assertThat(variables).hasSize(3);
 	}
 
 	@Test
@@ -106,8 +104,8 @@ public class TasksTests {
 
 			boolean await = listener.stateEnteredLatch.await(8, TimeUnit.SECONDS);
 			String reason = "Machine was " + machine + " " + StringUtils.collectionToCommaDelimitedString(listener.statesEntered);
-			assertThat(reason , await, is(true));
-			assertThat(machine.getState().getIds(), contains(States.READY));
+			assertThat(await).isTrue().withFailMessage(reason);
+			assertThat(machine.getState().getIds()).containsExactly(States.READY);
 			log.info("testRunSmoke SMOKE STOP " + i);
 		}
 	}
@@ -117,9 +115,9 @@ public class TasksTests {
 		listener.reset(10, 0, 0);
 		tasks.fail("T1");
 		tasks.run();
-		assertThat(listener.stateChangedLatch.await(6, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(10));
-		assertThat(machine.getState().getIds(), contains(States.READY));
+		assertThat(listener.stateChangedLatch.await(6, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(10);
+		assertThat(machine.getState().getIds()).containsExactly(States.READY);
 	}
 
 	@Test
@@ -127,16 +125,16 @@ public class TasksTests {
 		listener.reset(10, 0, 0);
 		tasks.fail("T2");
 		tasks.run();
-		assertThat(listener.stateChangedLatch.await(6, TimeUnit.SECONDS), is(true));
+		assertThat(listener.stateChangedLatch.await(6, TimeUnit.SECONDS)).isTrue();
 
 		Map<Object, Object> variables = machine.getExtendedState().getVariables();
-		assertThat(variables.size(), is(3));
+		assertThat(variables).hasSize(3);
 
-		assertThat(machine.getState().getIds(), contains(States.ERROR, States.MANUAL));
+		assertThat(machine.getState().getIds()).containsExactly(States.ERROR, States.MANUAL);
 		listener.reset(1, 0, 0);
 		tasks.fix();
-		assertThat(listener.stateChangedLatch.await(6, TimeUnit.SECONDS), is(true));
-		assertThat(machine.getState().getIds(), contains(States.READY));
+		assertThat(listener.stateChangedLatch.await(6, TimeUnit.SECONDS)).isTrue();
+		assertThat(machine.getState().getIds()).containsExactly(States.READY);
 	}
 
 	@SuppressWarnings("unchecked")
@@ -149,9 +147,9 @@ public class TasksTests {
 		tasks = context.getBean(Tasks.class);
 		listener = context.getBean(TestListener.class);
 		doStartAndAssert(machine);
-		assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(1));
-		assertThat(machine.getState().getIds(), contains(States.READY));
+		assertThat(listener.stateChangedLatch.await(1, TimeUnit.SECONDS)).isTrue();
+		assertThat(listener.stateChangedCount).isEqualTo(1);
+		assertThat(machine.getState().getIds()).containsExactly(States.READY);
 	}
 
 	@AfterEach
diff --git a/spring-statemachine-samples/turnstile/src/test/java/demo/turnstile/TurnstileTests.java b/spring-statemachine-samples/turnstile/src/test/java/demo/turnstile/TurnstileTests.java
index 97efe2ec..c6491029 100644
--- a/spring-statemachine-samples/turnstile/src/test/java/demo/turnstile/TurnstileTests.java
+++ b/spring-statemachine-samples/turnstile/src/test/java/demo/turnstile/TurnstileTests.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2019 the original author or authors.
+ * Copyright 2015-2020 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,9 +15,7 @@
  */
 package demo.turnstile;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.is;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.springframework.statemachine.TestUtils.doStartAndAssert;
 import static org.springframework.statemachine.TestUtils.doStopAndAssert;
 
@@ -56,7 +54,7 @@ public class TurnstileTests {
 
 	@Test
 	public void testNotStarted() throws Exception {
-		assertThat(commands.state(), is("No state"));
+		assertThat(commands.state()).isEqualTo("No state");
 	}
 
 	@Test
@@ -64,10 +62,10 @@ public class TurnstileTests {
 		doStartAndAssert(machine);
 		listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
 		listener.stateEnteredLatch.await(1, TimeUnit.SECONDS);
-		assertThat(machine.getState().getIds(), contains(States.LOCKED));
-		assertThat(listener.statesEntered.size(), is(1));
-		assertThat(listener.statesEntered.get(0).getId(), is(States.LOCKED));
-		assertThat(listener.statesExited.size(), is(0));
+		assertThat(machine.getState().getIds()).containsExactly(States.LOCKED);
+		assertThat(listener.statesEntered).hasSize(1);
+		assertThat(listener.statesEntered.get(0).getId()).isEqualTo(States.LOCKED);
+		assertThat(listener.statesExited).isEmpty();
 	}
 
 	static class Config {
diff --git a/spring-statemachine-samples/turnstilereactive/src/test/java/demo/turnstilereactive/TurnstileReactiveTests.java b/spring-statemachine-samples/turnstilereactive/src/test/java/demo/turnstilereactive/TurnstileReactiveTests.java
index b1153e95..aee436f3 100644
--- a/spring-statemachine-samples/turnstilereactive/src/test/java/demo/turnstilereactive/TurnstileReactiveTests.java
+++ b/spring-statemachine-samples/turnstilereactive/src/test/java/demo/turnstilereactive/TurnstileReactiveTests.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 the original author or authors.
+ * Copyright 2019-2020 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,7 +15,7 @@
  */
 package demo.turnstilereactive;
 
-import static org.hamcrest.CoreMatchers.containsString;
+import static org.assertj.core.api.Assertions.assertThat;
 
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -41,7 +41,9 @@ public class TurnstileReactiveTests {
 	@Test
 	public void testState() {
 		webClient.get().uri("/state").exchange()
-			.expectBody(String.class).value(containsString("LOCKED"));
+			.expectBody(String.class).value(body -> {
+				assertThat(body).contains("LOCKED");
+			});
 	}
 
 	@Test
diff --git a/spring-statemachine-samples/washer/src/test/java/demo/washer/WasherTests.java b/spring-statemachine-samples/washer/src/test/java/demo/washer/WasherTests.java
index e3aacda6..893cea5a 100644
--- a/spring-statemachine-samples/washer/src/test/java/demo/washer/WasherTests.java
+++ b/spring-statemachine-samples/washer/src/test/java/demo/washer/WasherTests.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2019 the original author or authors.
+ * Copyright 2015-2020 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,9 +15,7 @@
  */
 package demo.washer;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.is;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.springframework.statemachine.TestUtils.doSendEventAndConsumeAll;
 import static org.springframework.statemachine.TestUtils.doStartAndAssert;
 import static org.springframework.statemachine.TestUtils.doStopAndAssert;
@@ -57,11 +55,11 @@ public class WasherTests {
 	public void testInitialState() throws Exception {
 		listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
 		listener.stateEnteredLatch.await(1, TimeUnit.SECONDS);
-		assertThat(machine.getState().getIds(), contains(States.RUNNING, States.WASHING));
-		assertThat(listener.statesEntered.size(), is(2));
-		assertThat(listener.statesEntered.get(0).getId(), is(States.RUNNING));
-		assertThat(listener.statesEntered.get(1).getId(), is(States.WASHING));
-		assertThat(listener.statesExited.size(), is(0));
+		assertThat(machine.getState().getIds()).containsExactly(States.RUNNING, States.WASHING);
+		assertThat(listener.statesEntered).hasSize(2);
+		assertThat(listener.statesEntered.get(0).getId()).isEqualTo(States.RUNNING);
+		assertThat(listener.statesEntered.get(1).getId()).isEqualTo(States.WASHING);
+		assertThat(listener.statesExited).isEmpty();
 	}
 
 	@Test
@@ -69,7 +67,7 @@ public class WasherTests {
 		listener.reset(1, 0, 0);
 		doSendEventAndConsumeAll(machine, Events.RINSE);
 		listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
-		assertThat(machine.getState().getIds(), contains(States.RUNNING, States.RINSING));
+		assertThat(machine.getState().getIds()).containsExactly(States.RUNNING, States.RINSING);
 	}
 
 	@Test
@@ -81,7 +79,7 @@ public class WasherTests {
 		listener.reset(1, 0, 0);
 		doSendEventAndConsumeAll(machine, Events.CUTPOWER);
 		listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
-		assertThat(machine.getState().getIds(), contains(States.POWEROFF));
+		assertThat(machine.getState().getIds()).containsExactly(States.POWEROFF);
 	}
 
 	@Test
@@ -97,7 +95,7 @@ public class WasherTests {
 		listener.reset(1, 0, 0);
 		doSendEventAndConsumeAll(machine, Events.RESTOREPOWER);
 		listener.stateChangedLatch.await(1, TimeUnit.SECONDS);
-		assertThat(machine.getState().getIds(), contains(States.RUNNING, States.RINSING));
+		assertThat(machine.getState().getIds()).containsExactly(States.RUNNING, States.RINSING);
 	}
 
 	static class Config {