public void CurrentChildStateReflectsCurrentStateOfChild()
{
var sm = new StateMachine("state machine");
var initialState = sm.CreateInitialState("initial state");
var state1 = sm.CreateState("state1");
var childSm = state1.CreateChildStateMachine();
var childInitialState = childSm.CreateInitialState("childInitialState");
var childState1 = childSm.CreateState("childState1");
var evt = sm.CreateEvent("evt");
var evt2 = sm.CreateEvent("evt2");
initialState.TransitionOn(evt).To(state1);
childInitialState.TransitionOn(evt).To(childState1);
state1.TransitionOn(evt2).To(initialState);
Assert.AreEqual(initialState, sm.CurrentChildState);
evt.Fire();
Assert.AreEqual(childInitialState, sm.CurrentChildState);
evt.Fire();
Assert.AreEqual(childState1, sm.CurrentChildState);
evt2.Fire();
Assert.AreEqual(initialState, sm.CurrentChildState);
}
public void RecursiveFireDoesNotThrowIfTransitionNotFound()
{
var sm = new StateMachine("sm");
var initialState = sm.CreateInitialState("initialState");
var state1 = sm.CreateState("state1");
var evt = sm.CreateEvent("evt");
var evt2 = sm.CreateEvent("evt2");
initialState.TransitionOn(evt).To(state1).WithHandler(i => Assert.DoesNotThrow(() => evt2.Fire()));
try { evt.TryFire(); } catch { }
}
public void OuterEventTryFireReturnsTrueIfRecursiveTransitionNotFoundAndFiredWithTryFire()
{
var sm = new StateMachine("sm");
var initialState = sm.CreateInitialState("initialState");
var state1 = sm.CreateState("state1");
var evt = sm.CreateEvent("evt");
var evt2 = sm.CreateEvent("evt2");
initialState.TransitionOn(evt).To(state1).WithHandler(i => evt2.TryFire());
Assert.True(evt.TryFire());
}
public void OuterEventFireThrowsIfRecursiveTransitionNotFound()
{
var sm = new StateMachine("sm");
var initialState = sm.CreateInitialState("initialState");
var state1 = sm.CreateState("state1");
var evt = sm.CreateEvent("evt");
var evt2 = sm.CreateEvent("evt2");
initialState.TransitionOn(evt).To(state1).WithHandler(i => evt2.Fire());
var e = Assert.Throws<TransitionNotFoundException>(() => evt.Fire());
Assert.AreEqual(state1, e.From);
Assert.AreEqual(evt2, e.Event);
Assert.AreEqual(sm, e.StateMachine);
}
public void IndicatesWhetherInState()
{
var sm = new StateMachine("State Machine");
var state1 = sm.CreateInitialState("State 1");
var state2 = sm.CreateState("State 2");
var state3 = sm.CreateState("State 3");
var evt = sm.CreateEvent("Event");
var group1 = new StateGroup("Group 1");
var group2 = new StateGroup("Group 2");
state1.AddToGroup(group1);
state2.AddToGroup(group2);
state3.AddToGroup(group2);
state1.TransitionOn(evt).To(state2);
state2.TransitionOn(evt).To(state3);
Assert.True(group1.IsCurrent);
Assert.False(group2.IsCurrent);
evt.Fire();
Assert.False(group1.IsCurrent);
Assert.True(group2.IsCurrent);
evt.Fire();
Assert.False(group1.IsCurrent);
Assert.True(group2.IsCurrent);
}
public void TransitionRaisedWhenTransitionOnChild()
{
var sm = new StateMachine("sm");
var initial = sm.CreateInitialState("initial");
var child = initial.CreateChildStateMachine();
var childInitial = child.CreateInitialState("childInitial");
var childState1 = child.CreateState("childState1");
var evt = sm.CreateEvent("evt");
childInitial.TransitionOn(evt).To(childState1);
TransitionEventArgs<State> ea = null;
sm.Transition += (o, e) =>
{
ea = e;
};
evt.Fire();
Assert.NotNull(ea);
Assert.AreEqual(childInitial, ea.From);
Assert.AreEqual(childState1, ea.To);
Assert.AreEqual(evt, ea.Event);
Assert.False(ea.IsInnerTransition);
}
public void TryFireReturnsFalseIfTransitionNotFound()
{
var sm = new StateMachine("sm");
var initialState = sm.CreateInitialState("initialState");
var evt = sm.CreateEvent("evt");
Assert.False(evt.TryFire());
}
public void ThrowsIfForcedTransitionToAStateBelongingToAChildStateMachine()
{
var sm = new StateMachine("State Machine");
var evt = sm.CreateEvent("Event");
var state = sm.CreateInitialState("Initial State");
var subSm = state.CreateChildStateMachine();
var subState = subSm.CreateInitialState("Child Initial State");
Assert.Throws<InvalidStateTransitionException>(() => sm.ForceTransition(subState, evt));
}
public void EventFireInTransitionHandlerIsQueued()
{
var sm = new StateMachine("sm");
var initial = sm.CreateInitialState("initial");
var state1 = sm.CreateState("state1");
var state2 = sm.CreateState("state2");
var state3 = sm.CreateState("state3");
var evt = sm.CreateEvent("evt");
var evt2 = sm.CreateEvent("evt2");
initial.TransitionOn(evt).To(state1).WithHandler(i => evt2.Fire());
initial.TransitionOn(evt2).To(state2);
state1.TransitionOn(evt2).To(state3);
evt.Fire();
Assert.AreEqual(state3, sm.CurrentState);
}
public void DoesNotThrowIfParentEventUsedInChildStateMachine()
{
var sm = new StateMachine("State Machine");
var state = sm.CreateInitialState("Initial State");
var subSm = state.CreateChildStateMachine();
var subState = subSm.CreateInitialState("Child Initial State");
var evt = sm.CreateEvent("Event");
Assert.DoesNotThrow(() => subState.TransitionOn(evt).To(subState));
}
public void FireThrowsIfTransitionNotFound()
{
var sm = new StateMachine("sm");
var initialState = sm.CreateInitialState("initialState");
var evt = sm.CreateEvent("evt");
var e = Assert.Throws<TransitionNotFoundException>(() => evt.Fire());
Assert.AreEqual(initialState, e.From);
Assert.AreEqual(evt, e.Event);
Assert.AreEqual(sm, e.StateMachine);
}
public void NormalSelfTransitionShouldFireExitAndEntry()
{
var events = new List<string>();
var sm = new StateMachine("State Machine");
var evt = sm.CreateEvent("Event");
var state1 = sm.CreateInitialState("State 1").WithEntry(i => events.Add("State 1 Entry")).WithExit(i => events.Add("State 1 Exit"));
state1.TransitionOn(evt).To(state1).WithHandler(i => events.Add("Transition 1 1"));
evt.Fire();
Assert.That(events, Is.EquivalentTo(new[] { "State 1 Exit", "Transition 1 1", "State 1 Entry" }));
}
public void ThrowsIfChildStateUsedInParentStateMachine()
{
var sm = new StateMachine("State Machine");
var state = sm.CreateInitialState("Initial State");
var subSm = state.CreateChildStateMachine();
var subState = subSm.CreateInitialState("Child Initial State");
var evt = sm.CreateEvent("Event");
var e = Assert.Throws<InvalidStateTransitionException>(() => state.TransitionOn(evt).To(subState));
Assert.AreEqual(state, e.From);
Assert.AreEqual(subState, e.To);
}
public void InnerSelfTransitionOnEventTShouldNotFireExitAndEntry()
{
var events = new List<string>();
var sm = new StateMachine("State Machine");
var evt = sm.CreateEvent<int>("Event");
var state1 = sm.CreateInitialState("State 1").WithEntry(i => events.Add("State 1 Entry")).WithExit(i => events.Add("State 1 Exit"));
state1.InnerSelfTransitionOn(evt).WithHandler(i => events.Add("Transition 1 1 Inner"));
evt.Fire(3);
Assert.That(events, Is.EquivalentTo(new[] { "Transition 1 1 Inner" }));
}
public void CorrectHandlersAreInvokedInNormalTransition()
{
var events = new List<string>();
var sm = new StateMachine("State Machine");
var evt = sm.CreateEvent("Event");
var state1 = sm.CreateInitialState("State 1").WithExit(i => events.Add("State 1 Exit"));
var state2 = sm.CreateState("State 2").WithEntry(i => events.Add("State 2 Entry"));
var transition = state1.TransitionOn(evt).To(state2).WithHandler(i => events.Add("Transition 1 2"));
evt.Fire();
Assert.That(events, Is.EquivalentTo(new[] { "State 1 Exit", "Transition 1 2", "State 2 Entry" }));
}
public void EventTryFireCallsSynchronizerEventFire()
{
var sm = new StateMachine("sm");
var initial = sm.CreateInitialState("initial");
var evt = sm.CreateEvent("evt");
initial.TransitionOn(evt).To(initial);
var synchronizer = new Mock<IStateMachineSynchronizer>();
sm.Synchronizer = synchronizer.Object;
evt.TryFire();
synchronizer.Verify(x => x.FireEvent(It.IsAny<Func<bool>>(), EventFireMethod.TryFire));
}
public void CurrentStateReflectsCurrentState()
{
var sm = new StateMachine("state machine");
var initialState = sm.CreateInitialState("initial state");
var state1 = sm.CreateState("state1");
var evt = sm.CreateEvent("evt");
initialState.TransitionOn(evt).To(state1);
Assert.AreEqual(initialState, sm.CurrentState);
evt.Fire();
Assert.AreEqual(state1, sm.CurrentState);
}
public void ResettingStateMachineRemovesFault()
{
var exception = new Exception("foo");
var sm = new StateMachine("sm");
var initial = sm.CreateInitialState("initial").WithEntry(i => { throw exception; });
var evt = sm.CreateEvent("evt");
initial.TransitionOn(evt).To(initial);
Assert.Throws<TransitionFailedException>(() => evt.TryFire());
sm.Reset();
Assert.False(sm.IsFaulted);
Assert.Null(sm.Fault);
}
public void ResetResetsCurrentStateOfStateMachine()
{
var sm = new StateMachine("sm");
var initial = sm.CreateInitialState("initial");
var state1 = sm.CreateState("state1");
var evt = sm.CreateEvent("evt");
initial.TransitionOn(evt).To(state1);
evt.Fire();
sm.Reset();
Assert.AreEqual(initial, sm.CurrentState);
}
public void TransitionAddedToState()
{
var stateMachine = new StateMachine("State Machine");
var state1 = stateMachine.CreateState("State 1");
var state2 = stateMachine.CreateState("State 2");
var evt = stateMachine.CreateEvent("Event");
state1.TransitionOn(evt).To(state2);
Assert.AreEqual(1, state1.Transitions.Count);
Assert.AreEqual(state1, state1.Transitions[0].From);
Assert.AreEqual(state2, state1.Transitions[0].To);
Assert.AreEqual(evt, state1.Transitions[0].Event);
Assert.False(state1.Transitions[0].IsInnerTransition);
}
public void TransitionIsAbortedIfAnyGuardThrowsAnException()
{
var sm = new StateMachine("sm");
var initial = sm.CreateInitialState("initial");
var state1 = sm.CreateState("state1");
var evt = sm.CreateEvent("evt");
var exception = new Exception("foo");
initial.TransitionOn(evt).To(initial).WithGuard(i => { throw exception; });
initial.TransitionOn(evt).To(state1);
var e = Assert.Throws<Exception>(() => evt.Fire());
Assert.AreEqual(exception, e);
Assert.AreEqual(initial, sm.CurrentState);
}
public void FirstRegisteredTransitionWins()
{
var sm = new StateMachine("state machine");
var initial = sm.CreateInitialState("initial");
var state1 = sm.CreateState("state1");
var state2 = sm.CreateState("state2");
var evt = sm.CreateEvent("evt");
initial.TransitionOn(evt).To(state2);
initial.TransitionOn(evt).To(state1);
evt.Fire();
Assert.AreEqual(state2, sm.CurrentState);
}
public void FuncThrowsExceptionIfEventFireFailed()
{
var sm = new StateMachine("sm");
var initial = sm.CreateInitialState("initial");
var evt = sm.CreateEvent("evt");
var synchronizer = new Mock<IStateMachineSynchronizer>();
Func<bool> fireFunc = null;
synchronizer.Setup(x => x.FireEvent(It.IsAny<Func<bool>>(), EventFireMethod.Fire))
.Callback<Func<bool>, EventFireMethod>((func, _) => fireFunc = func);
sm.Synchronizer = synchronizer.Object;
evt.Fire();
Assert.Throws<TransitionNotFoundException>(() => fireFunc());
}
public void CorrectInfoIsGivenInGuard()
{
TransitionInfo<State> guardInfo = null;
var sm = new StateMachine("State Machine");
var evt = sm.CreateEvent("Event");
var state1 = sm.CreateInitialState("State 1");
var state2 = sm.CreateState("State 2");
state1.TransitionOn(evt).To(state2).WithGuard(i => { guardInfo = i; return true; });
evt.Fire();
Assert.NotNull(guardInfo);
Assert.AreEqual(state1, guardInfo.From);
Assert.AreEqual(state2, guardInfo.To);
Assert.AreEqual(evt, guardInfo.Event);
Assert.False(guardInfo.IsInnerTransition);
}
public void FiresEntryHandlerWithCorrectArgumentsWhenEntered()
{
var sm = new StateMachine("State Machine");
var state1 = sm.CreateInitialState("State 1");
var state2 = sm.CreateState("State 2");
var evt = sm.CreateEvent("Event");
StateHandlerInfo<State> info = null;
var group = new StateGroup("Group")
.WithEntry(i => info = i);
state2.AddToGroup(group);
state1.TransitionOn(evt).To(state2);
evt.Fire();
Assert.NotNull(info);
Assert.AreEqual(state1, info.From);
Assert.AreEqual(state2, info.To);
Assert.AreEqual(evt, info.Event);
}
public void ResetResetsStateOfChildStateMachines()
{
var parent = new StateMachine("parent");
var initialState = parent.CreateInitialState("initialState");
var state1 = parent.CreateState("state1");
var child = state1.CreateChildStateMachine();
var substate1 = child.CreateInitialState("substate1");
var substate2 = child.CreateState("substate2");
var evt = parent.CreateEvent("evt");
initialState.TransitionOn(evt).To(state1);
substate1.TransitionOn(evt).To(substate2);
evt.Fire();
evt.Fire();
parent.Reset();
Assert.IsNull(child.CurrentState);
}
public void IsCurrentIncludesChildStateMachines()
{
var sm = new StateMachine("State Machine");
var state1 = sm.CreateInitialState("State 1");
var subSm = state1.CreateChildStateMachine();
var state11 = subSm.CreateInitialState("State 1.1");
var state12 = subSm.CreateState("State 1.2");
var group = new StateGroup("Group");
state1.AddToGroup(group);
var evt = sm.CreateEvent("Event");
state11.TransitionOn(evt).To(state12);
Assert.True(group.IsCurrent);
evt.Fire();
Assert.True(group.IsCurrent);
}
public void FirstRegisteredTransitionWithTrueGuardWins()
{
var sm = new StateMachine("state machine");
var initial = sm.CreateInitialState("initial");
var state1 = sm.CreateState("state1");
var state2 = sm.CreateState("state2");
var state3 = sm.CreateState("state3");
var state4 = sm.CreateState("state4");
var evt = sm.CreateEvent("evt");
initial.TransitionOn(evt).To(state1).WithGuard(i => false);
initial.TransitionOn(evt).To(state2).WithGuard(i => false);
initial.TransitionOn(evt).To(state3);
initial.TransitionOn(evt).To(state4);
evt.Fire();
Assert.AreEqual(state3, sm.CurrentState);
}
public void TransitionRaisedWhenInnerSelfTransitionOnParent()
{
var sm = new StateMachine("sm");
var initial = sm.CreateInitialState("initial");
var evt = sm.CreateEvent("evt");
initial.InnerSelfTransitionOn(evt);
TransitionEventArgs<State> ea = null;
sm.Transition += (o, e) =>
{
ea = e;
};
evt.Fire();
Assert.NotNull(ea);
Assert.AreEqual(initial, ea.From);
Assert.AreEqual(initial, ea.To);
Assert.AreEqual(evt, ea.Event);
Assert.True(ea.IsInnerTransition);
}
public void StateMachineDoesNotFireEventUntilFuncIsInvoked()
{
var sm = new StateMachine("sm");
var initial = sm.CreateInitialState("initial");
var state1 = sm.CreateState("state1");
var evt = sm.CreateEvent("evt");
initial.TransitionOn(evt).To(state1);
var synchronizer = new Mock<IStateMachineSynchronizer>();
Func<bool> fireFunc = null;
synchronizer.Setup(x => x.FireEvent(It.IsAny<Func<bool>>(), EventFireMethod.Fire))
.Callback<Func<bool>, EventFireMethod>((func, _) => fireFunc = func);
sm.Synchronizer = synchronizer.Object;
evt.Fire();
Assert.AreEqual(initial, sm.CurrentState);
Assert.NotNull(fireFunc);
Assert.True(fireFunc());
Assert.AreEqual(state1, sm.CurrentState);
}
