public async Task Builder_Should_BeAbleToBuildANewStateMachineWithPreviousState()
{
var dummy = new DummyData();
var builder = StateMachineBuilder.Create <DummyData>()
.AddStep(new CounterStep())
.AddStep(new CounterStep())
.AddStep(new CounterStep())
.AddStep(new CounterStep())
.AddStep(new CounterStep());
var machine1 = builder.Build(dummy);
Assert.Equal(0, machine1.State);
Assert.True(await machine1.MoveNextAsync());
Assert.Equal(1, machine1.State);
Assert.True(await machine1.MoveNextAsync());
var machine2 = builder.Build(machine1.State, dummy);
Assert.Equal(2, machine2.State);
Assert.True(await machine2.MoveNextAsync());
Assert.Equal(3, machine2.State);
Assert.True(await machine2.MoveNextAsync());
Assert.Equal(4, machine2.State);
Assert.True(await machine2.MoveNextAsync());
Assert.Equal(5, machine2.State);
Assert.False(await machine2.MoveNextAsync());
}
public void Build_Should_Throw_When_NoStepIsProvided()
{
var builder = StateMachineBuilder.Create <DummyState, DummyData>()
.SetEndState(DummyState.Done);
Assert.Throws <MissingStepException>(() => builder.Build(DummyState.Start, new DummyData()));
}
public async Task StateMachineBuiltWithBuilder_Should_BeAbleToStartFromAState()
{
var dummy = new DummyData();
var machine = StateMachineBuilder.Create <DummyData>()
.AddStep(new CounterStep())
.AddStep(new CounterStep())
.AddStep(new CounterStep())
.AddStep(new CounterStep())
.AddStep(new CounterStep())
.Build(2, dummy);
Assert.Equal(2, machine.State);
Assert.True(await machine.MoveNextAsync());
Assert.Equal(3, machine.State);
Assert.True(await machine.MoveNextAsync());
Assert.Equal(4, machine.State);
Assert.True(await machine.MoveNextAsync());
Assert.Equal(5, machine.State);
Assert.False(await machine.MoveNextAsync());
Assert.Equal(5, machine.State);
Assert.False(await machine.MoveNextAsync());
Assert.Equal(5, machine.State);
Assert.False(await machine.MoveNextAsync());
Assert.Equal(5, machine.State);
Assert.False(await machine.MoveNextAsync());
Assert.Equal(3, dummy.StepCount);
}
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);
}
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 Ctor_SuccessfullyCreateStateMachine_CurrentStateIsEqualToInitalState()
{
// Arrange
var stateMachine = StateMachineBuilder.Create(State.Start);
// Act
var currentState = stateMachine.CurrentState;
// Assert
Assert.Equal(State.Start, currentState);
}
public void IsTransitionAllowedTo_InvalidTransition_ReturnFalse()
{
// Arrange
var stateMachine = StateMachineBuilder.Create(State.Start);
// Act
var transitionAllowed = stateMachine.IsTransitionAllowedTo(State.Working);
// Assert
Assert.False(transitionAllowed);
}
public void ChangeState_InvalidTransition_ThrowInvalidTransitionException()
{
// Arrange
var stateMachine = StateMachineBuilder.Create(State.Start);
stateMachine.AddTransition(State.Start, State.Working);
stateMachine.AddTransition(State.Working, State.Deleted);
// Act, Assert
Assert.Throws <InvalidTransitionException>(() => stateMachine.ChangeState(State.Deleted));
}
public void ChangeState_CurrentStateEqualsNewState_ReturnCurrentState()
{
// Arrange
var stateMachine = StateMachineBuilder.Create(State.Start);
stateMachine.AddTransition(State.Start, State.Working);
// Act
var newState = stateMachine.ChangeState(State.Start);
// Assert
Assert.Equal(State.Start, newState);
}
public void IsTransitionAllowedTo_ValidTransition_ReturnTrue()
{
// Arrange
var stateMachine = StateMachineBuilder.Create(State.Start);
stateMachine.AddTransition(State.Start, State.Working);
// Act
var transitionAllowed = stateMachine.IsTransitionAllowedTo(State.Working);
// Assert
Assert.True(transitionAllowed);
}
public static void Main(string[] args)
{
var builder = StateMachineBuilder <State, String, Fettle.Void> .Create();
builder.Transition().From(State.Initial).To(State.One).On("hello");
builder.Transition().From(State.One).To(State.Two).On("jump");
var template = builder.BuildTransitionModel();
var machine = template.NewStateMachineWithInitialState(State.Initial);
machine.FireEvent("hello");
Console.WriteLine("State = " + machine.CurrentState);
machine.FireEvent("jump");
Console.WriteLine("State = " + machine.CurrentState);
}
private static void Main(string[] args)
{
var stateMachine = StateMachineBuilder.Create().
AddState("Enter").
OnEnterAsync(async(machine) => {
Print.Log("Getting data.");
string data = await GetData();
Print.Log($"Data: {data}");
}).
Build();
stateMachine.LogFlow = true;
stateMachine.StartAsync().ContinueWith(x => Print.Log("Done."));
Print.Log($"First hello");
Thread.Sleep(1000);
Print.Log($"Second hello");
Console.ReadLine();
}
public async Task BuilderWithState_Should_BeAbleToBuildANewStateMachineWithPreviousState()
{
var dummy = new DummyData();
var builder = StateMachineBuilder.Create <DummyState, DummyData>()
.AddStep(new StartStep())
.AddStep(new MiddleStep())
.SetEndState(DummyState.Done);
var machine1 = builder.Build(DummyState.Start, dummy);
Assert.Equal(DummyState.Start, machine1.State);
Assert.True(await machine1.MoveNextAsync());
Assert.Equal(DummyState.Middle, machine1.State);
var machine2 = builder.Build(machine1.State, dummy);
Assert.Equal(DummyState.Middle, machine1.State);
Assert.True(await machine2.MoveNextAsync());
Assert.Equal(DummyState.Done, machine2.State);
Assert.False(await machine2.MoveNextAsync());
}
public void AddSteps_Should_Throw_When_StepIsNull()
{
var builder = StateMachineBuilder.Create <DummyData>();
Assert.Throws <ArgumentNullException>(() => builder.AddSteps((IEnumerable <IStateMachineStep <DummyData> >)null));
}
