diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/StateMachineTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/StateMachineTests.java index 7e82fb76..81c10a89 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/StateMachineTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/StateMachineTests.java @@ -15,12 +15,14 @@ */ package org.springframework.statemachine; -import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.Matchers.contains; import static org.hamcrest.Matchers.containsInAnyOrder; +import static org.hamcrest.Matchers.is; import static org.hamcrest.Matchers.notNullValue; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; +import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; import org.apache.commons.logging.Log; @@ -37,6 +39,8 @@ import org.springframework.statemachine.config.EnableStateMachine; import org.springframework.statemachine.config.EnumStateMachineConfigurerAdapter; import org.springframework.statemachine.config.builders.StateMachineStateConfigurer; import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer; +import org.springframework.statemachine.listener.StateMachineListenerAdapter; +import org.springframework.statemachine.state.State; public class StateMachineTests extends AbstractStateMachineTests { @@ -78,14 +82,14 @@ public class StateMachineTests extends AbstractStateMachineTests { Thread.sleep(2000); assertThat(testAction2.stateContexts.size(), is(0)); machine.sendEvent(TestEvents.E1); - assertThat(testAction1.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); + assertThat(testAction1.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); assertThat(testAction1.stateContexts.size(), is(1)); - assertThat(testAction2.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); + assertThat(testAction2.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); assertThat(testAction2.stateContexts.size(), is(1)); machine.sendEvent(TestEvents.E2); - assertThat(testAction3.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); + assertThat(testAction3.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); assertThat(testAction3.stateContexts.size(), is(1)); // timer still fires but should not cause transition anymore @@ -95,7 +99,7 @@ public class StateMachineTests extends AbstractStateMachineTests { assertThat(testAction2.stateContexts.size(), is(timedTriggered)); machine.sendEvent(TestEvents.E3); - assertThat(testAction4.onExecuteLatch.await(1, TimeUnit.SECONDS), is(true)); + assertThat(testAction4.onExecuteLatch.await(2, TimeUnit.SECONDS), is(true)); assertThat(testAction4.stateContexts.size(), is(1)); assertThat(testAction2.stateContexts.size(), is(timedTriggered)); @@ -103,22 +107,41 @@ public class StateMachineTests extends AbstractStateMachineTests { @Test @SuppressWarnings("unchecked") - public void testForkJoin() { + public void testForkJoin() throws Exception { context.register(BaseConfig.class, Config3.class); context.refresh(); EnumStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, EnumStateMachine.class); + TestListener listener = new TestListener(); + machine.addStateListener(listener); + assertThat(machine, notNullValue()); + + listener.reset(1); machine.start(); - assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.SI)); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(listener.stateChangedCount, is(1)); + assertThat(machine.getState().getIds(), contains(TestStates.SI)); + + listener.reset(3); machine.sendEvent(TestEvents.E1); + assertThat(listener.stateChangedLatch.await(3, TimeUnit.SECONDS), is(true)); + assertThat(listener.stateChangedCount, is(3)); assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S20, TestStates.S30)); + + listener.reset(1); machine.sendEvent(TestEvents.E2); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(listener.stateChangedCount, is(1)); assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S30)); + + listener.reset(3); machine.sendEvent(TestEvents.E3); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(listener.stateChangedCount, is(3)); assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S4)); } - + private static class LoggingAction implements Action { private static final Log log = LogFactory.getLog(StateMachineTests.LoggingAction.class); @@ -319,5 +342,23 @@ public class StateMachineTests extends AbstractStateMachineTests { } } - + + private static class TestListener extends StateMachineListenerAdapter { + + volatile CountDownLatch stateChangedLatch = new CountDownLatch(1); + volatile int stateChangedCount = 0; + + @Override + public void stateChanged(State from, State to) { + stateChangedCount++; + stateChangedLatch.countDown(); + } + + public void reset(int c1) { + stateChangedLatch = new CountDownLatch(c1); + stateChangedCount = 0; + } + + } + } diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/ForkStateTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/ForkStateTests.java index 86768c27..b58e3657 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/ForkStateTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/ForkStateTests.java @@ -21,6 +21,9 @@ import static org.hamcrest.Matchers.notNullValue; import static org.hamcrest.Matchers.nullValue; import static org.junit.Assert.assertThat; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; + import org.junit.Test; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.Bean; @@ -33,6 +36,7 @@ import org.springframework.statemachine.config.EnableStateMachine; import org.springframework.statemachine.config.EnumStateMachineConfigurerAdapter; import org.springframework.statemachine.config.builders.StateMachineStateConfigurer; import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer; +import org.springframework.statemachine.listener.StateMachineListenerAdapter; public class ForkStateTests extends AbstractStateMachineTests { @@ -43,19 +47,27 @@ public class ForkStateTests extends AbstractStateMachineTests { @Test @SuppressWarnings("unchecked") - public void testForkEventPassed() { + public void testForkEventPassed() throws Exception { context.register(BaseConfig.class, Config1.class); context.refresh(); EnumStateMachine machine = context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, EnumStateMachine.class); + TestListener listener = new TestListener(); + machine.addStateListener(listener); + TestEntryAction s20EntryAction = context.getBean("s20EntryAction", TestEntryAction.class); TestEntryAction s21EntryAction = context.getBean("s21EntryAction", TestEntryAction.class); TestEntryAction s30EntryAction = context.getBean("s30EntryAction", TestEntryAction.class); TestEntryAction s31EntryAction = context.getBean("s31EntryAction", TestEntryAction.class); assertThat(machine, notNullValue()); machine.start(); + + listener.reset(4); machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).setHeader("foo", "bar").build()); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); + assertThat(listener.stateChangedCount, is(4)); + assertThat(machine.getState().getIds(), containsInAnyOrder(TestStates.S2, TestStates.S21, TestStates.S31)); assertThat(s20EntryAction.stateContexts.size(), is(1)); assertThat(s21EntryAction.stateContexts.size(), is(1)); @@ -130,4 +142,22 @@ public class ForkStateTests extends AbstractStateMachineTests { } + static class TestListener extends StateMachineListenerAdapter { + + volatile CountDownLatch stateChangedLatch = new CountDownLatch(1); + volatile int stateChangedCount = 0; + + @Override + public void stateChanged(State from, State to) { + stateChangedLatch.countDown(); + stateChangedCount++; + } + + public void reset(int c1) { + stateChangedLatch = new CountDownLatch(c1); + stateChangedCount = 0; + } + + } + } 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 8d1b8813..7ecaf845 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,3 +1,18 @@ +/* + * Copyright 2015 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ package demo.cdplayer; import static org.hamcrest.Matchers.contains; @@ -44,7 +59,7 @@ public class CdPlayerTests { @Test public void testInitialState() throws InterruptedException { - listener.stateChangedLatch.await(1, TimeUnit.SECONDS); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); assertThat(listener.stateChangedCount, is(2)); assertThat(machine.getState().getIds(), contains(States.IDLE, States.CLOSED)); assertLcdStatusStartsWith("No CD"); @@ -54,12 +69,12 @@ public class CdPlayerTests { public void testEjectTwice() throws Exception { listener.reset(1, 0, 0); player.eject(); - listener.stateChangedLatch.await(1, TimeUnit.SECONDS); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); assertThat(listener.stateChangedCount, is(1)); assertThat(machine.getState().getIds(), contains(States.IDLE, States.OPEN)); listener.reset(1, 0, 0); player.eject(); - listener.stateChangedLatch.await(1, TimeUnit.SECONDS); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); assertThat(listener.stateChangedCount, is(1)); assertThat(machine.getState().getIds(), contains(States.IDLE, States.CLOSED)); } @@ -71,7 +86,7 @@ public class CdPlayerTests { player.load(library.getCollection().get(0)); player.eject(); player.play(); - listener.stateChangedLatch.await(5, TimeUnit.SECONDS); + assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS), is(true)); assertThat(listener.stateChangedCount, is(4)); assertThat(machine.getState().getIds(), contains(States.BUSY, States.PLAYING)); assertLcdStatusContains("cd1"); @@ -83,7 +98,7 @@ public class CdPlayerTests { player.eject(); player.load(library.getCollection().get(0)); player.play(); - listener.stateChangedLatch.await(5, TimeUnit.SECONDS); + assertThat(listener.stateChangedLatch.await(5, TimeUnit.SECONDS), is(true)); assertThat(listener.stateChangedCount, is(4)); assertThat(machine.getState().getIds(), contains(States.BUSY, States.PLAYING)); assertLcdStatusContains("cd1"); @@ -93,7 +108,7 @@ public class CdPlayerTests { public void testPlayWithNoCdLoaded() throws Exception { listener.reset(0, 0, 0); player.play(); - listener.stateChangedLatch.await(1, TimeUnit.SECONDS); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); assertThat(listener.stateChangedCount, is(0)); assertThat(machine.getState().getIds(), contains(States.IDLE, States.CLOSED)); assertLcdStatusStartsWith("No CD"); @@ -106,23 +121,23 @@ public class CdPlayerTests { player.load(library.getCollection().get(0)); player.eject(); player.play(); - listener.stateChangedLatch.await(1, TimeUnit.SECONDS); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); assertThat(listener.stateChangedCount, is(4)); assertThat(machine.getState().getIds(), contains(States.BUSY, States.PLAYING)); assertLcdStatusContains("cd1"); listener.reset(0, 0, 0, 1); - listener.transitionLatch.await(1, TimeUnit.SECONDS); + assertThat(listener.transitionLatch.await(2, TimeUnit.SECONDS), is(true)); assertThat(listener.transitionCount, is(1)); assertLcdStatusContains("00:01"); listener.reset(0, 0, 0, 1); - listener.transitionLatch.await(1, TimeUnit.SECONDS); + assertThat(listener.transitionLatch.await(2, TimeUnit.SECONDS), is(true)); assertLcdStatusContains("00:02"); assertThat(listener.transitionCount, is(1)); listener.reset(0, 0, 0, 2); - listener.transitionLatch.await(3, TimeUnit.SECONDS); + assertThat(listener.transitionLatch.await(4, TimeUnit.SECONDS), is(true)); assertThat(listener.transitionCount, is(2)); // ok we have some timing problems with // this test, so for now just check it's @@ -137,37 +152,37 @@ public class CdPlayerTests { player.load(library.getCollection().get(0)); player.eject(); player.play(); - listener.stateChangedLatch.await(2, TimeUnit.SECONDS); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); assertThat(listener.stateChangedCount, is(4)); assertThat(machine.getState().getIds(), contains(States.BUSY, States.PLAYING)); assertLcdStatusContains("cd1"); listener.reset(0, 0, 0, 1); - listener.transitionLatch.await(2, TimeUnit.SECONDS); + assertThat(listener.transitionLatch.await(2, TimeUnit.SECONDS), is(true)); assertThat(listener.transitionCount, is(1)); assertLcdStatusContains("00:01"); listener.reset(0, 0, 0, 1); - listener.transitionLatch.await(2, TimeUnit.SECONDS); + assertThat(listener.transitionLatch.await(2, TimeUnit.SECONDS), is(true)); assertLcdStatusContains("00:02"); assertThat(listener.transitionCount, is(1)); listener.reset(1, 0, 0, 0); player.pause(); - listener.stateChangedLatch.await(2, TimeUnit.SECONDS); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); assertThat(listener.stateChangedCount, is(1)); assertLcdStatusContains("00:02"); listener.reset(1, 0, 0, 1); player.pause(); - listener.stateChangedLatch.await(2, TimeUnit.SECONDS); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); listener.transitionLatch.await(2, TimeUnit.SECONDS); assertThat(listener.stateChangedCount, is(1)); assertThat(listener.transitionCount, is(1)); listener.reset(0, 0, 0, 2); - listener.transitionLatch.await(2, TimeUnit.SECONDS); + assertThat(listener.transitionLatch.await(2, TimeUnit.SECONDS), is(true)); assertThat(listener.transitionCount, is(2)); assertLcdStatusNotContains("00:02"); } @@ -180,13 +195,13 @@ public class CdPlayerTests { player.eject(); player.play(); - listener.stateChangedLatch.await(1, TimeUnit.SECONDS); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); assertThat(listener.stateChangedCount, is(4)); assertThat(machine.getState().getIds(), contains(States.BUSY, States.PLAYING)); listener.reset(2, 0, 0); player.stop(); - listener.stateChangedLatch.await(1, TimeUnit.SECONDS); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); assertThat(listener.stateChangedCount, is(2)); assertLcdStatusIs("cd1 "); } @@ -196,7 +211,7 @@ public class CdPlayerTests { listener.reset(2, 0, 0); player.eject(); player.play(); - listener.stateChangedLatch.await(1, TimeUnit.SECONDS); + assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true)); assertThat(listener.stateChangedCount, is(2)); assertThat(machine.getState().getIds(), contains(States.IDLE, States.CLOSED)); }