public void EventsQueueing( IStateMachine <string, int> machine) { const int FirstEvent = 0; const int SecondEvent = 1; bool arrived = false; "establish a passive state machine with transitions"._(() => { machine = new PassiveStateMachine <string, int>(); machine.In("A").On(FirstEvent).Goto("B"); machine.In("B").On(SecondEvent).Goto("C"); machine.In("C").ExecuteOnEntry(() => arrived = true); machine.Initialize("A"); }); "when firing an event onto the state machine"._(() => { machine.Fire(FirstEvent); machine.Fire(SecondEvent); machine.Start(); }); "it should queue event at the end"._(() => arrived.Should().BeTrue("state machine should arrive at destination state")); }
public void CustomTypesForStatesAndEvents( PassiveStateMachine <MyState, MyEvent> machine, bool arrivedInStateB) { "establish a state machine with custom types for states and events"._(() => { machine = new PassiveStateMachine <MyState, MyEvent>(); machine.In(new MyState("A")) .On(new MyEvent(1)).Goto(new MyState("B")); machine.In(new MyState("B")) .ExecuteOnEntry(() => arrivedInStateB = true); machine.Initialize(new MyState("A")); machine.Start(); }); "when using the state machine"._(() => machine.Fire(new MyEvent(1))); "it should use equals to compare states and events"._(() => arrivedInStateB.Should().BeTrue("state B should be current state")); }
public void EventArgument( PassiveStateMachine <int, int> machine, int passedArgument) { const int Event = 3; const int AnotherState = 3; const int Argument = 17; "establish a state machine with an entry action taking an event argument"._(() => { machine = new PassiveStateMachine <int, int>(); machine.In(State) .On(Event).Goto(AnotherState); machine.In(AnotherState) .ExecuteOnEntry((int argument) => passedArgument = argument); }); "when entering the state"._(() => { machine.Initialize(State); machine.Start(); machine.Fire(Event, Argument); }); "it should pass event argument to entry action"._(() => passedArgument.Should().Be(Argument)); }
public void CommonAncestor( PassiveStateMachine <int, int> machine) { const int CommonAncestorState = 0; const int SourceState = 1; const int ParentOfSourceState = 2; const int SiblingOfSourceState = 3; const int DestinationState = 4; const int ParentOfDestinationState = 5; const int SiblingOfDestinationState = 6; const int Event = 0; bool commonAncestorStateLeft = false; "establish a hierarchical state machine"._(() => { machine = new PassiveStateMachine <int, int>(); machine.DefineHierarchyOn(CommonAncestorState) .WithHistoryType(HistoryType.None) .WithInitialSubState(ParentOfSourceState) .WithSubState(ParentOfDestinationState); machine.DefineHierarchyOn(ParentOfSourceState) .WithHistoryType(HistoryType.None) .WithInitialSubState(SourceState) .WithSubState(SiblingOfSourceState); machine.DefineHierarchyOn(ParentOfDestinationState) .WithHistoryType(HistoryType.None) .WithInitialSubState(DestinationState) .WithSubState(SiblingOfDestinationState); machine.In(SourceState) .On(Event).Goto(DestinationState); machine.In(CommonAncestorState) .ExecuteOnExit(() => commonAncestorStateLeft = true); machine.Initialize(SourceState); machine.Start(); }); "when firing an event resulting in a transition with a common ancestor"._(() => machine.Fire(Event)); "the state machine should remain inside common ancestor state"._(() => commonAncestorStateLeft .Should().BeFalse()); }
public void ExitActionWithParameter( PassiveStateMachine <int, int> machine, string parameter) { const string Parameter = "parameter"; "establish a state machine with exit action with parameter on a state"._(() => { machine = new PassiveStateMachine <int, int>(); machine.In(State) .ExecuteOnExitParametrized(p => parameter = p, Parameter) .On(Event).Goto(AnotherState); }); "when leaving the state"._(() => { machine.Initialize(State); machine.Start(); machine.Fire(Event); }); "it should execute the exit action"._(() => parameter.Should().NotBeNull()); "it should pass parameter to the exit action"._(() => parameter.Should().Be(Parameter)); }
public void MultipleExitActions( PassiveStateMachine <int, int> machine, bool exitAction1Executed, bool exitAction2Executed) { "establish a state machine with several exit actions on a state"._(() => { machine = new PassiveStateMachine <int, int>(); machine.In(State) .ExecuteOnExit(() => exitAction1Executed = true) .ExecuteOnExit(() => exitAction2Executed = true) .On(Event).Goto(AnotherState); }); "when leaving the state"._(() => { machine.Initialize(State); machine.Start(); machine.Fire(Event); }); "It should execute all exit actions"._(() => { exitAction1Executed .Should().BeTrue("first action should be executed"); exitAction2Executed .Should().BeTrue("second action should be executed"); }); }
public void NoMatchingGuard( PassiveStateMachine <int, int> machine, CurrentStateExtension currentStateExtension) { bool declined = false; "establish state machine with no matching guard"._(() => { machine = new PassiveStateMachine <int, int>(); currentStateExtension = new CurrentStateExtension(); machine.AddExtension(currentStateExtension); machine.In(SourceState) .On(Event) .If(() => false).Goto(ErrorState); machine.TransitionDeclined += (sender, e) => declined = true; machine.Initialize(SourceState); machine.Start(); }); "when an event is fired"._(() => machine.Fire(Event)); "it should notify about declined transition"._(() => declined.Should().BeTrue("TransitionDeclined event should be fired")); }
public void Start( PassiveStateMachine <int, int> machine, bool entryActionExecuted) { "establish an initialized state machine"._(() => { machine = new PassiveStateMachine <int, int>(); machine.AddExtension(testExtension); machine.In(TestState) .ExecuteOnEntry(() => entryActionExecuted = true); machine.Initialize(TestState); }); "when starting the state machine"._(() => machine.Start()); "should set current state of state machine to state to which it is initialized"._(() => this.testExtension.CurrentState.Should().Be(TestState)); "should execute entry action of state to which state machine is initialized"._(() => entryActionExecuted.Should().BeTrue()); }
public void OtherwiseGuard( PassiveStateMachine <int, int> machine, CurrentStateExtension currentStateExtension) { "establish a state machine with otherwise guard and no machting other guard"._(() => { machine = new PassiveStateMachine <int, int>(); currentStateExtension = new CurrentStateExtension(); machine.AddExtension(currentStateExtension); machine.In(SourceState) .On(Event) .If(() => false).Goto(ErrorState) .Otherwise().Goto(DestinationState); machine.Initialize(SourceState); machine.Start(); }); "when an event is fired"._(() => machine.Fire(Event)); "it should_take_transition_guarded_with_otherwise"._(() => currentStateExtension.CurrentState.Should().Be(DestinationState)); }
public void MultipleEntryActions( PassiveStateMachine <int, int> machine, bool entryAction1Executed, bool entryAction2Executed) { "establish a state machine with several entry actions on a state"._(() => { machine = new PassiveStateMachine <int, int>(); machine.In(State) .ExecuteOnEntry(() => entryAction1Executed = true) .ExecuteOnEntry(() => entryAction2Executed = true); }); "when entering the state"._(() => { machine.Initialize(State); machine.Start(); }); "It should execute all entry actions"._(() => { entryAction1Executed .Should().BeTrue("first action should be executed"); entryAction2Executed .Should().BeTrue("second action should be executed"); }); }
public void MatchingGuard( PassiveStateMachine <int, int> machine, CurrentStateExtension currentStateExtension) { "establish a state machine with guarded transitions"._(() => { machine = new PassiveStateMachine <int, int>(); currentStateExtension = new CurrentStateExtension(); machine.AddExtension(currentStateExtension); machine.In(SourceState) .On(Event) .If(() => false).Goto(ErrorState) .If(() => true).Goto(DestinationState) .If(() => true).Goto(ErrorState) .Otherwise().Goto(ErrorState); machine.Initialize(SourceState); machine.Start(); }); "when an event is fired"._(() => machine.Fire(Event)); "it should take transition guarded with first matching guard"._(() => currentStateExtension.CurrentState.Should().Be(DestinationState)); }
public void EntryActionWithParameter( PassiveStateMachine <int, int> machine, string parameter) { const string Parameter = "parameter"; "establish a state machine with entry action with parameter on a state"._(() => { machine = new PassiveStateMachine <int, int>(); machine.In(State) .ExecuteOnEntryParametrized(p => parameter = p, Parameter); }); "when entering the state"._(() => { machine.Initialize(State); machine.Start(); }); "it should execute the entry action"._(() => parameter.Should().NotBeNull()); "it should pass parameter to the entry action"._(() => parameter.Should().Be(Parameter)); }
public void ExceptionHandling( PassiveStateMachine <int, int> machine, bool exitAction1Executed, bool exitAction2Executed, bool exitAction3Executed) { var exception2 = new Exception(); var exception3 = new Exception(); var receivedException = new List <Exception>(); "establish a state machine with several exit actions on a state and some of them throw an exception"._(() => { machine = new PassiveStateMachine <int, int>(); machine.In(State) .ExecuteOnExit(() => exitAction1Executed = true) .ExecuteOnExit(() => { exitAction2Executed = true; throw exception2; }) .ExecuteOnExit(() => { exitAction3Executed = true; throw exception3; }) .On(Event).Goto(AnotherState); machine.TransitionExceptionThrown += (s, e) => receivedException.Add(e.Exception); }); "when entering the state"._(() => { machine.Initialize(State); machine.Start(); machine.Fire(Event); }); "it should execute all entry actions on entry"._(() => { exitAction1Executed .Should().BeTrue("action 1 should be executed"); exitAction2Executed .Should().BeTrue("action 2 should be executed"); exitAction3Executed .Should().BeTrue("action 3 should be executed"); }); "it should handle all exceptions of all throwing entry actions by firing the TransitionExceptionThrown event"._(() => receivedException .Should().BeEquivalentTo(new object[] { exception2, exception3 })); }
public void Background() { "establish a hierarchical state machine"._(() => { testExtension = new CurrentStateExtension(); machine = new PassiveStateMachine <int, int>(); machine.AddExtension(testExtension); machine.DefineHierarchyOn(SuperState) .WithHistoryType(HistoryType.None) .WithInitialSubState(LeafState); machine.In(SuperState) .ExecuteOnEntry(() => entryActionOfSuperStateExecuted = true); machine.In(LeafState) .ExecuteOnEntry(() => entryActionOfLeafStateExecuted = true); }); }
public void ExecutingTransition( PassiveStateMachine <int, int> machine, string actualParameter, bool exitActionExecuted, bool entryActionExecuted) { "establish a state machine with transitions"._(() => { machine = new PassiveStateMachine <int, int>(); machine.AddExtension(CurrentStateExtension); machine.In(SourceState) .ExecuteOnExit(() => exitActionExecuted = true) .On(Event).Goto(DestinationState).Execute <string>(p => actualParameter = p); machine.In(DestinationState) .ExecuteOnEntry(() => entryActionExecuted = true); machine.Initialize(SourceState); machine.Start(); }); "when firing an event onto the state machine"._(() => machine.Fire(Event, Parameter)); "it should_execute_transition_by_switching_state"._(() => CurrentStateExtension.CurrentState.Should().Be(DestinationState)); "it should_execute_transition_actions"._(() => actualParameter.Should().NotBeNull()); "it should_pass_parameters_to_transition_action"._(() => actualParameter.Should().Be(Parameter)); "it should_execute_exit_action_of_source_state"._(() => exitActionExecuted.Should().BeTrue()); "it should_execute_entry_action_of_destination_state"._(() => entryActionExecuted.Should().BeTrue()); }
public void CustomFactory( PassiveStateMachine <string, int> machine, StandardFactory <string, int> factory) { "establish a custom factory"._(() => { factory = A.Fake <StandardFactory <string, int> >(); }); "when creating a passive state machine"._(() => { machine = new PassiveStateMachine <string, int>("_", factory); machine.In("initial").On(42).Goto("answer"); }); "it should use custom factory to create internal instances"._(() => A.CallTo(factory).MustHaveHappened()); }
public void Initialize( PassiveStateMachine <int, int> machine, bool entryActionExecuted) { "establish a state machine"._(() => { machine = new PassiveStateMachine <int, int>(); machine.AddExtension(testExtension); machine.In(TestState) .ExecuteOnEntry(() => entryActionExecuted = true); }); "when state machine is initialized"._(() => machine.Initialize(TestState)); "should not yet execute any entry actions"._(() => entryActionExecuted.Should().BeFalse()); }
public void EntryAction( PassiveStateMachine <int, int> machine, bool entryActionExecuted) { "establish a state machine with entry action on a state"._(() => { machine = new PassiveStateMachine <int, int>(); machine.In(State) .ExecuteOnEntry(() => entryActionExecuted = true); }); "when entering the state"._(() => { machine.Initialize(State); machine.Start(); }); "it should execute the entry action"._(() => entryActionExecuted.Should().BeTrue()); }
public void ExitAction( PassiveStateMachine <int, int> machine, bool exitActionExecuted) { "establish a state machine with exit action on a state"._(() => { machine = new PassiveStateMachine <int, int>(); machine.In(State) .ExecuteOnExit(() => exitActionExecuted = true) .On(Event).Goto(AnotherState); }); "when leaving the state"._(() => { machine.Initialize(State); machine.Start(); machine.Fire(Event); }); "it should execute the exit action"._(() => exitActionExecuted.Should().BeTrue()); }
public void NoExceptionHandlerRegistered( Exception catchedException) { "establish an exception throwing state machine without a registered exception handler"._(() => { machine = new PassiveStateMachine <int, int>(); machine.In(Values.Source) .On(Values.Event).Execute(() => { throw Values.Exception; }); machine.Initialize(Values.Source); machine.Start(); }); "when an exception occurs"._(() => catchedException = Catch.Exception(() => this.machine.Fire(Values.Event))); "should (re-)throw exception"._(() => catchedException.InnerException .Should().BeSameAs(Values.Exception)); }
public void NoCommonAncestor( PassiveStateMachine <string, int> machine) { const string SourceState = "SourceState"; const string ParentOfSourceState = "ParentOfSourceState"; const string SiblingOfSourceState = "SiblingOfSourceState"; const string DestinationState = "DestinationState"; const string ParentOfDestinationState = "ParentOfDestinationState"; const string SiblingOfDestinationState = "SiblingOfDestinationState"; const string GrandParentOfSourceState = "GrandParentOfSourceState"; const string GrandParentOfDestinationState = "GrandParentOfDestinationState"; const int Event = 0; string log = string.Empty; "establish a hierarchical state machine"._(() => { machine = new PassiveStateMachine <string, int>(); machine.DefineHierarchyOn(ParentOfSourceState) .WithHistoryType(HistoryType.None) .WithInitialSubState(SourceState) .WithSubState(SiblingOfSourceState); machine.DefineHierarchyOn(ParentOfDestinationState) .WithHistoryType(HistoryType.None) .WithInitialSubState(DestinationState) .WithSubState(SiblingOfDestinationState); machine.DefineHierarchyOn(GrandParentOfSourceState) .WithHistoryType(HistoryType.None) .WithInitialSubState(ParentOfSourceState); machine.DefineHierarchyOn(GrandParentOfDestinationState) .WithHistoryType(HistoryType.None) .WithInitialSubState(ParentOfDestinationState); machine.In(SourceState) .ExecuteOnExit(() => log += "exit" + SourceState) .On(Event).Goto(DestinationState); machine.In(ParentOfSourceState) .ExecuteOnExit(() => log += "exit" + ParentOfSourceState); machine.In(DestinationState) .ExecuteOnEntry(() => log += "enter" + DestinationState); machine.In(ParentOfDestinationState) .ExecuteOnEntry(() => log += "enter" + ParentOfDestinationState); machine.In(GrandParentOfSourceState) .ExecuteOnExit(() => log += "exit" + GrandParentOfSourceState); machine.In(GrandParentOfDestinationState) .ExecuteOnEntry(() => log += "enter" + GrandParentOfDestinationState); machine.Initialize(SourceState); machine.Start(); }); "when firing an event resulting in a transition without a common ancestor"._(() => machine.Fire(Event)); "it should execute exit action of source state"._(() => log.Should().Contain("exit" + SourceState)); "it should execute exit action of parents of source state (recursively)"._(() => log .Should().Contain("exit" + ParentOfSourceState) .And.Contain("exit" + GrandParentOfSourceState)); "it should execute entry action of parents of destination state (recursively)"._(() => log.Should().Contain("enter" + ParentOfDestinationState) .And.Contain("enter" + GrandParentOfDestinationState)); "it should execute entry action of destination state"._(() => log.Should().Contain("enter" + DestinationState)); "it should execute actions from source upwards and then downwards to destination state"._(() => { string[] states = { SourceState, ParentOfSourceState, GrandParentOfSourceState, GrandParentOfDestinationState, ParentOfDestinationState, DestinationState }; var statesInOrderOfAppearanceInLog = states .OrderBy(s => log.IndexOf(s.ToString(CultureInfo.InvariantCulture), StringComparison.Ordinal)); statesInOrderOfAppearanceInLog .Should().Equal(states); }); }