Example #1
0
        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);
        }
Example #2
0
		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();
		}
Example #3
0
        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");
            }
        }
Example #4
0
        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));
        }
Example #5
0
        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"));
        }
Example #6
0
        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());
        }
Example #7
0
        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);
        }
Example #21
0
		public void Setup()
		{
			smb = new StateMachineBuilder();
			stateCalledBack = null;
		}
		public void Setup()
		{
			smb = new StateMachineBuilder();
		}