public void TestAddNextStateDuplicate()
{
var builder = StateMachineFactory.CreateBuilder <TestEnum, TestTransitionEnum, object>();
var startState = builder.AddState(TestEnum.Start);
var endState = builder.AddState(TestEnum.End);
startState.AddValidTransition(TestTransitionEnum.Stopping, endState);
Assert.ThrowsException <ArgumentException>(() => startState.AddValidTransition(TestTransitionEnum.Stopping, endState));
}
/// <summary>
/// Configures the state machine.
/// </summary>
private void ConfigureStateMachine()
{
_endPointStateMachine = StateMachineFactory.Create(EndPointStatus.Initializing)
.Permit(EndPointStatus.Initializing, EndPointStatus.Receiving, t =>
{
InitializeEndPoint();
ReceivingStart();
})
.Permit(EndPointStatus.Receiving, EndPointStatus.Stopped, OnReceivingStop)
.Permit(EndPointStatus.Stopped, EndPointStatus.Receiving, t => ReceivingStart());
}
/// <summary>
/// Configures the state machine.
/// </summary>
private void ConfigureStateMachine()
{
_stateMachine = StateMachineFactory.Create(MonitorStatus.Initializing);
_stateMachine.Permit(MonitorStatus.Initializing, MonitorStatus.Started, OnStartSampler)
.Permit(MonitorStatus.Started, MonitorStatus.Stopped, e =>
{
_cancellationTokenSource.Cancel();
InvokeOnStop();
})
.Permit(MonitorStatus.Stopped, MonitorStatus.Started, OnStartSampler);
}
/// <summary>
/// Configures the state machine.
/// </summary>
private void ConfigureStateMachine()
{
_stateMachine = StateMachineFactory.Create(ProcessorStatus.Initializing)
.Permit(ProcessorStatus.Initializing, ProcessorStatus.Configured,
OnConfiguredControl)
.Permit(ProcessorStatus.Configured, ProcessorStatus.Started,
OnStartControl)
.Permit(ProcessorStatus.Started, ProcessorStatus.Stopped, OnStopControl)
.Permit(ProcessorStatus.Stopped, ProcessorStatus.Started, OnStartControl)
.Permit(ProcessorStatus.Stopped, ProcessorStatus.Configured);
}
public void TestInvalidTransition()
{
var stateMachineBuilder = StateMachineFactory.CreateBuilder <TestEnum, TestTransitionEnum, int>();
var startState = stateMachineBuilder.AddState(TestEnum.Start);
var endState = stateMachineBuilder.AddState(TestEnum.End);
var stateMachine = stateMachineBuilder.Compile();
var context = stateMachine.StartStateMachine(TestEnum.Start, 5);
Assert.ThrowsException <InvalidOperationException>(() => context.Post(TestTransitionEnum.Middling));
}
/// <summary>
/// Configures the state machine.
/// </summary>
private void ConfigureStateMachine()
{
StateMachine = StateMachineFactory.Create(ProcessorStatus.Initializing)
.Permit(ProcessorStatus.Initializing, ProcessorStatus.Configured,
OnConfigured)
.Permit(ProcessorStatus.Configured, ProcessorStatus.Started,
InputGatewayStart)
.Permit(ProcessorStatus.Started, ProcessorStatus.Stopped, InputGatewayStop)
.Permit(ProcessorStatus.Stopped, ProcessorStatus.Started,
InputGatewayStart)
.Permit(ProcessorStatus.Stopped, ProcessorStatus.Configured);
}
public void TryTransition_GivenPassiveTransitionAndAutoAdvanceOff_WhenInitialStateOne_TransitionsToStateTwo()
{
var uut = StateMachineFactory.Create <DummyState>("Test StateMachine", _logger);
var harness = new StateMachineTestHarness <DummyState>(uut, DummyState.One.ToString());
TestBuilder.BuildOneWayPassiveMachine(harness.Machine);
uut.AutoAdvance = false;
uut.CompleteEdit();
uut.TryTransition(this);
Assert.AreEqual(DummyState.Two, uut.CurrentState);
}
public void TestStateMachineTransition()
{
var builder = StateMachineFactory.CreateBuilder <TestEnum, TestTransitionEnum, object>();
var start = builder.AddState(TestEnum.Start);
var end = builder.AddState(TestEnum.End);
start.AddValidTransition(TestTransitionEnum.Stopping, end);
var stateMachine = builder.Compile();
Assert.AreEqual(2, stateMachine.States.Count);
}
/// <summary>
/// Configures the state machine.
/// </summary>
private void ConfigureStateMachine()
{
_stateMachine = StateMachineFactory.Create(ProcessorStatus.Initializing)
.Permit(ProcessorStatus.Initializing, ProcessorStatus.Configured)
.Permit(ProcessorStatus.Configured, ProcessorStatus.Started,
t => _inputGateway.Start())
.Permit(ProcessorStatus.Started, ProcessorStatus.Stopped,
t => _inputGateway.Stop())
.Permit(ProcessorStatus.Stopped, ProcessorStatus.Started,
t => _inputGateway.Start())
.Permit(ProcessorStatus.Stopped, ProcessorStatus.Configured);
}
public void TestBackAndForth()
{
var oneToTwo = false;
var twoToOne = false;
var two = false;
var factory = StateMachineFactory.CreateBuilder <NumberedTestEnum, TransitionEnum, int>();
var finishGate = new ManualResetEventSlim(false);
var first = factory.AddState(NumberedTestEnum.One);
first.OnStateEnter(ctx =>
{
finishGate.Set();
return(Task.CompletedTask);
});
var second = factory.AddState(NumberedTestEnum.Two);
second.OnStateEnter(ctx =>
{
two = true;
ctx.Post(TransitionEnum.T2);
return(Task.CompletedTask);
});
first.AddValidTransition(TransitionEnum.T1, second)
.AddTransitionFunction(ctx =>
{
oneToTwo = true;
return(Task.CompletedTask);
});
second.AddValidTransition(TransitionEnum.T2, first)
.AddTransitionFunction(ctx =>
{
twoToOne = true;
return(Task.CompletedTask);
});
var stateMachine = factory.Compile();
var session = stateMachine.StartStateMachine(NumberedTestEnum.One, 5);
session.Post(TransitionEnum.T1);
var one = finishGate.Wait(StateMachineCirclularTests.GateWait);
Thread.MemoryBarrier();
Assert.IsTrue(oneToTwo);
Assert.IsTrue(two);
Assert.IsTrue(twoToOne);
Assert.IsTrue(one);
}
public void TestAddNextState()
{
var builder = StateMachineFactory.CreateBuilder <TestEnum, TestTransitionEnum, object>();
var startState = builder.AddState(TestEnum.Start);
var nextState = builder.AddState(TestEnum.End);
Assert.IsFalse(((StateBuilder <TestEnum, TestTransitionEnum, object>)startState).Transitions.Any());
Assert.IsFalse(((StateBuilder <TestEnum, TestTransitionEnum, object>)nextState).Transitions.Any());
startState.AddValidTransition(TestTransitionEnum.Stopping, nextState);
Assert.AreSame(nextState, ((StateBuilder <TestEnum, TestTransitionEnum, object>)startState).Transitions.Single().EndState);
Assert.IsFalse(((StateBuilder <TestEnum, TestTransitionEnum, object>)nextState).Transitions.Any());
}
public ZombieFactory(ITimeProvider timeProvider,
IEntityLifeManager entityLifeManager,
ITargetLocator targetLocator,
StateMachineFactory stateMachineFactory,
IDoor[] doors,
IPool <Zombie> pool)
{
_timeProvider = timeProvider;
_entityLifeManager = entityLifeManager;
_targetLocator = targetLocator;
_stateMachineFactory = stateMachineFactory;
_doors = doors;
_pool = pool;
}
public void TestFullLoop()
{
var factory = StateMachineFactory.CreateBuilder <NumberedTestEnum, TransitionEnum, int>();
var finishGate = new ManualResetEventSlim(false);
var states = Enum.GetValues(typeof(NumberedTestEnum)).Cast <NumberedTestEnum>().Select(s => factory.AddState(s)).ToArray();
var statecounts = new int[states.Length];
for (var i = 0; i < states.Length; i++)
{
states[i].AddValidTransition(TransitionEnum.T1, states[(i + 1) % states.Length]);
if (i != 0)
{
var locali = i;
states[i].OnStateEnter(ctx =>
{
statecounts[locali]++;
ctx.Post(TransitionEnum.T1);
return(Task.CompletedTask);
});
}
}
states[0].OnStateEnter(ctx =>
{
if (++statecounts[0] < 5)
{
ctx.Post(TransitionEnum.T1);
}
else
{
finishGate.Set();
}
return(Task.CompletedTask);
});
var stateMachine = factory.Compile();
var context = stateMachine.StartStateMachine(NumberedTestEnum.One, 5);
context.Post(TransitionEnum.T1);
Assert.IsTrue(finishGate.Wait(StateMachineCirclularTests.GateWait));
Assert.AreEqual(5, statecounts[0]);
context.Dispose();
}
public void Signal_GivenTriggeredTransition_TransitionNotTraversed()
{
var uut = StateMachineFactory.Create <DummyState>("Test StateMachine", _logger);
var harness = new StateMachineTestHarness <DummyState>(uut, DummyState.One.ToString());
TestBuilder.BuildOneWayMachineWithTriggers(harness.Machine, harness);
uut.CompleteEdit();
Assert.AreEqual(DummyState.One, uut.CurrentState);
bool signalResult = uut.Signal(new DataWaypoint(this, "Test method"));
Assert.IsFalse(signalResult, "A transition was traversed but should not have been.");
Assert.AreEqual(DummyState.One, uut.CurrentState);
}
public void Signal_GivenPassiveTransitionAndAutoAdvanceOn_MultipleTransitionTraversed()
{
var uut = StateMachineFactory.Create <DummyState>("Test StateMachine", _logger);
var harness = new StateMachineTestHarness <DummyState>(uut, DummyState.One.ToString());
TestBuilder.BuildOneWayPassiveMachine(harness.Machine);
uut.AutoAdvance = true;
uut.CompleteEdit();
Assert.AreEqual(DummyState.One, uut.CurrentState);
bool signalResult = uut.Signal(new DataWaypoint(this, "Test method"));
Assert.IsTrue(signalResult, "Failed to signal the machine under test.");
Assert.AreEqual(DummyState.Three, uut.CurrentState);
}
public async Task TestSimpleFaultStopsMachine()
{
var builder = StateMachineFactory.CreateBuilder <TestEnum, TestTransitionEnum, int>();
var one = builder.AddState(TestEnum.Start)
.OnStateEnter(xtc => throw new Exception());
var two = builder.AddState(TestEnum.End);
one.AddValidTransition(TestTransitionEnum.Stopping, two);
var stateMachine = builder.Compile();
var context = stateMachine.StartStateMachine(TestEnum.Start, 5, true);
await Task.Delay(1000);
Assert.AreEqual(StateMachineLifetime.Error, context.CurrentLifecycle);
}
public SimpleStateMachineFacts()
{
this.transitionsTester = new Mock <ITestTransitions>();
var configuration = StateMachineConfigurationFactory.Create <StateBase, EventBase>();
configuration.ConfigureState <InitialState>(1)
.Transition <TestCommand>((s, e) => new TestState())
.OnLeave(s => this.transitionsTester.Object.OnLeaveInitial(s));
configuration.ConfigureState <TestState>(1)
.OnEnter(s => this.transitionsTester.Object.OnEnterTest(s))
.Transition <TestCommand>((s, e) => new TestState())
.OnLeave(s => this.transitionsTester.Object.OnLeaveTest(s));
sut = StateMachineFactory.CreateSimple(new InitialState(), configuration);
}
private void CreateStateMachine(object globalSyncContext)
{
try
{
StateMachine = StateMachineFactory.CreateTriggerAsync <ChildState>($"Child{_name} StateMachine", _logger, globalSyncContext);
using (var builder = ChildMachineBuilder.BuildStateMachine(this, StateMachine))
{
//TODO: add EFFECT actions
}
}
catch (Exception ex)
{
_logger.Error($"{ex.GetType().Name} while creating child StateMachine.", ex);
throw;
}
}
protected internal override IStateMachine <StateBase, EventBase> CreateSut()
{
var configuration = StateMachineConfigurationFactory.CreateAsync <StateBase, EventBase>();
configuration.ConfigureState <InitialState>(1)
.Transition <TestCommand>((s, e) => new TestState())
.OnLeave(s => this.transitionsTester.Object.OnLeaveInitial(s));
configuration.ConfigureState <TestState>(1)
.OnEnter(s => this.transitionsTester.Object.OnEnterTest(s))
.Transition <StartDetectionCommand>((s, e) => new DetectingState(false, new List <Device>()))
.Transition <TestCommand>((s, e) => new TestState())
.OnLeave(s => this.transitionsTester.Object.OnLeaveTest(s));
configuration.ConfigureAsyncState <DetectingState>(6)
.RunAsync(async s =>
{
try
{
await this.detectionManager.Object.Detect();
return(new DetectionCompletedSuccess());
}
catch (OperationCanceledException)
{
return(new DetectionCancelled());
}
catch (Exception)
{
return(new DetectionCompletedFailure());
}
})
.Transition <TestCommand>((s, e) => new DetectingState(s.WaitingCancellation, s.DetectedDevices))
.Transition <DeviceDetected>((s, e) =>
{
s.DetectedDevices.Add(e.Device);
return(new DetectingState(s.WaitingCancellation, s.DetectedDevices));
})
.Transition <DetectionCompletedSuccess>((s, e) => new DetectionSuccessState(s.DetectedDevices))
.OnLeave(s => this.transitionsTester.Object.OnLeaveDetecting(s));
configuration.ConfigureState <DetectionSuccessState>(2)
.Transition <StartDetectionCommand>((s, e) => new DetectingState(false, new List <Device>()))
.Transition <GoBackCommand>((s, e) => new InitialState());
return(StateMachineFactory.CreateAsync(new InitialState(), configuration));
}
private static async Task AsyncMachineExample()
{
// Note the "CreateAsyncConfiguration"
var config = StateMachineFactory.CreateAwaitableConfiguration <State, Trigger>();
config.ForState(State.Off)
.OnEntry(async() => Console.WriteLine("OnEntry of Off"))
.OnExit(async() => Console.WriteLine("OnExit of Off"))
.PermitReentry(Trigger.TurnOff)
.Permit(Trigger.Ring, State.Ringing, async() => { Console.WriteLine("Attempting to ring"); })
.Permit(Trigger.Connect, State.Connected, async() => { Console.WriteLine("Connecting"); });
var connectTriggerWithParameter = config.SetTriggerParameter <string>(Trigger.Connect);
config.ForState(State.Ringing)
.OnEntry(() => Console.WriteLine("OnEntry of Ringing"))
.OnExit(() => Console.WriteLine("OnExit of Ringing"))
.Permit(connectTriggerWithParameter, State.Connected,
name => { Console.WriteLine("Attempting to connect to {0}", name); })
.Permit(Trigger.Talk, State.Talking, () => { Console.WriteLine("Attempting to talk"); });
config.ForState(State.Connected)
.OnEntry(async() => Console.WriteLine("AOnEntry of Connected"))
.OnExit(async() => Console.WriteLine("AOnExit of Connected"))
.PermitReentry(Trigger.Connect)
.Permit(Trigger.Talk, State.Talking, async() => { Console.WriteLine("Attempting to talk"); })
.Permit(Trigger.TurnOff, State.Off, async() => { Console.WriteLine("Turning off"); });
config.ForState(State.Talking)
.OnEntry(() => Console.WriteLine("OnEntry of Talking"))
.OnExit(() => Console.WriteLine("OnExit of Talking"))
.Permit(Trigger.TurnOff, State.Off, () => { Console.WriteLine("Turning off"); })
.Permit(Trigger.Ring, State.Ringing, () => { Console.WriteLine("Attempting to ring"); });
var machine = StateMachineFactory.Create(State.Ringing, config);
await machine.FireAsync(Trigger.Talk);
await machine.FireAsync(Trigger.Ring);
await machine.FireAsync(connectTriggerWithParameter, "John Doe");
}
public FSMZombieBrain(ITimeProvider timeProvider,
ITargetLocator targetLocator,
StateMachineFactory stateMachineFactory,
TargetChaser targetChaser,
IAttacker attacker,
TimeSpan attackInterval,
IDoor[] doors,
IMover mover,
IPositionDetector positionDetector)
{
_timeProvider = timeProvider;
_targetLocator = targetLocator;
_stateMachineFactory = stateMachineFactory;
_targetChaser = targetChaser;
_attacker = attacker;
_attackInterval = attackInterval;
_doors = doors;
_mover = mover;
_positionDetector = positionDetector;
}
private IEnumerable <IServerSupervisor> GetCommonSupervisors()
{
var stateMachineFactory = new StateMachineFactory(_storage);
var sharedWorkerContext = new SharedWorkerContext(
_serverId,
_options.Queues,
_storage,
new JobPerformanceProcess(),
JobActivator.Current,
stateMachineFactory);
yield return(new ServerSupervisor(new WorkerManager(sharedWorkerContext, _options.WorkerCount)));
yield return(new ServerSupervisor(new ServerHeartbeat(_storage, _serverId)));
yield return(new ServerSupervisor(new ServerWatchdog(_storage)));
yield return(new ServerSupervisor(
new SchedulePoller(_storage, stateMachineFactory, _options.SchedulePollingInterval)));
}
public async Task TestSimplEFaultCaughtGloballyDoesntStopMachine()
{
var hitHandler = false;
var builder = StateMachineFactory.CreateBuilder <TestEnum, TestTransitionEnum, int>();
var one = builder.AddState(TestEnum.Start)
.OnStateEnter(xtc => throw new Exception());
var two = builder.AddState(TestEnum.End);
builder.SetGlobalFaultHandler((ctx, ex) => { hitHandler = true; });
one.AddValidTransition(TestTransitionEnum.Stopping, two);
var stateMachine = builder.Compile();
var context = stateMachine.StartStateMachine(TestEnum.Start, 5, true);
await Task.Delay(1000);
Assert.AreEqual(StateMachineLifetime.Running, context.CurrentLifecycle);
Assert.IsTrue(hitHandler);
}
public static void LiquidStateAwaitableSyncTest()
{
var config = StateMachineFactory.CreateAwaitableConfiguration <State, Trigger>();
config.ForState(State.Off)
.OnEntry(async() => Console.WriteLine("OnEntry of Off"))
.OnExit(async() => Console.WriteLine("OnExit of Off"))
.PermitReentry(Trigger.TurnOff)
.Permit(Trigger.Ring, State.Ringing, async() => { Console.WriteLine("Attempting to ring"); })
.Permit(Trigger.Connect, State.Connected, async() => { Console.WriteLine("Connecting"); });
var connectTriggerWithParameter = config.SetTriggerParameter <string>(Trigger.Connect);
config.ForState(State.Ringing)
.OnEntry(async() => Console.WriteLine("OnEntry of Ringing"))
.OnExit(async() => Console.WriteLine("OnExit of Ringing"))
.Permit(connectTriggerWithParameter, State.Connected,
async name => { Console.WriteLine("Attempting to connect to " + name); })
.Permit(Trigger.Talk, State.Talking, async() => { Console.WriteLine("Attempting to talk"); });
config.ForState(State.Connected)
.OnEntry(async() => Console.WriteLine("AOnEntry of Connected"))
.OnExit(async() => Console.WriteLine("AOnExit of Connected"))
.PermitReentry(Trigger.Connect)
.Permit(Trigger.Talk, State.Talking, async() => { Console.WriteLine("Attempting to talk"); })
.Permit(Trigger.TurnOff, State.Off, async() => { Console.WriteLine("Turning off"); });
config.ForState(State.Talking)
.OnEntry(async() => Console.WriteLine("OnEntry of Talking"))
.OnExit(async() => Console.WriteLine("OnExit of Talking"))
.Permit(Trigger.TurnOff, State.Off, async() => { Console.WriteLine("Turning off"); })
.PermitDynamic(Trigger.Ring, () => DynamicState.Create(State.Ringing),
async() => { Console.WriteLine("Attempting to ring"); });
var machine = StateMachineFactory.Create(State.Ringing, config, queued: false);
machine.FireAsync(Trigger.Talk).Wait();
machine.FireAsync(Trigger.Ring).Wait();
machine.FireAsync(Trigger.Talk).Wait();
}
/// <summary>
/// Configures the state machine.
/// </summary>
private void ConfigureStateMachine()
{
_stateMachine = StateMachineFactory.Create(ServiceStatus.Initializing)
.Permit(ServiceStatus.Initializing, ServiceStatus.StandBy, StartControl)
.Permit(ServiceStatus.StandBy, ServiceStatus.Started, StartProcessor)
.Permit(ServiceStatus.StandBy, ServiceStatus.Stopped, StopControl)
.Permit(ServiceStatus.Started, ServiceStatus.StandBy, StopProcessor)
.Permit(ServiceStatus.Started, ServiceStatus.Stopped, StopAll)
.Permit(ServiceStatus.Stopped, ServiceStatus.StandBy, StartControl);
_controller.OnStart += (sender, args) =>
{
//El processor es un bus no un servicio, los servicios arrancan cuando el controller acaba de configurarlos
if (_processor is ISubscriber)
{
if (_stateMachine.CanChangeState(ServiceStatus.Started))
{
_stateMachine.ChangeState(ServiceStatus.Started);
}
}
};
_processor.OnStart += (sender, args) =>
{
if (_stateMachine.CanChangeState(ServiceStatus.Started))
{
_stateMachine.ChangeState(ServiceStatus.Started);
}
};
_processor.OnStop += (sender, args) =>
{
if (_stateMachine.CanChangeState(ServiceStatus.StandBy))
{
_stateMachine.ChangeState(ServiceStatus.StandBy);
}
};
}
public override void Init(List <SceneNode> sceneNodes)
{
var logger = CreateLogger();
_deps = GetDeps(sceneNodes);
var random = new DefaultRandom(new Random());
var tankMobTargetLocator = new TypeTargetLocator(EntityType.Tank);
var targetLocators = new List <ITargetLocator>
{
tankMobTargetLocator
};
var entitiesSpawner = new EntitiesSpawner(targetLocators);
var timeProvider = new UnityTimeProvider();
CreateTank(logger, timeProvider, entitiesSpawner);
var stateMachineFactory = new StateMachineFactory();
var mobSpawner = CreateMobSpawner(logger, timeProvider, entitiesSpawner, tankMobTargetLocator, stateMachineFactory, random);
mobSpawner.Start();
}
private IEnumerable <IServerComponent> GetCommonComponents()
{
var performanceProcess = new DefaultJobPerformanceProcess(JobActivator.Current);
var stateMachineFactory = new StateMachineFactory(_storage);
for (var i = 0; i < _options.WorkerCount; i++)
{
var context = new WorkerContext(_serverId, _options.Queues, i + 1);
yield return(new Worker(context, _storage, performanceProcess, stateMachineFactory));
}
yield return(new ServerHeartbeat(_storage, _serverId));
yield return(new SchedulePoller(_storage, stateMachineFactory, _options.SchedulePollingInterval));
yield return(new ServerWatchdog(_storage, _options.ServerWatchdogOptions));
yield return(new RecurringJobScheduler(
_storage,
new BackgroundJobClient(_storage, stateMachineFactory),
new ScheduleInstantFactory(),
SchedulerResolution.Current.CreateThrottler()));
}
public void BlockDoublePendingTransition()
{
var gate = new ManualResetEventSlim(false);
var stateMachineBuilder = StateMachineFactory.CreateBuilder <TestEnum, TestTransitionEnum, int>();
var startState = stateMachineBuilder.AddState(TestEnum.Start);
var endState = stateMachineBuilder.AddState(TestEnum.End);
startState.AddValidTransition(TestTransitionEnum.Stopping, endState);
startState.OnStateEnter(ctx =>
{
Assert.IsTrue(gate.Wait(StateMachineTests.gateTimeout));
return(Task.CompletedTask);
});
var stateMachine = stateMachineBuilder.Compile();
var context = stateMachine.StartStateMachine(TestEnum.Start, 5, executeStageEntry: true);
context.Post(TestTransitionEnum.Stopping);
Assert.ThrowsException <ArgumentException>(() => context.Post(TestTransitionEnum.Stopping));
gate.Set();
}
public void TestStateMachineTransitionWhileInProgress()
{
var waitEvent = new ManualResetEventSlim(false);
var stateMachineBuilder = StateMachineFactory.CreateBuilder <TestEnum, TestTransitionEnum, int>();
var startState = stateMachineBuilder.AddState(TestEnum.Start);
var endState = stateMachineBuilder.AddState(TestEnum.End);
startState.AddValidTransition(TestTransitionEnum.Stopping, endState)
.AddTransitionFunction(ctx =>
{
waitEvent.Wait(StateMachineTests.gateTimeout);
return(Task.CompletedTask);
});
var stateMachine = stateMachineBuilder.Compile();
var context = stateMachine.StartStateMachine(TestEnum.Start, 5);
context.Post(TestTransitionEnum.Stopping);
Assert.ThrowsException <Exception>(() => context.Post(TestTransitionEnum.Stopping));
waitEvent.Set();
waitEvent.Dispose();
}
public void TestPendingTransition()
{
var factory = StateMachineFactory.CreateBuilder <NumberedTestEnum, TransitionEnum, int>();
var leftState2 = false;
var finishGate = new ManualResetEventSlim(false);
var first = factory.AddState(NumberedTestEnum.One);
var second = factory.AddState(NumberedTestEnum.Two);
second.OnStateEnter(async ctx =>
{
ctx.Post(TransitionEnum.T2);
await Task.Delay(1000);
leftState2 = true;
});
var third = factory.AddState(NumberedTestEnum.Three);
third.OnStateEnter(ctx =>
{
Assert.IsTrue(leftState2);
finishGate.Set();
return(Task.CompletedTask);
});
first.AddValidTransition(TransitionEnum.T1, second);
second.AddValidTransition(TransitionEnum.T2, third);
var stateMachine = factory.Compile();
var session = stateMachine.StartStateMachine(NumberedTestEnum.One, 5);
session.Post(TransitionEnum.T1);
Assert.IsTrue(finishGate.Wait(StateMachineConcurrencyTests.GateWait));
}
