public void TestStateMachinePerformance()
{
StateMachine sm = Initialize();
sm.StructureLocked = false;
m_outputEnabled = false;
//sm.TransitionHandler(States.Idle, States.Validated).Prepare += new PrepareTransitionEvent(PrepareToTransitiontoValidWithSuccess);
//sm.TransitionHandler(States.Idle, States.Validated).Commit += new CommitTransitionEvent(CommitTransitiontoValid);
//sm.TransitionHandler(States.Idle, States.Validated).Rollback += new RollbackTransitionEvent(RollbackTransitiontoValid);
//_Debug.WriteLine("Idle state is " + sm._TestGetStateNumber(States.Idle));
//_Debug.WriteLine("Validated state is " + sm._TestGetStateNumber(States.Validated));
//_Debug.WriteLine("Paused state is " + sm._TestGetStateNumber(States.Paused));
//_Debug.WriteLine("Running state is " + sm._TestGetStateNumber(States.Running));
//_Debug.WriteLine("Finished state is " + sm._TestGetStateNumber(States.Finished));
//_Debug.WriteLine("Idle to Validated is valid? " + sm.TransitionHandler(States.Idle, States.Validated).IsValidTransition);
//_Debug.WriteLine("Idle to Paused is valid? " + sm.TransitionHandler(States.Idle, States.Paused).IsValidTransition);
for (int i = 0; i < 1000; i++)
{
sm.DoTransition(States.Validated, m_batch);
sm.DoTransition(States.Idle, m_batch);
}
m_outputEnabled = true;
}
//public Enum GetStopEnum(){ return DefaultModelStates.Idle; }
/// <summary>
/// Starts the model.
/// </summary>
public virtual void Start()
{
if (s_diagnostics)
{
_Debug.WriteLine("Model.Start() requested.");
}
IsRunning = true;
IsReady = false;
IsPaused = false;
IsCompleted = false;
m_stateMachine.DoTransition(GetStartEnum());
}
public void TestTransitionIllegalToo()
{
StateMachine sm = Initialize();
sm.TransitionHandler(States.Idle, States.Paused).Prepare += new PrepareTransitionEvent(PrepareToTransitiontoValidWithSuccess);
sm.DoTransition(States.Paused, m_batch);
}
public void TestTransitionSuccessWithoutFollowon()
{
StateMachine sm = Initialize(false);
sm.TransitionHandler(States.Idle, States.Validated).Prepare += new PrepareTransitionEvent(PrepareToTransitiontoValidWithSuccess);
sm.TransitionHandler(States.Idle, States.Validated).Commit += new CommitTransitionEvent(CommitTransitiontoValid);
sm.TransitionHandler(States.Idle, States.Validated).Rollback += new RollbackTransitionEvent(RollbackTransitiontoValid);
sm.DoTransition(States.Validated, m_batch);
_Debug.Assert(States.Validated.Equals(sm.State), "State machine did not transition to 'Validated' state");
}
public void TestTransitionChainSuccess()
{
StateMachine sm = Initialize(false);
sm.TransitionHandler(States.Finished, States.Idle).Prepare += new PrepareTransitionEvent(PrepareToTransitionToIdleWithSuccess);
sm.TransitionHandler(States.Finished, States.Idle).Commit += new CommitTransitionEvent(CommitTransitionToIdle);
sm.TransitionHandler(States.Finished, States.Idle).Rollback += new RollbackTransitionEvent(RollbackTransitionToIdle);
sm.TransitionHandler(States.Idle, States.Validated).Prepare += new PrepareTransitionEvent(PrepareToTransitiontoValidWithSuccess);
sm.TransitionHandler(States.Idle, States.Validated).Commit += new CommitTransitionEvent(CommitTransitiontoValid);
sm.TransitionHandler(States.Idle, States.Validated).Rollback += new RollbackTransitionEvent(RollbackTransitiontoValid);
sm.TransitionHandler(States.Validated, States.Running).Prepare += new PrepareTransitionEvent(PrepareToTransitionToRunningWithSuccess);
sm.TransitionHandler(States.Validated, States.Running).Commit += new CommitTransitionEvent(CommitTransitionToRunning);
sm.TransitionHandler(States.Validated, States.Running).Rollback += new RollbackTransitionEvent(RollbackTransitionToRunning);
sm.TransitionHandler(States.Paused, States.Running).Prepare += new PrepareTransitionEvent(PrepareToTransitionToRunningWithSuccess);
sm.TransitionHandler(States.Paused, States.Running).Commit += new CommitTransitionEvent(CommitTransitionToRunning);
sm.TransitionHandler(States.Paused, States.Running).Rollback += new RollbackTransitionEvent(RollbackTransitionToRunning);
sm.TransitionHandler(States.Running, States.Paused).Prepare += new PrepareTransitionEvent(PrepareToTransitionToPausedWithSuccess);
sm.TransitionHandler(States.Running, States.Paused).Commit += new CommitTransitionEvent(CommitTransitionToPaused);
sm.TransitionHandler(States.Running, States.Paused).Rollback += new RollbackTransitionEvent(RollbackTransitionToPaused);
sm.TransitionHandler(States.Running, States.Finished).Prepare += new PrepareTransitionEvent(PrepareToTransitionToFinishedWithSuccess);
sm.TransitionHandler(States.Running, States.Finished).Commit += new CommitTransitionEvent(CommitTransitionToFinished);
sm.TransitionHandler(States.Running, States.Finished).Rollback += new RollbackTransitionEvent(RollbackTransitionToFinished);
sm.DoTransition(States.Validated, m_batch);
_Debug.Assert(States.Validated.Equals(sm.State), "Transition chain did not move to the 'Validated' state.");
sm.DoTransition(States.Running, m_batch);
_Debug.Assert(States.Running.Equals(sm.State), "Transition chain did not move to the 'Running' state.");
sm.DoTransition(States.Paused, m_batch);
_Debug.Assert(States.Paused.Equals(sm.State), "Transition chain did not move to the 'Paused' state.");
sm.DoTransition(States.Running, m_batch);
_Debug.Assert(States.Running.Equals(sm.State), "Transition chain did not move to the 'Running' state.");
sm.DoTransition(States.Finished, m_batch);
_Debug.Assert(States.Finished.Equals(sm.State), "Transition chain did not move to the 'Finished' state.");
}
public void TestTransitionIllegal()
{
StateMachine sm = Initialize();
sm.TransitionHandler(States.Idle, States.Validated).Prepare += new PrepareTransitionEvent(PrepareToTransitiontoValidWithSuccess);
sm.TransitionHandler(States.Idle, States.Validated).Commit += new CommitTransitionEvent(CommitTransitiontoValid);
sm.TransitionHandler(States.Idle, States.Validated).Rollback += new RollbackTransitionEvent(RollbackTransitiontoValid);
try {
sm.DoTransition(States.Paused, m_batch);
} catch (TransitionFailureException tfe) {
_Debug.WriteLine(tfe);
}
_Debug.Assert(States.Idle.Equals(sm.State), "State machine did not stay in 'Idle' state");
}
/// <summary>
/// Adds an error to the model, and iterates over all of the error handlers,
/// allowing each in turn to respond to the error. As soon as any errorHandler
/// indicates that it has HANDLED the error (by returning true from 'HandleError'),
/// the error is cleared, and further handlers are not called.
/// </summary>
/// <param name="theError">The error that is to be added to the model's error list.</param>
/// <returns>True if the error was successfully added to the model, false if it was cleared by a handler.</returns>
public bool AddError(IModelError theError)
{
foreach (IErrorHandler errorHandler in ErrorHandlers)
{
if (errorHandler.HandleError(theError))
{
if (ErrorCleared != null)
{
ErrorCleared(theError);
}
return(false);
}
}
if (theError.Target == null)
{
throw new ApplicationException("An error was added to the model with its target set to null. This is illegal.");
}
m_errors.Add(theError.Target, theError);
if (ErrorHappened != null)
{
ErrorHappened(theError);
}
// IF WE ARE TRANSITIONING, We are not going to abort on the
// addition of an error, since there may be intermediate situations
// where an error is okay. If a 'fail on the first sign of an error'
// behavior is desired, then the developer can hook the
// 'ErrorHappened' event. Instead, we will have the model register a
// handler as the last thing done on attempting a transition, to
// check that we are error-free. But, IF WE ARE NOT TRANSITIONING,
// then anything that causes an error will abort the model, and move
// it back to the 'Idle' state.
if (!StateMachine.IsTransitioning)
{
if (s_diagnostics)
{
_Debug.WriteLine("Model.Abort() requested as a result of the addition of an error : " + theError);
}
if (!StateMachine.State.Equals(GetAbortEnum()))
{
StateMachine.DoTransition(GetAbortEnum());
}
}
return(true);
}
public void TestTransitionMultipleHandlersSorted()
{
StateMachine sm = Initialize(false);
// Set up Prepare handlers.
sm.UniversalTransitionHandler().AddPrepareEvent(new PrepareTransitionEvent(UniversalPrepareToTransition), -2);
sm.OutboundTransitionHandler(States.Idle).AddPrepareEvent(new PrepareTransitionEvent(PrepareToTransitionOutOfIdleWithSuccess_1), 4);
sm.OutboundTransitionHandler(States.Idle).AddPrepareEvent(new PrepareTransitionEvent(PrepareToTransitionOutOfIdleWithSuccess_2), 3);
sm.OutboundTransitionHandler(States.Idle).AddPrepareEvent(new PrepareTransitionEvent(PrepareToTransitionOutOfIdleWithSuccess_3), 2);
sm.OutboundTransitionHandler(States.Idle).AddPrepareEvent(new PrepareTransitionEvent(PrepareToTransitionOutOfIdleWithSuccess_4), 1);
sm.InboundTransitionHandler(States.Validated).AddPrepareEvent(new PrepareTransitionEvent(PrepareToTransitiontoValidWithSuccess_1), 4);
sm.InboundTransitionHandler(States.Validated).AddPrepareEvent(new PrepareTransitionEvent(PrepareToTransitiontoValidWithSuccess_2), 3);
sm.InboundTransitionHandler(States.Validated).AddPrepareEvent(new PrepareTransitionEvent(PrepareToTransitiontoValidWithSuccess_3), 2);
sm.InboundTransitionHandler(States.Validated).AddPrepareEvent(new PrepareTransitionEvent(PrepareToTransitiontoValidWithSuccess_4), 1);
sm.TransitionHandler(States.Idle, States.Validated).AddPrepareEvent(new PrepareTransitionEvent(PrepareToTransitionIdletoValidWithSuccess_1), 4);
sm.TransitionHandler(States.Idle, States.Validated).AddPrepareEvent(new PrepareTransitionEvent(PrepareToTransitionIdletoValidWithSuccess_2), 3);
sm.TransitionHandler(States.Idle, States.Validated).AddPrepareEvent(new PrepareTransitionEvent(PrepareToTransitionIdletoValidWithSuccess_3), 2);
sm.TransitionHandler(States.Idle, States.Validated).AddPrepareEvent(new PrepareTransitionEvent(PrepareToTransitionIdletoValidWithSuccess_4), 1);
// Set up Commit handlers.
sm.UniversalTransitionHandler().AddCommitEvent(new CommitTransitionEvent(UniversalCommitTransition), -2);
sm.OutboundTransitionHandler(States.Idle).AddCommitEvent(new CommitTransitionEvent(CommitTransitionOutOfIdle_1), 4);
sm.OutboundTransitionHandler(States.Idle).AddCommitEvent(new CommitTransitionEvent(CommitTransitionOutOfIdle_2), 3);
sm.OutboundTransitionHandler(States.Idle).AddCommitEvent(new CommitTransitionEvent(CommitTransitionOutOfIdle_3), 2);
sm.OutboundTransitionHandler(States.Idle).AddCommitEvent(new CommitTransitionEvent(CommitTransitionOutOfIdle_4), 1);
sm.InboundTransitionHandler(States.Validated).AddCommitEvent(new CommitTransitionEvent(CommitTransitionToValid_1), 4);
sm.InboundTransitionHandler(States.Validated).AddCommitEvent(new CommitTransitionEvent(CommitTransitionToValid_2), 3);
sm.InboundTransitionHandler(States.Validated).AddCommitEvent(new CommitTransitionEvent(CommitTransitionToValid_3), 2);
sm.InboundTransitionHandler(States.Validated).AddCommitEvent(new CommitTransitionEvent(CommitTransitionToValid_4), 1);
sm.TransitionHandler(States.Idle, States.Validated).AddCommitEvent(new CommitTransitionEvent(CommitTransitionIdleToValid_1), 4);
sm.TransitionHandler(States.Idle, States.Validated).AddCommitEvent(new CommitTransitionEvent(CommitTransitionIdleToValid_2), 3);
sm.TransitionHandler(States.Idle, States.Validated).AddCommitEvent(new CommitTransitionEvent(CommitTransitionIdleToValid_3), 2);
sm.TransitionHandler(States.Idle, States.Validated).AddCommitEvent(new CommitTransitionEvent(CommitTransitionIdleToValid_4), 1);
sm.DoTransition(States.Validated, m_batch);
_Debug.Assert(States.Validated.Equals(sm.State), "");
}
public void TestTransitionMultipleHandlers()
{
StateMachine sm = Initialize(false);
// Set up Prepare handlers.
sm.UniversalTransitionHandler().Prepare += new PrepareTransitionEvent(UniversalPrepareToTransition);
sm.OutboundTransitionHandler(States.Idle).Prepare += new PrepareTransitionEvent(PrepareToTransitionOutOfIdleWithSuccess_1);
sm.OutboundTransitionHandler(States.Idle).Prepare += new PrepareTransitionEvent(PrepareToTransitionOutOfIdleWithSuccess_2);
sm.OutboundTransitionHandler(States.Idle).Prepare += new PrepareTransitionEvent(PrepareToTransitionOutOfIdleWithSuccess_3);
sm.OutboundTransitionHandler(States.Idle).Prepare += new PrepareTransitionEvent(PrepareToTransitionOutOfIdleWithSuccess_4);
sm.InboundTransitionHandler(States.Validated).Prepare += new PrepareTransitionEvent(PrepareToTransitiontoValidWithSuccess_1);
sm.InboundTransitionHandler(States.Validated).Prepare += new PrepareTransitionEvent(PrepareToTransitiontoValidWithSuccess_2);
sm.InboundTransitionHandler(States.Validated).Prepare += new PrepareTransitionEvent(PrepareToTransitiontoValidWithSuccess_3);
sm.InboundTransitionHandler(States.Validated).Prepare += new PrepareTransitionEvent(PrepareToTransitiontoValidWithSuccess_4);
sm.TransitionHandler(States.Idle, States.Validated).Prepare += new PrepareTransitionEvent(PrepareToTransitionIdletoValidWithSuccess_1);
sm.TransitionHandler(States.Idle, States.Validated).Prepare += new PrepareTransitionEvent(PrepareToTransitionIdletoValidWithSuccess_2);
sm.TransitionHandler(States.Idle, States.Validated).Prepare += new PrepareTransitionEvent(PrepareToTransitionIdletoValidWithSuccess_3);
sm.TransitionHandler(States.Idle, States.Validated).Prepare += new PrepareTransitionEvent(PrepareToTransitionIdletoValidWithSuccess_4);
// Set up Commit handlers.
sm.UniversalTransitionHandler().Commit += new CommitTransitionEvent(UniversalCommitTransition);
sm.OutboundTransitionHandler(States.Idle).Commit += new CommitTransitionEvent(CommitTransitionOutOfIdle_1);
sm.OutboundTransitionHandler(States.Idle).Commit += new CommitTransitionEvent(CommitTransitionOutOfIdle_2);
sm.OutboundTransitionHandler(States.Idle).Commit += new CommitTransitionEvent(CommitTransitionOutOfIdle_3);
sm.OutboundTransitionHandler(States.Idle).Commit += new CommitTransitionEvent(CommitTransitionOutOfIdle_4);
sm.InboundTransitionHandler(States.Validated).Commit += new CommitTransitionEvent(CommitTransitionToValid_1);
sm.InboundTransitionHandler(States.Validated).Commit += new CommitTransitionEvent(CommitTransitionToValid_2);
sm.InboundTransitionHandler(States.Validated).Commit += new CommitTransitionEvent(CommitTransitionToValid_3);
sm.InboundTransitionHandler(States.Validated).Commit += new CommitTransitionEvent(CommitTransitionToValid_4);
sm.TransitionHandler(States.Idle, States.Validated).Commit += new CommitTransitionEvent(CommitTransitionIdleToValid_1);
sm.TransitionHandler(States.Idle, States.Validated).Commit += new CommitTransitionEvent(CommitTransitionIdleToValid_2);
sm.TransitionHandler(States.Idle, States.Validated).Commit += new CommitTransitionEvent(CommitTransitionIdleToValid_3);
sm.TransitionHandler(States.Idle, States.Validated).Commit += new CommitTransitionEvent(CommitTransitionIdleToValid_4);
sm.DoTransition(States.Validated, m_batch);
Assert.IsTrue(States.Validated.Equals(sm.State), "");
}
public void TestStateMachine()
{
StateMachine sm = Initialize();
sm.TransitionHandler(States.Idle, States.Validated).Prepare += new PrepareTransitionEvent(PrepareToTransitiontoValidWithSuccess);
sm.TransitionHandler(States.Idle, States.Validated).Commit += new CommitTransitionEvent(CommitTransitiontoValid);
sm.TransitionHandler(States.Idle, States.Validated).Rollback += new RollbackTransitionEvent(RollbackTransitiontoValid);
#if DEBUG
_Debug.WriteLine("Idle state is " + sm._TestGetStateNumber(States.Idle));
_Debug.WriteLine("Validated state is " + sm._TestGetStateNumber(States.Validated));
_Debug.WriteLine("Paused state is " + sm._TestGetStateNumber(States.Paused));
_Debug.WriteLine("Running state is " + sm._TestGetStateNumber(States.Running));
_Debug.WriteLine("Finished state is " + sm._TestGetStateNumber(States.Finished));
_Debug.WriteLine("Idle to Validated is valid? " + sm.TransitionHandler(States.Idle, States.Validated).IsValidTransition);
_Debug.WriteLine("Idle to Paused is valid? " + sm.TransitionHandler(States.Idle, States.Paused).IsValidTransition);
#endif
sm.DoTransition(States.Validated, m_batch);
}
