Refactor join handling

- Refactor how join is handled
- Add new StateListener for listening entry/exit per State.
- Transition is now passed to next guy from a join state.
- A lot of changes in core machine/factory/executor to support
  this new join handling.
- Fixes #235
- Fixes #237

spring-statemachine-core/src/test/java/org/springframework/statemachine/state/JoinStateTests.java

@@ -16,6 +16,7 @@
 package org.springframework.statemachine.state;
 
 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;
@@ -24,18 +25,22 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.junit.Test;
 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.messaging.Message;
 import org.springframework.statemachine.AbstractStateMachineTests;
 import org.springframework.statemachine.ObjectStateMachine;
+import org.springframework.statemachine.StateMachine;
 import org.springframework.statemachine.StateMachineSystemConstants;
 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.support.StateMachineInterceptorAdapter;
 import org.springframework.statemachine.transition.Transition;
 
 public class JoinStateTests extends AbstractStateMachineTests {
@@ -105,16 +110,17 @@ public class JoinStateTests extends AbstractStateMachineTests {
 		machine.sendEvent(TestEvents.E1);
 		assertThat(listener.stateChangedLatch.await(2, 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));
 
-		listener.reset(3);
+		listener.reset(2);
 		machine.sendEvent(TestEvents.E3);
 		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
-		assertThat(listener.stateChangedCount, is(3));
+		assertThat(listener.stateChangedCount, is(2));
 
 		assertThat(machine.getState().getIds(), contains(TestStates.S4));
 	}
@@ -185,14 +191,128 @@ public class JoinStateTests extends AbstractStateMachineTests {
 		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
 		assertThat(listener.stateChangedCount, is(1));
 
-		listener.reset(3);
+		listener.reset(2);
 		machine.sendEvent(TestEvents.E3);
 		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
+		assertThat(listener.stateChangedCount, is(2));
+
+		assertThat(machine.getState().getIds(), contains(TestStates.S4));
+	}
+
+	@Test
+	@SuppressWarnings("unchecked")
+	public void testMultiJoin1() throws Exception {
+		context.register(BaseConfig.class, Config3.class);
+		context.refresh();
+		ObjectStateMachine<TestStates,TestEvents> machine =
+				context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class);
+		TestListener listener = new TestListener();
+		machine.addStateListener(listener);
+		listener.reset(1);
+		assertThat(machine, notNullValue());
+		machine.start();
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
+		assertThat(listener.stateChangedCount, is(1));
+
+		listener.reset(3);
+		machine.sendEvent(TestEvents.E1);
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
 		assertThat(listener.stateChangedCount, is(3));
 
+		listener.reset(1);
+		machine.sendEvent(TestEvents.E2);
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
+		assertThat(listener.stateChangedCount, is(1));
+
+		listener.reset(2);
+		machine.sendEvent(TestEvents.E3);
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
+		assertThat(listener.stateChangedCount, is(2));
+
 		assertThat(machine.getState().getIds(), contains(TestStates.S4));
 	}
 
