internal void ValidateTrackingAndTracing(ExpectedTrace expectedTrace, ExpectedTrace expectedWorkflowInstanceTrace)
{
//The expected trace may get modified in the validateTraces method. Hence make a copy to be prior to tracking validation.
//We are merging two sets of traces
//1) the traces generated by activities
//2) the traces generated by workflowinstance method calls
UnorderedTraces mergedTrace = new UnorderedTraces();
mergedTrace.Steps.Add(expectedTrace.Trace);
if (expectedWorkflowInstanceTrace != null)
{
mergedTrace.Steps.Add(expectedWorkflowInstanceTrace.Trace);
}
ExpectedTrace expectedMergedTrace = new ExpectedTrace(expectedTrace)
{
Trace = mergedTrace
};
ValidateTracking(expectedTrace);
//Log.TraceInternal("[TestWorkflowRuntime]***Validate Tracing...");
ValidateTraces(expectedMergedTrace, GetActualTrace());
}
protected override void GetCancelTrace(TraceGroup traceGroup)
{
UnorderedTraces finalCancelTraces = new UnorderedTraces();
GetCompensationTrace(finalCancelTraces);
finalCancelTraces.Steps.Add(new ActivityTrace(this.DisplayName, ActivityInstanceState.Canceled));
traceGroup.Steps.Add(new ActivityTrace(this.DisplayName, ActivityInstanceState.Canceled));
}
protected override void GetCancelTrace(TraceGroup traceGroup)
{
// The Parallel.Canceled trace and Compensation traces can come unordered...
UnorderedTraces finalCancelTraces = new UnorderedTraces();
GetCompensationTrace(finalCancelTraces);
finalCancelTraces.Steps.Add(new ActivityTrace(this.DisplayName, ActivityInstanceState.Canceled));
traceGroup.Steps.Add(finalCancelTraces);
}
public void ThrowExceptionInValues()
{
UnorderedTraces ordered = new UnorderedTraces()
{
Steps =
{
new OrderedTraces()
{
Steps =
{
new ActivityTrace("w1", ActivityInstanceState.Executing),
new ActivityTrace("w1", ActivityInstanceState.Faulted),
}
},
new OrderedTraces()
{
Steps =
{
new ActivityTrace("w1", ActivityInstanceState.Executing),
new ActivityTrace("w1", ActivityInstanceState.Faulted),
}
},
new OrderedTraces()
{
Steps =
{
new ActivityTrace("w1", ActivityInstanceState.Executing),
new ActivityTrace("w1", ActivityInstanceState.Faulted),
}
}
}
};
TestParallelForEach <int> foreachAct = new TestParallelForEach <int>("foreach")
{
ValuesExpression = context => new IEnumerableWithException {
NumberOfIterations = 3
},
Body = new TestWriteLine("w1")
{
Message = "w1"
},
ExpectedOutcome = Outcome.Faulted,
ActivitySpecificTraces =
{
ordered,
}
};
TestRuntime.RunAndValidateAbortedException(foreachAct, typeof(TestCaseException), new Dictionary <string, string>());
}
public void WhileWithExceptionFromCondition()
{
// Test case description:
// Throw exception in while and in while condition
TestSequence outerSequence = new TestSequence("sequence1");
TestSequence innerSequence = new TestSequence("Seq");
TestAssign <int> increment = new TestAssign <int>("Increment Counter");
Variable <int> counter = VariableHelper.CreateInitialized <int>("counter", 0);
TestWhile whileAct = new TestWhile("while act")
{
Body = innerSequence,
HintIterationCount = 10,
};
ExceptionThrowingActivitiy <bool> throwFromCondition = new ExceptionThrowingActivitiy <bool>();
((Microsoft.CoreWf.Statements.While)whileAct.ProductActivity).Condition = throwFromCondition;
increment.ToVariable = counter;
increment.ValueExpression = ((env) => (((int)counter.Get(env))) + 1);
innerSequence.Activities.Add(increment);
outerSequence.Variables.Add(counter);
outerSequence.Activities.Add(whileAct);
OrderedTraces trace = new OrderedTraces();
trace.Steps.Add(new ActivityTrace(outerSequence.DisplayName, ActivityInstanceState.Executing));
trace.Steps.Add(new ActivityTrace(whileAct.DisplayName, ActivityInstanceState.Executing));
OrderedTraces ordered = new OrderedTraces();
UnorderedTraces unordered = new UnorderedTraces();
unordered.Steps.Add(ordered);
unordered.Steps.Add(new ActivityTrace(throwFromCondition.DisplayName, ActivityInstanceState.Executing));
unordered.Steps.Add(new ActivityTrace(throwFromCondition.DisplayName, ActivityInstanceState.Faulted));
trace.Steps.Add(unordered);
ExpectedTrace expected = new ExpectedTrace(trace);
expected.AddIgnoreTypes(typeof(WorkflowAbortedTrace));
expected.AddIgnoreTypes(typeof(SynchronizeTrace));
Exception exc;
TestWorkflowRuntime tr = TestRuntime.CreateTestWorkflowRuntime(outerSequence);
tr.CreateWorkflow();
tr.ResumeWorkflow();
tr.WaitForAborted(out exc, expected);
Assert.True((exc.GetType() == typeof(DataMisalignedException)) && exc.Message == "I am Miss.Aligned!");
}
//
// Example hint list describing 3 branches and the order of processing for CA's on each Branch
// { Branch, CA2, CA1, Branch, CA3, Branch, CA6, CA5, CA4 }
//
private void ProcessCompensationHints(IList <Directive> hints, string defaultAction, TraceGroup traceGroup)
{
// A splited flowchart Confirmation/Compensation are collections of unordered branch traces
// (similar to Parallel)
UnorderedTraces unordered = new UnorderedTraces();
OrderedTraces ordered = null;
foreach (Directive directive in hints)
{
// If we encounter a Branch directive that means we need to start a new OrderedTraces group
if (directive.Name == "Branch")
{
if (ordered != null) // Already had one, so add it to our collection before we create a new one
{
if (ordered.Steps.Count > 0) // There's a chance we didn't produce any output
{
unordered.Steps.Add(ordered);
}
}
ordered = new OrderedTraces();
}
else
{
TestActivity target = FindChildActivity(directive.Name);
TestCompensableActivity.ProcessDirective(target, directive, defaultAction, traceGroup);
}
}
// Was there one left over? (From the last branch directive)
if (ordered != null)
{
if (ordered.Steps.Count > 0) // There's a chance we didn't produce any output
{
unordered.Steps.Add(ordered);
}
}
if (unordered.Steps.Count > 0)
{
traceGroup.Steps.Add(unordered);
}
}
protected override void GetActivitySpecificTrace(Test.Common.TestObjects.Utilities.Validation.TraceGroup traceGroup)
{
UnorderedTraces parallelTraceGroup = null;
Outcome outcome = Outcome.Completed;
parallelTraceGroup = new UnorderedTraces();
foreach (TestPickBranch branch in this.Branches)
{
// Each Branch is Ordered with respect to itself (like normal)
OrderedTraces branchTraceGroup = new OrderedTraces();
Outcome bOutcome = branch.GetTriggerTrace(branchTraceGroup);
if (bOutcome.GetType() != typeof(Outcome))
{
outcome = bOutcome;
}
parallelTraceGroup.Steps.Add(branchTraceGroup);
}
traceGroup.Steps.Add(parallelTraceGroup);
parallelTraceGroup = new UnorderedTraces();
foreach (TestPickBranch branch in this.Branches)
{
// Each Branch is Ordered with respect to itself (like normal)
OrderedTraces branchTraceGroup = new OrderedTraces();
Outcome bOutcome = branch.GetActionTrace(branchTraceGroup);
if (bOutcome != null && bOutcome.GetType() != typeof(Outcome))
{
outcome = bOutcome;
}
parallelTraceGroup.Steps.Add(branchTraceGroup);
}
traceGroup.Steps.Add(parallelTraceGroup);
this.CurrentOutcome = outcome;
}
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());
}
protected override void GetActivitySpecificTrace(TraceGroup traceGroup)
{
UnorderedTraces parallelTraceGroup = new UnorderedTraces();
if (this.HintIterationCount < 0 && _values == null)
{
return;
}
if (this.HintIterationCount < 0 && _values != null)
{
this.HintIterationCount = _values.Count <T>();
}
if (_valuesActivity != null)
{
Outcome conditionOutcome = _valuesActivity.GetTrace(traceGroup);
if (conditionOutcome.DefaultPropogationState != OutcomeState.Completed)
{
// propogate the unknown outcome upwards
this.CurrentOutcome = conditionOutcome;
}
}
if (this.Body != null)
{
Outcome outc;
for (int i = 1; i < _values.Count <T>() + 1; i++)
{
OrderedTraces orderedTraceGroup = new OrderedTraces();
if (HintIterationCount < i)
{
TestDummyTraceActivity tdt = new TestDummyTraceActivity(Body.DisplayName)
{
ExpectedOutcome = Outcome.Canceled
};
tdt.GetTrace(orderedTraceGroup);
}
else
{
outc = this.Body.GetTrace(orderedTraceGroup);
if (this.ProductParallelForEach.CompletionCondition != null && outc.DefaultPropogationState != OutcomeState.Canceled)
{
TestDummyTraceActivity condition = new TestDummyTraceActivity(this.ProductParallelForEach.CompletionCondition, ConditionOutcome);
CurrentOutcome = condition.GetTrace(orderedTraceGroup);
}
if (outc.DefaultPropogationState != OutcomeState.Completed)
{
CurrentOutcome = outc;
}
}
parallelTraceGroup.Steps.Add(orderedTraceGroup);
}
traceGroup.Steps.Add(parallelTraceGroup);
}
}
protected override void GetActivitySpecificTrace(TraceGroup traceGroup)
{
// Parallel is a collection of unordered branches
UnorderedTraces parallelTraceGroup = new UnorderedTraces();
bool oneCompleted = false;
int index = 0;
foreach (TestActivity branch in _branches)
{
// Each Branch is Ordered with respect to itself (like normal)
OrderedTraces branchTraceGroup = new OrderedTraces();
if (_numberOfBranchesExecution == index)
{
// so if we have gone past the hint
if (branch.ExpectedOutcome.DefaultPropogationState == OutcomeState.Completed)
{
TestDummyTraceActivity tdt = new TestDummyTraceActivity(branch.DisplayName)
{
ExpectedOutcome = Outcome.Canceled
};
tdt.GetTrace(branchTraceGroup);
}
}
else
{
index++;
Outcome bOutcome = branch.GetTrace(branchTraceGroup);
if (bOutcome.DefaultPropogationState == OutcomeState.Completed)
{
oneCompleted = true;
if (this.ProductParallel.CompletionCondition != null)
{
if (_expressionActivity != null)
{
CurrentOutcome = _expressionActivity.GetTrace(branchTraceGroup);
}
else
{
TestDummyTraceActivity tdt = new TestDummyTraceActivity(this.ProductParallel.CompletionCondition, Outcome.Completed);
CurrentOutcome = tdt.GetTrace(branchTraceGroup);
}
}
}
else if (CurrentOutcome.IsOverrideable)
{
CurrentOutcome = bOutcome;
}
}
parallelTraceGroup.Steps.Add(branchTraceGroup);
}
// If there's at least one good branch and the CompletionCondition is true, we probably succeeded
if (oneCompleted && _completionCondition)
{
this.CurrentOutcome = Outcome.Completed;
}
traceGroup.Steps.Add(parallelTraceGroup);
}
public void SetDelegateArgument()
{
// for using delegate argument
TheStruct valueType = new TheStruct();
int indiceValue = 2;
DelegateInArgument <int> indice = new DelegateInArgument <int>();
Variable <TheStruct> var = VariableHelper.CreateInitialized <TheStruct>("var", valueType);
TestValueTypeIndexerReference <TheStruct, int> valueTypeIndexerReference = new TestValueTypeIndexerReference <TheStruct, int>()
{
OperandLocationVariable = var,
};
valueTypeIndexerReference.Indices.Add(new TestArgument <int>(Direction.In, null, (env) => indice.Get(env)));
int value = 321;
TestAssign <int> testAssign = new TestAssign <int>()
{
ToLocation = valueTypeIndexerReference, Value = value
};
TestSequence seq = new TestSequence()
{
Activities =
{
testAssign,
new TestWriteLine {
MessageExpression = ((ctx) => var.Get(ctx)[indiceValue].ToString())
}
}
};
CoreWf.Statements.Sequence outerSeq = new CoreWf.Statements.Sequence()
{
Variables =
{
var
},
Activities =
{
new InvokeAction <int>()
{
Argument = indiceValue,
Action = new ActivityAction <int>()
{
Argument = indice,
Handler = seq.ProductActivity
}
}
}
};
TestCustomActivity testActivity = TestCustomActivity <CoreWf.Statements.Sequence> .CreateFromProduct(outerSeq);
UnorderedTraces traces = new UnorderedTraces()
{
Steps =
{
new UserTrace(value.ToString())
}
};
testActivity.ActivitySpecificTraces.Add(traces);
ExpectedTrace expectedTrace = testActivity.GetExpectedTrace();
expectedTrace.AddIgnoreTypes(typeof(ActivityTrace));
TestRuntime.RunAndValidateWorkflow(testActivity, expectedTrace);
}
