public void TransitionNotFoundRaisedWhenTransitionNotFoundOnChild()
{
var sm = new StateMachine("sm");
var initial = sm.CreateInitialState("initial");
var state1 = sm.CreateState("state 1");
var child = initial.CreateChildStateMachine();
var childInitial = child.CreateInitialState("childInitial");
var evt = new Event("evt");
state1.InnerSelfTransitionOn(evt);
TransitionNotFoundEventArgs<State> ea = null;
sm.TransitionNotFound += (o, e) =>
{
ea = e;
};
evt.TryFire();
Assert.NotNull(ea);
Assert.AreEqual(evt, ea.Event);
Assert.AreEqual(initial, ea.From);
Assert.AreEqual(sm, ea.StateMachine);
Assert.AreEqual(EventFireMethod.TryFire, ea.EventFireMethod);
}
public void DynamicTransitionStateSelectorIsSettable()
{
var sm = new StateMachine("sm");
var state1 = sm.CreateInitialState("state1");
var state2 = sm.CreateState("state2");
var evt = new Event("evt");
var transition = state1.TransitionOn(evt).ToDynamic(i => state2);
transition.StateSelector = i => null;
evt.TryFire();
Assert.AreEqual(state1, sm.CurrentState);
}
public void OperationCompletesWhenASuccessStateIsReached()
{
var sm = new StateMachine("sm");
var initial = sm.CreateInitialState("initial");
var doingOperation = sm.CreateState("doingOperation");
var completedOperation = sm.CreateState("completedOperation");
var evt = new Event("evt");
initial.TransitionOn(evt).To(doingOperation);
doingOperation.TransitionOn(evt).To(completedOperation);
var op = new Operation<State>(evt, doingOperation, completedOperation);
var task = op.TryFireAsync();
Assert.False(task.IsCompleted);
Assert.AreEqual(doingOperation, sm.CurrentState);
evt.TryFire();
Assert.True(task.IsCompleted);
Assert.True(task.Result);
}
public void IgnoredTryFireReturnsTrue()
{
var sm = new StateMachine("sm");
var state1 = sm.CreateInitialState("state1");
var evt = new Event("evt");
state1.Ignore(evt);
Assert.True(evt.TryFire());
}
public void EventTryFireCallsSynchronizerEventFire()
{
var sm = new StateMachine("sm");
var initial = sm.CreateInitialState("initial");
var evt = new Event("evt");
initial.TransitionOn(evt).To(initial);
var synchronizer = new Mock<IStateMachineSynchronizer>();
sm.Synchronizer = synchronizer.Object;
evt.TryFire();
synchronizer.Verify(x => x.FireEvent(It.IsAny<Func<bool>>(), EventFireMethod.TryFire));
}
public void TrueReturnValueFromFireEventPropagatedToTryFire()
{
var sm = new StateMachine("sm");
var initial = sm.CreateInitialState("initial");
var state1 = sm.CreateState("state 1");
var evt = new Event("evt");
state1.InnerSelfTransitionOn(evt);
var synchronizer = new Mock<IStateMachineSynchronizer>();
synchronizer.Setup(x => x.FireEvent(It.IsAny<Func<bool>>(), EventFireMethod.TryFire))
.Returns(true);
sm.Synchronizer = synchronizer.Object;
Assert.True(evt.TryFire());
}
public void FuncReturnsTrueIfEventTryFireSucceeded()
{
var sm = new StateMachine("sm");
var initial = sm.CreateInitialState("initial");
var state1 = sm.CreateState("state1");
var evt = new Event("evt");
initial.TransitionOn(evt).To(state1);
var synchronizer = new Mock<IStateMachineSynchronizer>();
Func<bool> fireFunc = null;
synchronizer.Setup(x => x.FireEvent(It.IsAny<Func<bool>>(), EventFireMethod.TryFire))
.Callback<Func<bool>, EventFireMethod>((func, _) => fireFunc = func);
sm.Synchronizer = synchronizer.Object;
evt.TryFire();
Assert.True(fireFunc());
}
public void TransitionRaisedWhenInnerSelfTransitionOnParent()
{
var sm = new StateMachine("sm");
var initial = sm.CreateInitialState("initial");
var evt = new Event("evt");
initial.InnerSelfTransitionOn(evt);
TransitionEventArgs<State> ea = null;
sm.Transition += (o, e) =>
{
ea = e;
};
evt.TryFire();
Assert.NotNull(ea);
Assert.AreEqual(initial, ea.From);
Assert.AreEqual(initial, ea.To);
Assert.AreEqual(evt, ea.Event);
Assert.True(ea.IsInnerTransition);
Assert.AreEqual(EventFireMethod.TryFire, ea.EventFireMethod);
}
public void TryFireWithEventDataReturnsFalseIfNotYetAssociatedStateMachine()
{
var evt = new Event<string>("evt");
Assert.False(evt.TryFire("foo"));
}
public void TryFireThrowsfNotYetAssociatedStateMachine()
{
var evt = new Event("evt");
Assert.Throws<InvalidEventSetupException>(() => evt.TryFire());
}
public void TryFireReturnsFalseIfTransitionNotFound()
{
var sm = new StateMachine("sm");
var initialState = sm.CreateInitialState("initialState");
var state1 = sm.CreateState("state1");
var evt = new Event("evt");
state1.InnerSelfTransitionOn(evt);
Assert.False(evt.TryFire());
}
public static void QuickStart()
{
// First off, create a state machine. It's recommended to give it a name
// (which helps debugging), but you don't have to.
var stateMachine = new StateMachine("State Machine");
// Whenever we create a state machine, we need to give it an initial state. This
// is the state which the state machine starts in.
var awaitingMoney = stateMachine.CreateInitialState("Awaiting Money");
// We then add the other states in the staate machine.
var awaitingSelection = stateMachine.CreateState("Awaiting Selection");
var dispensing = stateMachine.CreateState("Dispensing");
// Next, we'll create the events.
var moneyReceived = new Event("Money Received");
var selectionReceived = new Event("Selection Received");
var dispenseComplete = new Event("Dispense Complete");
// Finally, we create transitions between our states based on these events.
awaitingMoney.TransitionOn(moneyReceived).To(awaitingSelection);
awaitingSelection.TransitionOn(selectionReceived).To(dispensing);
dispensing.TransitionOn(dispenseComplete).To(awaitingMoney);
// See that the state machine starts in the initial state
Assert.AreEqual(awaitingMoney, stateMachine.CurrentState);
Assert.True(awaitingMoney.IsCurrent);
// Fire events directly. This will throw an exception if there is no transition
// from the current state.
moneyReceived.Fire();
// Alternatively, you can try and fire the event - this won't throw on failure,
// but will return a bool indicating whether it succeeded.
moneyReceived.TryFire();
Assert.AreEqual(awaitingSelection, stateMachine.CurrentState);
}
public void StateSelectorWhichReturnsNullAbortsTransition()
{
var sm = new StateMachine("sm");
var initial = sm.CreateInitialState("initial");
var evt = new Event("evt");
initial.TransitionOn(evt).ToDynamic(i => null);
Assert.False(evt.TryFire());
}
public void OperationFailsIfANonSuccessStateIsReached()
{
var sm = new StateMachine("sm");
var initial = sm.CreateInitialState("initial");
var doingOperation = sm.CreateState("doingOperation");
var completedOperation = sm.CreateState("completedOperation");
var operationFailed = sm.CreateState("operationFailed");
var evt = new Event("evt");
initial.TransitionOn(evt).To(doingOperation);
doingOperation.TransitionOn(evt).To(operationFailed);
var op = new Operation<State>(evt, doingOperation, completedOperation);
var task = op.TryFireAsync();
Assert.False(task.IsCompleted);
Assert.AreEqual(doingOperation, sm.CurrentState);
evt.TryFire();
Assert.True(task.IsFaulted);
var e = Assert.Throws<OperationFailedException>(() => task.GetAwaiter().GetResult());
Assert.AreEqual(doingOperation, e.OperationStates[0]);
Assert.AreEqual(operationFailed, e.ActualState);
Assert.That(e.SuccessStates, Is.EquivalentTo(new[] { completedOperation }));
}
public void ResettingStateMachineRemovesFault()
{
var exception = new Exception("foo");
var sm = new StateMachine("sm");
var initial = sm.CreateInitialState("initial").WithEntry(i => { throw exception; });
var evt = new Event("evt");
initial.TransitionOn(evt).To(initial);
Assert.Throws<TransitionFailedException>(() => evt.TryFire());
sm.Reset();
Assert.False(sm.IsFaulted);
Assert.Null(sm.Fault);
}