public void GroupTransition()
{
var rootGroup = new TestStateGroup();
var startGroup = new TestStateGroup();
var destGroup = new TestStateGroup();
rootGroup.Entry = startGroup;
var toDest = new StateTransition(() => { return(true); }, destGroup);
startGroup.AddTransition(toDest);
var startState = new TestState();
startGroup.Entry = startState;
var destState = new TestState();
destGroup.Entry = destState;
rootGroup.Start();
rootGroup.Update();
rootGroup.Update();
Assert.AreEqual(1, startState.StartIterations);
Assert.AreEqual(1, startState.UpdateIterations);
Assert.AreEqual(1, startState.EndIterations);
Assert.AreEqual(1, destState.StartIterations);
Assert.AreEqual(1, destState.UpdateIterations);
}
public void EndWithoutStart()
{
var group = new TestStateGroup();
var state = new TestState();
group.Entry = state;
group.End();
Assert.AreEqual(0, state.StartIterations);
Assert.AreEqual(0, state.UpdateIterations);
Assert.AreEqual(0, state.EndIterations);
}
public void ErrantStart()
{
var group = new TestStateGroup();
var state = new TestState();
group.Entry = state;
group.Start();
group.Update();
group.Start();
Assert.AreEqual(1, state.StartIterations);
}
public void TransitionFailure()
{
var group = new TestStateGroup();
var first = new TestState();
var next = new TestState();
var transition = new StateTransition(() => { return(false); }, next);
first.AddTransition(transition);
group.Entry = first;
group.Start();
group.Update();
Assert.AreEqual(0, first.EndIterations);
}
public void SubstateLifecycle()
{
var group = new TestStateGroup();
var state = new TestState();
group.Entry = state;
group.Start();
group.Update();
group.End();
Assert.AreEqual(1, state.StartIterations);
Assert.AreEqual(1, state.UpdateIterations);
Assert.AreEqual(1, state.EndIterations);
}
public void AnyStateTransitionFailure()
{
var group = new TestStateGroup();
var start = new TestState();
var attemptedDestination = new TestState();
var transition = new StateTransition(() => { return(false); }, attemptedDestination);
group.Any.AddTransition(transition);
group.Entry = start;
group.Start();
group.Update();
Assert.AreEqual(0, start.EndIterations);
}
public void AnyStateTransitionSuccess()
{
var group = new TestStateGroup();
var start = new TestState();
var destination = new TestState();
var transition = new StateTransition(() => { return(true); }, destination);
group.Any.AddTransition(transition);
group.Entry = start;
group.Start();
group.Update();
group.Update();
Assert.AreEqual(1, start.EndIterations);
Assert.AreEqual(1, destination.StartIterations);
}
public void TransitionSuccess()
{
var group = new TestStateGroup();
var first = new TestState();
var next = new TestState();
var transition = new StateTransition(() => { return(true); }, next);
first.AddTransition(transition);
group.Entry = first;
group.Start();
group.Update();
group.Update();
Assert.AreEqual(1, first.EndIterations);
Assert.AreEqual(1, next.StartIterations);
Assert.AreEqual(1, next.UpdateIterations);
}
public void TransitionSuccessAfterFailure()
{
var group = new TestStateGroup();
var state = new TestState();
var destination = new TestState();
var willTransitionSucceed = false;
var transition = new StateTransition(() => { return(willTransitionSucceed); }, destination);
state.AddTransition(transition);
group.Entry = state;
group.Start();
group.Update();
willTransitionSucceed = true;
group.Update();
Assert.AreEqual(2, state.UpdateIterations);
Assert.AreEqual(0, destination.StartIterations);
}
public void TransitionIsChecked()
{
var group = new TestStateGroup();
var state = new TestState();
var didCheckTransition = false;
var transition = new StateTransition(() =>
{
didCheckTransition = true;
return(true);
},
state);
state.AddTransition(transition);
group.Entry = state;
group.Start();
group.Update();
Assert.IsTrue(didCheckTransition);
}
public void StateTransitionPriorityOverAnyStateTransition()
{
var group = new TestStateGroup();
var start = new TestState();
var destination = new TestState();
var anyDestination = new TestState();
var transition = new StateTransition(() => { return(true); }, destination);
var anyTransition = new StateTransition(() => { return(true); }, anyDestination);
start.AddTransition(transition);
group.Any.AddTransition(anyTransition);
group.Entry = start;
group.Start();
group.Update();
group.Update();
Assert.AreEqual(1, destination.StartIterations);
Assert.AreEqual(0, anyDestination.StartIterations);
}
public void OneStateUpdates()
{
var group = new TestStateGroup();
var state = new TestState();
var iterations = 42;
group.Entry = state;
group.Start();
var current = 0;
while (current < iterations)
{
current++;
group.Update();
}
Assert.AreEqual(1, state.StartIterations);
Assert.AreEqual(iterations, state.UpdateIterations);
Assert.AreEqual(0, state.EndIterations);
}
public void MultipleTransitionsSucceed()
{
var group = new TestStateGroup();
var first = new TestState();
var destination = new TestState();
var lastDestination = new TestState();
var firstTransition = new StateTransition(() => { return(true); }, destination);
var secondTransition = new StateTransition(() => { return(true); }, lastDestination);
first.AddTransition(firstTransition);
first.AddTransition(secondTransition);
group.Entry = first;
group.Start();
group.Update();
group.Update();
Assert.AreEqual(1, destination.StartIterations);
Assert.AreEqual(1, destination.UpdateIterations);
Assert.AreEqual(0, lastDestination.StartIterations);
}
public void TransitionBackAndForth()
{
var group = new TestStateGroup();
var first = new TestState();
var second = new TestState();
var firstTransition = new StateTransition(() => { return(true); }, second);
var secondTransition = new StateTransition(() => { return(true); }, first);
first.AddTransition(firstTransition);
second.AddTransition(secondTransition);
group.Entry = first;
group.Start();
group.Update();
group.Update();
group.Update();
group.Update();
Assert.AreEqual(2, first.UpdateIterations);
Assert.AreEqual(2, second.UpdateIterations);
}
public void TransitionSecondSuccess()
{
var group = new TestStateGroup();
var start = new TestState();
var attemptedDestination = new TestState();
var destination = new TestState();
var fail = new StateTransition(() => { return(false); }, attemptedDestination);
var succeed = new StateTransition(() => { return(true); }, destination);
start.AddTransition(fail);
start.AddTransition(succeed);
group.Entry = start;
group.Start();
group.Update();
group.Update();
Assert.AreEqual(0, attemptedDestination.StartIterations);
Assert.AreEqual(1, destination.StartIterations);
Assert.AreEqual(1, destination.UpdateIterations);
}
public void SharedSubstate()
{
var root = new TestStateGroup();
var start = new TestStateGroup();
var dest = new TestStateGroup();
root.Entry = start;
var toDest = new StateTransition(() => { return(true); }, dest);
start.AddTransition(toDest);
var sharedSubstate = new TestState();
start.Entry = sharedSubstate;
dest.Entry = sharedSubstate;
root.Start();
root.Update();
root.Update();
Assert.AreEqual(2, sharedSubstate.StartIterations);
Assert.AreEqual(2, sharedSubstate.UpdateIterations);
Assert.AreEqual(1, sharedSubstate.EndIterations);
}
