internal Outcome GetTrace(TraceGroup stateTrace, TestTransition incomingTransition)
        {
            //Trace for InternalState
            this.CurrentOutcome = this.ExpectedOutcome;
            Outcome outcome = this.ExpectedOutcome;

            if (!this.IsFinal)
            {
                outcome = this.GetTransitInTrace(stateTrace, incomingTransition);

                if (this.CurrentOutcome.IsOverrideable)
                {
                    this.CurrentOutcome = outcome;
                }

                if (outcome.DefaultPropogationState == OutcomeState.Completed)
                {
                    if (this.HintTransition == null)
                    {
                        throw new InvalidOperationException(string.Format("TestStateMachineState '{0}' HintTransition is null", this.DisplayName));
                    }

                    outcome = this.GetTransitOutTrace(stateTrace);
                    if (this.CurrentOutcome.IsOverrideable)
                    {
                        this.CurrentOutcome = outcome;
                    }
                }
            }
            else
            {
                this.GetStartTrace(stateTrace);
                if (this.Entry != null)
                {
                    outcome = this.Entry.GetTrace(stateTrace);
                }

                if (this.CurrentOutcome.IsOverrideable)
                {
                    this.CurrentOutcome = outcome;
                }

                if (CurrentOutcome.DefaultPropogationState == OutcomeState.Completed)
                {
                    this.GetCloseTrace(stateTrace);
                }
                else if (CurrentOutcome.DefaultPropogationState == OutcomeState.Canceled)
                {
                    this.GetCancelTrace(stateTrace);
                }
                else if (CurrentOutcome is CaughtExceptionOutcome)
                {
                    this.GetFaultTrace(stateTrace);
                }
            }

            _iterationNumber++;

            return(outcome.Propogate());
        }
 private void AddTransition(TestTransition transition)
 {
     if (transition != null)
     {
         _productState.Transitions.Add(transition.ProductTransition);
         transition.Source = this;
     }
 }
 protected void InsertTransition(int i, TestTransition t)
 {
     this.ProductState.Transitions.Insert(i, t.ProductTransition);
     t.Source = this;
 }
 protected bool RemoveTransition(TestTransition t)
 {
     return(this.ProductState.Transitions.Remove(t.ProductTransition));
 }
        private Outcome GetTransitInTrace(TraceGroup stateTraceGroup, TestTransition incomingTransition)
        {
            HashSet <TestActivity> triggerHash  = new HashSet <TestActivity>();
            UnorderedTraces        triggerTrace = new UnorderedTraces();

            Outcome outcome = this.ExpectedOutcome;

            this.CurrentOutcome = this.ExpectedOutcome;

            this.GetStartTrace(stateTraceGroup);

            outcome = this.GetEntryTrace(stateTraceGroup);
            if (this.CurrentOutcome.IsOverrideable)
            {
                this.CurrentOutcome = outcome;
            }

            if (outcome.DefaultPropogationState == OutcomeState.Completed)
            {
                stateTraceGroup.Steps.Add(triggerTrace);
                foreach (TestTransition t in this.Transitions)
                {
                    // Shared trigger transitions
                    if (triggerHash.Add(t.Trigger))
                    {
                        outcome = t.GetTriggerTrace(triggerTrace);

                        if (outcome.DefaultPropogationState == OutcomeState.Completed)
                        {
                            outcome = t.GetConditionTrace(triggerTrace);

                            if (this.CurrentOutcome.IsOverrideable)
                            {
                                this.CurrentOutcome = outcome.Propogate();
                            }
                        }
                        else if (outcome.DefaultPropogationState == OutcomeState.Faulted || outcome is UncaughtExceptionOutcome || outcome is CaughtExceptionOutcome)
                        {
                            if (this.CurrentOutcome.IsOverrideable)
                            {
                                this.CurrentOutcome = outcome.Propogate();
                            }
                        }
                        // trigger cancel can mean two things:
                        // 1. trigger is cancelled by another trigger. This is normal behavior.
                        // 2. trigger is cancelled externally. In such case, Transition.ExpectedOutcome should be set to canceled.
                        else if (outcome.DefaultPropogationState == OutcomeState.Canceled)
                        {
                            if (t.ExpectedOutcome.DefaultPropogationState == OutcomeState.Canceled)
                            {
                                if (this.CurrentOutcome.IsOverrideable)
                                {
                                    this.CurrentOutcome = outcome.Propogate();
                                }
                            }
                            continue;
                        }
                    }
                    else
                    {
                        outcome = t.GetConditionTrace(triggerTrace);

                        if (outcome.DefaultPropogationState != OutcomeState.Completed)
                        {
                            if (CurrentOutcome.IsOverrideable)
                            {
                                CurrentOutcome = outcome.Propogate();
                            }
                        }
                    }
                }
            }

            if (this.CurrentOutcome.DefaultPropogationState == OutcomeState.Canceled)
            {
                this.GetCancelTrace(stateTraceGroup);
            }

            return(this.CurrentOutcome.Propogate());
        }
示例#6
0
        protected override void GetActivitySpecificTrace(TraceGroup traceGroup)
        {
            // To support PartialTrust, StateMachineEventManagerFactory activity is used in Variable<StateMachineEventManager>.Default
            // The code below generates the expected trace for StateMachineEventManagerFactory activity
            new TestDummyTraceActivity("StateMachineEventManagerFactory").GetTrace(traceGroup);

            Stack <TestStateMachineState> stack = new Stack <TestStateMachineState>();

            // get trace for initial state
            TestTransition fakeInitialTransition = new TestTransition("fakeinitial")
            {
                To = this.InitialState
            };

            Outcome    outcome = this.ExpectedOutcome;
            TraceGroup ordered = new OrderedTraces();

            traceGroup.Steps.Add(ordered);

            TestStateMachineState currentState = null;
            TestTransition        t            = fakeInitialTransition;

            while (t != null && t.To != null && t.To.IsFinal != true)
            {
                TestTransition nextTransition = null;
                currentState = t.To;

                OrderedTraces stateTrace = new OrderedTraces();
                ordered.Steps.Add(stateTrace);
                // keep HintTransition in nextTransition, because TestStateMachineState.GetTrace increases TestStateMachineState.iterationNumber
                nextTransition = currentState.HintTransition;
                outcome        = currentState.GetTrace(stateTrace, t);

                if (CurrentOutcome.IsOverrideable)
                {
                    CurrentOutcome = outcome.Propogate();
                }

                if (CurrentOutcome.DefaultPropogationState != OutcomeState.Completed)
                {
                    break;
                }

                t = nextTransition;
            }

            if (t == null || t.To == null)
            {
                throw new InvalidOperationException("Invalid HintTransition: null");
            }
            else if (CurrentOutcome.DefaultPropogationState == OutcomeState.Completed)
            {
                if (t.To.IsFinal == true)
                {
                    outcome = t.To.GetTrace(traceGroup, null);
                    if (CurrentOutcome.IsOverrideable)
                    {
                        CurrentOutcome = outcome.Propogate();
                    }
                }
                else
                {
                    throw new InvalidOperationException(string.Format("Invalid HintTransition: {0}", t.To.DisplayName));
                }
            }
            // faulting and cancellation will be handled by TestActivity
        }