+	@Test
+	@SuppressWarnings("unchecked")
+	public void testMultiJoin2() throws Exception {
+		context.register(BaseConfig.class, Config3.class);
+		context.refresh();
+		ObjectStateMachine<TestStates,TestEvents> machine =
+				context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class);
+		TestListener listener = new TestListener();
+		machine.addStateListener(listener);
+		listener.reset(1);
+		assertThat(machine, notNullValue());
+		machine.start();
+		machine.getExtendedState().getVariables().put("foo", "bar");
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
+		assertThat(listener.stateChangedCount, is(1));
+
+		listener.reset(3);
+		machine.sendEvent(TestEvents.E1);
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
+		assertThat(listener.stateChangedCount, is(3));
+
+		listener.reset(1);
+		machine.sendEvent(TestEvents.E2);
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
+		assertThat(listener.stateChangedCount, is(1));
+
+		listener.reset(2);
+		machine.sendEvent(TestEvents.E3);
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
+		assertThat(listener.stateChangedCount, is(2));
+
+		assertThat(machine.getState().getIds(), contains(TestStates.SF));
+	}
+
+	@Test
+	@SuppressWarnings("unchecked")
+	public void testInterceptorPostStateChangeTransitionNotNull() throws Exception {
+		context.register(BaseConfig.class, Config1.class);
+		context.refresh();
+		ObjectStateMachine<TestStates,TestEvents> machine =
+				context.getBean(StateMachineSystemConstants.DEFAULT_ID_STATEMACHINE, ObjectStateMachine.class);
+		TestListener listener = new TestListener();
+		machine.addStateListener(listener);
+
+		final AtomicBoolean nullCheck = new AtomicBoolean(false);
+		machine.addStateMachineInterceptor(new StateMachineInterceptorAdapter<TestStates,TestEvents>() {
+			@Override
+			public void postStateChange(State<TestStates, TestEvents> state, Message<TestEvents> message,
+					Transition<TestStates, TestEvents> transition, StateMachine<TestStates, TestEvents> stateMachine) {
+				if (state.getId() == TestStates.S4) {
+					nullCheck.set(transition == null);
+				}
+				super.postStateChange(state, message, transition, stateMachine);
+			}
+		});
+
+		listener.reset(1);
+		assertThat(machine, notNullValue());
+		machine.start();
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
+		assertThat(listener.stateChangedCount, is(1));
+
+		listener.reset(3);
+		machine.sendEvent(TestEvents.E1);
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
+		assertThat(listener.stateChangedCount, is(3));
+
+		listener.reset(1);
+		machine.sendEvent(TestEvents.E2);
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
+		assertThat(listener.stateChangedCount, is(1));
+
+		listener.reset(2);
+		machine.sendEvent(TestEvents.E3);
+		assertThat(listener.stateChangedLatch.await(2, TimeUnit.SECONDS), is(true));
+		assertThat(listener.stateChangedCount, is(2));
+
+		assertThat(machine.getState().getIds(), contains(TestStates.S4));
+		assertThat("Interceptor postStateChange has null transition", nullCheck.get(), is(false));
+	}
+
 	@Configuration
 	@EnableStateMachine
 	static class Config1 extends EnumStateMachineConfigurerAdapter<TestStates, TestEvents> {
@@ -312,6 +432,71 @@ public class JoinStateTests extends AbstractStateMachineTests {
 
 	}
 
+	@Configuration
+	@EnableStateMachine
+	static class Config3 extends EnumStateMachineConfigurerAdapter<TestStates, TestEvents> {
+
+		@Override
+		public void configure(StateMachineStateConfigurer<TestStates, TestEvents> states) throws Exception {
+			states
+				.withStates()
+					.initial(TestStates.SI)
+					.state(TestStates.S2)
+					.join(TestStates.S3)
+					.state(TestStates.SF)
+					.state(TestStates.S4)
+					.and()
+					.withStates()
+						.parent(TestStates.S2)
+						.initial(TestStates.S20)
+						.end(TestStates.S21)
+						.and()
+					.withStates()
+						.parent(TestStates.S2)
+						.initial(TestStates.S30)
+						.end(TestStates.S31);
+		}
+
+		@Override
+		public void configure(StateMachineTransitionConfigurer<TestStates, TestEvents> transitions) throws Exception {
+			transitions
+				.withExternal()
+					.source(TestStates.SI)
+					.target(TestStates.S2)
+					.event(TestEvents.E1)
+					.and()
+				.withExternal()
+					.source(TestStates.S20)
+					.target(TestStates.S21)
+					.event(TestEvents.E2)
+					.and()
+				.withExternal()
+					.source(TestStates.S30)
+					.target(TestStates.S31)
+					.event(TestEvents.E3)
+					.and()
+				.withJoin()
+					.source(TestStates.S2)
+					.target(TestStates.S3)
+					.and()
+				.withExternal()
+					.source(TestStates.S3)
+					.target(TestStates.SF)
+					.guardExpression("!extendedState.variables.isEmpty()")
+					.and()
+				.withExternal()
+					.source(TestStates.S3)
+					.target(TestStates.S4)
+					.guardExpression("extendedState.variables.isEmpty()")
+					.and()
+				.withExternal()
+					.source(TestStates.S4)
+					.target(TestStates.SI)
+					.event(TestEvents.E4);
+		}
+
+	}
+
 	private static class TestListener extends StateMachineListenerAdapter<TestStates, TestEvents> {
 
 		volatile CountDownLatch stateChangedLatch = new CountDownLatch(1);