public async Task StateMachineBuiltWithBuilder_Should_RunTheFinalStep() { var dummy = new DummyData(); var machine = StateMachineBuilder.Create <DummyData>() .AddStep(new CounterStep()) .AddStep(new CounterStep()) .AddStep(new CounterStep()) .Build(dummy); Assert.Equal(0, machine.State); Assert.True(await machine.MoveNextAsync()); Assert.Equal(1, machine.State); Assert.True(await machine.MoveNextAsync()); Assert.Equal(2, machine.State); Assert.True(await machine.MoveNextAsync()); Assert.Equal(3, machine.State); Assert.False(await machine.MoveNextAsync()); Assert.Equal(3, machine.State); Assert.False(await machine.MoveNextAsync()); Assert.Equal(3, machine.State); Assert.False(await machine.MoveNextAsync()); Assert.Equal(3, machine.State); Assert.False(await machine.MoveNextAsync()); Assert.Equal(3, dummy.StepCount); }
public Sample() { InitializeComponent(); stateMachineBuilder = new StateMachineBuilder(); stateMachineBuilder.AddState(States.Green) .TransitionOn(Events.Change, States.Yellow) .OnEnter(s => Invoker(() => pnlGreen.BackColor = GreenOn)) .OnExit(s => Invoker(() => pnlGreen.BackColor = GreenOff)) .Timeout(3000, States.Yellow) .InitialState(); stateMachineBuilder.AddState(States.Yellow) .TransitionOn(Events.Change, States.Red) .Timeout(3000, States.Red) .OnEnter(s => Invoker(() => pnlYellow.BackColor = YellowOn)) .OnExit(s => Invoker(() => pnlYellow.BackColor = YellowOff)); stateMachineBuilder.AddState(States.Red) .TransitionOn(Events.Change, States.Green) .Timeout(3000, States.Green) .OnEnter(s => Invoker(() => pnlRed.BackColor = RedOn)) .OnExit(s => Invoker(() => pnlRed.BackColor = RedOff)); stateMachine = new StateMachine("StopLight", stateMachineBuilder); stateMachine.Asynchronous(); }
private static void Main(string[] args) { // Build a state machine with two states: "Hello, world!" and "Goodbye, world!" // Toggle between these two states when the trigger "Toggle state" gets set. // Don't worry, you can use whatever data type you'd like for the state and param ids. StateMachine stateMachine = StateMachineBuilder.Create(). AddState("Hello, world!").GoTo("Goodbye, world!").WhenTrigger("Toggle state"). AddState("Goodbye, world!").GoTo("Hello, world!").WhenTrigger("Toggle state"). Build().As <StateMachine>(); // Enable logging so you can see what goes on inside the state machine stateMachine.LogFlow = true; // Start the state machine, aka enter the first state: "Hello, world!" stateMachine.Start(); // Toggle states by setting the "Toggle state" trigger every second 5 times int count = 5; while (count-- >= 0) { Print.Log(stateMachine.ActiveStateId); Thread.Sleep(1000); stateMachine.SetTrigger("Toggle state"); } }
public void When_Trigger_Does_Not_Exist() { var stateMachine = new StateMachineBuilder().CreateStateMachine<char, int, StateMachineContext<char>>( sm => sm.DefineState('a') .WithTrigger(1, 'b') ); var originalContext = new StateMachineContext<char>('a'); Assert.Throws<InvalidTriggerException<char, int>>(() => stateMachine.Fire(originalContext, 2)); }
public void When_Predicate_Triggering_With_Non_Matching_Value() { var stateMachine = new StateMachineBuilder().CreateStateMachine<char, int, StateMachineContext<char>>( sm => sm.DefineState('a') .WithTrigger(1, (string x) => x == "yes", 'x') .WithTrigger(1, (string x) => x == "no", 'y') ); var originalContext = new StateMachineContext<char>('a'); Assert.Throws<InvalidTriggerException<char, int>>(() => stateMachine.Fire(originalContext, 1, "maybe")); }
public void When_Predicate_Triggering_With_Matching_Value() { var stateMachine = new StateMachineBuilder().CreateStateMachine<char, int, StateMachineContext<char>>( sm => sm.DefineState('a') .WithTrigger(1, (string x) => x == "yes", 'x') .WithTrigger(1, (string x) => x == "no", 'y') ); var originalContext = new StateMachineContext<char>('a'); Assert.Equal('x', stateMachine.Fire(originalContext, 1, "yes").GetState()); Assert.Equal('y', stateMachine.Fire(originalContext, 1, "no").GetState()); }
public void When_Trigger_Exists() { var stateMachine = new StateMachineBuilder().CreateStateMachine<char, int, StateMachineContext<char>>( sm => sm.DefineState('a') .WithTrigger(1, 'b') ); var originalContext = new StateMachineContext<char>('a'); var newContext = stateMachine.Fire(originalContext, 1); Assert.Equal(newContext.GetState(), 'b'); }
public void build_returns_root_state_which_has_added_states_under_it() { IState expectedParent = null; var rootState = new StateMachineBuilder() .State<TestState>() .Enter(state => expectedParent = state.Parent) .End() .Build(); rootState.ChangeState("TestState"); Assert.Equal(rootState, expectedParent); }
public void enter_sets_onEnter_action() { int timesEnterCalled = 0; var rootState = new StateMachineBuilder() .State<TestState>("foo") .Enter(_ => timesEnterCalled++) .End() .Build(); rootState.ChangeState("foo"); Assert.Equal(1, timesEnterCalled); }
public void state_with_type_and_string_has_specified_name() { IState expectedParent = null; var rootState = new StateMachineBuilder() .State<TestState>("test") .Enter(state => expectedParent = state.Parent) .End() .Build(); rootState.ChangeState("test"); Assert.Equal(rootState, expectedParent); }
public void event_sets_up_event() { var timesEventRaised = 0; var rootState = new StateMachineBuilder() .State<TestState>("foo") .Event("newEvent", _ => timesEventRaised++) .End() .Build(); rootState.ChangeState("foo"); rootState.TriggerEvent("newEvent"); Assert.Equal(1, timesEventRaised); }
public void event_passes_correct_arguments() { var expectedString = "test"; var actualString = string.Empty; var testEventArgs = new TestEventArgs(); testEventArgs.TestString = expectedString; var rootState = new StateMachineBuilder() .State<TestState>("foo") .Event<TestEventArgs>("newEvent", (state, eventArgs) => actualString = eventArgs.TestString) .End() .Build(); rootState.ChangeState("foo"); rootState.TriggerEvent("newEvent", testEventArgs); Assert.Equal(expectedString, actualString); }
public void condition_sets_action_for_condition() { var condition = false; var timesConditionActionCalled = 0; var rootState = new StateMachineBuilder() .State<TestState>("foo") .Condition(() => condition, _ => timesConditionActionCalled++) .End() .Build(); rootState.ChangeState("foo"); rootState.Update(1f); condition = true; rootState.Update(1f); Assert.Equal(1, timesConditionActionCalled); }
static void Main(string[] args) { Console.WriteLine("Shark state machine. Press Ctrl-C to exit."); // Set up the state machine var rootState = new StateMachineBuilder() .State<NormalState>("Swimming") .Update((state, time) => { state.OnUpdate(); if (hunger > 5) { state.PushState("Hunting"); } }) .State<HungryState>("Hunting") .Update((state, time) => { state.OnUpdate(); if (hunger <= 5) { state.Parent.PopState(); return; } }) .End() .End() .Build(); // Set the initial state. rootState.ChangeState("Swimming"); // Update the state machine at a set interval. while (true) { rootState.Update(1.0f); Thread.Sleep(1000); } }
public void Setup() { smb = new StateMachineBuilder(); events = new List<string>(); }
public new void BaseSetup() { smb = new StateMachineBuilder(); }
public void update_sets_onUpdate_action() { int timesUpdateCalled = 0; var rootState = new StateMachineBuilder() .State<TestState>("foo") .Update((state, dt) => timesUpdateCalled++) .End() .Build(); rootState.ChangeState("foo"); rootState.Update(1f); Assert.Equal(1, timesUpdateCalled); }
public void triggering_event_with_incorrect_type_of_EventArgs_throws_exception() { var expectedString = "test"; var actualString = string.Empty; var testEventArgs = new TestEventArgs(); testEventArgs.TestString = expectedString; var rootState = new StateMachineBuilder() .State<TestState>("foo") .Event<SecondTestEventArgs>("newEvent", (state, eventArgs) => { }) .End() .Build(); rootState.ChangeState("foo"); Assert.Throws<ApplicationException>(() => rootState.TriggerEvent("newEvent", testEventArgs)); }
public void state_with_type_adds_state_as_child_of_current_state() { IState expectedParent = null; IState actualParent = null; var rootState = new StateMachineBuilder() .State<TestState>("foo") .Enter(state => { expectedParent = state; state.ChangeState("TestState"); }) .State<TestState>() .Enter(state => actualParent = state.Parent) .End() .End() .Build(); rootState.ChangeState("foo"); Assert.Equal(expectedParent, actualParent); }
public void named_state_with_type_is_added_with_correct_name() { IState expectedParent = null; IState actualParent = null; var rootState = new StateMachineBuilder() .State<TestState>("foo") .Enter(state => { expectedParent = state; state.ChangeState("bar"); }) .State<TestState>("bar") .Enter(state => actualParent = state.Parent) .End() .End() .Build(); rootState.ChangeState("foo"); Assert.Equal(expectedParent, actualParent); }
public void Setup() { smb = new StateMachineBuilder(); stateCalledBack = null; }
public void Setup() { smb = new StateMachineBuilder(); }