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); }