public void SimpleIfElse()
{
// Test case description:
// Have simple if-else scenario with if, and else
TestSequence outerSequence = new TestSequence("sequence1");
TestSequence innerSequence = new TestSequence("sequence act");
TestAssign <int> changeCounter = new TestAssign <int>("Elif");
Variable <int> counter = VariableHelper.CreateInitialized <int>("counter", 0);
TestWriteLine writeLine = new TestWriteLine("write hello")
{
Message = "Its a small world after all"
};
changeCounter.ToVariable = counter;
changeCounter.ValueExpression = (env) => ((int)counter.Get(env)) + 15;
TestIf ifAct = new TestIf("if act1", HintThenOrElse.Else)
{
ConditionExpression = ((env) => ((int)counter.Get(env)) > 10),
ThenActivity = new TestWriteLine("NotExecuting", "Wont Execute"),
ElseActivity = changeCounter
};
TestIf ifAct2 = new TestIf("if act 2", HintThenOrElse.Then)
{
ConditionExpression = ((env) => ((int)counter.Get(env)) > 10),
ThenActivity = innerSequence,
};
outerSequence.Activities.Add(ifAct);
outerSequence.Activities.Add(ifAct2);
innerSequence.Activities.Add(writeLine);
outerSequence.Variables.Add(counter);
TestRuntime.RunAndValidateWorkflow(outerSequence);
}
public void DoWhileWithWorkFlowInvoker()
{
Variable <int> counter = VariableHelper.CreateInitialized <int>("counter", 0);
TestAssign <int> increment = new TestAssign <int>("Increment Counter");
increment.ToVariable = counter;
increment.ValueExpression = ((env) => (((int)counter.Get(env))) + 1);
TestDoWhile doWhile = new TestDoWhile("dowhile")
{
ConditionExpression = (env) => ((int)counter.Get(env)) < 2,
Body = increment,
HintIterationCount = 2,
Variables = { counter }
};
TestWriteLine writeLine = new TestWriteLine("write hello");
writeLine.Message = "Its a small world after all";
TestRuntime.RunAndValidateUsingWorkflowInvoker(doWhile, null, null, null);
}
public void ThrowExceptionFromSetterOfCustomTypeProperty()
{
//
// Test case description:
// Try setting a property which throws from setter.
TheStruct valueType = new TheStruct();
Variable <TheStruct> var = new Variable <TheStruct>()
{
Default = valueType, Name = "var"
};
TestValueTypePropertyReference <TheStruct, int> valueTypePropertyReference = new TestValueTypePropertyReference <TheStruct, int>()
{
PropertyName = "ThrowInSetterProperty",
OperandLocationVariable = var,
};
int value = 321;
TestAssign <int> testAssign = new TestAssign <int>()
{
ToLocation = valueTypePropertyReference,
Value = value,
ExpectedOutcome = Outcome.UncaughtException(typeof(System.Reflection.TargetInvocationException)),
};
TestSequence seq = new TestSequence()
{
Variables = { var },
Activities =
{
testAssign,
}
};
TestRuntime.RunAndValidateAbortedException(seq, typeof(System.Reflection.TargetInvocationException), null);
}
public void NestedFlowchartInLoop()
{
TestFlowchart parentFlowchart = new TestFlowchart("ParentFlowchart");
TestFlowchart childFlowchart = new TestFlowchart("ChildFlowchart");
Variable <int> counter = VariableHelper.CreateInitialized <int>("counter", 0);
parentFlowchart.Variables.Add(counter);
TestAssign <int> assign = new TestAssign <int>("Assign1")
{
ValueExpression = (env => ((int)counter.Get(env)) + 1),
ToVariable = counter
};
List <HintTrueFalse> hints = new List <HintTrueFalse>();
for (int i = 0; i < 5; i++)
{
hints.Add(HintTrueFalse.True);
}
hints.Add(HintTrueFalse.False);
TestFlowConditional flowDecision = new TestFlowConditional(hints.ToArray())
{
ConditionExpression = (env => counter.Get(env) <= 5)
};
parentFlowchart.AddLink(new TestWriteLine("Start", "Parent started"), childFlowchart);
parentFlowchart.AddConditionalLink(childFlowchart, flowDecision, childFlowchart, new TestWriteLine("End", "Parent ended"));
childFlowchart.AddStartLink(assign);
TestRuntime.RunAndValidateWorkflow(parentFlowchart);
}
public void WriteLineInWhileActivity()
{
Variable <int> counter = VariableHelper.CreateInitialized <int>("counter", 0);
TestAssign <int> increment = new TestAssign <int>("Increment Counter");
string textVariable = "Loop";
Variable <string> stringToWrite = VariableHelper.CreateInitialized <string>(
"stringToWrite",
textVariable);
// We don't really need to do Console.SetOut for this test. But we use
// ConsoleSetOut to create the streamWriter that we use as the TextWriter
// property of the product's WriteLine activity.
using (StreamWriter streamWriter = ConsoleSetOut(false))
{
Variable <TextWriter> writer = VariableHelper.CreateInitialized <TextWriter>(
"writer",
streamWriter);
increment.ToVariable = counter;
increment.ValueExpression = ((env) => (((int)counter.Get(env))) + 1);
TestSequence innersequence = new TestSequence
{
Variables =
{
stringToWrite,
writer
},
Activities =
{
new TestProductWriteline("Write on a file in while loop")
{
TextExpression = ((env) => (((string)stringToWrite.Get(env))) + counter.Get(env).ToString()),
TextWriterVariable = writer,
},
increment,
}
};
TestSequence outerSequence = new TestSequence
{
Activities =
{
new TestWhile("While loop")
{
Body = innersequence,
ConditionExpression = ((env) => ((int)counter.Get(env)) < 5),
HintIterationCount = 5
}
},
Variables =
{
counter
}
};
TestRuntime.RunAndValidateWorkflow(outerSequence);
}
VerifyTextOfWriteLine(
_tempFilePath,
textVariable + "0",
textVariable + "1",
textVariable + "2",
textVariable + "3",
textVariable + "4");
}
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);
}
public void EmptyAssignmentStandAlone()
{
TestAssign <string> assign = new TestAssign <string>();
TestRuntime.ValidateInstantiationException(assign, typeof(System.ArgumentException), string.Format(ErrorStrings.RequiredArgumentValueNotSupplied, "Value"));
}
public void NestedWhilesAndOtherLoops()
{
// Test case description:
// Nested whiles deep up to 3-5 levels. Set valid conditions trace the order to be likewhile1 loop1 while2
// loop 1 while 3 loop1 while1 loop1 while2 loop1 whle3 loop2while1 loop1 while2 loop2 while3 loop1whlie1
// loop1 while2 loop2 while3 loop2…while1 loop2 while2 loop2 while3 loop2
TestSequence outerSequence = new TestSequence("sequence1");
TestSequence innerSequence = new TestSequence("inner seq");
TestAssign <int> increment = new TestAssign <int>("increase count");
Variable <int> doWhileCounter = VariableHelper.CreateInitialized <int>("counter", 0);
Variable <int> loopCounter = VariableHelper.CreateInitialized <int>("loopcounter", 0);
TestAssign <int> loopCounterIncrement = new TestAssign <int>("increase loop counter")
{
ToVariable = loopCounter,
ValueExpression = ((env) => ((int)loopCounter.Get(env)) + 1)
};
increment.ToVariable = doWhileCounter;
increment.ValueExpression = ((env) => ((int)doWhileCounter.Get(env)) + 1);
TestForEach <string> foreachAct = new TestForEach <string>("ForEach")
{
Body = innerSequence,
ValuesExpression = (context => new List <string>()
{
"var1", "var2", "var3"
}),
HintIterationCount = 3,
};
TestDoWhile doWhile = new TestDoWhile("do while")
{
ConditionExpression = ((env) => ((int)doWhileCounter.Get(env)) < 9),
Body = foreachAct,
HintIterationCount = 3,
};
TestSequence whileSequence = new TestSequence("sequence1");
TestSequence innerIfSequence = new TestSequence("inner if sequence");
TestAssign <int> whileIncrement = new TestAssign <int>("increase count2");
Variable <int> whileCounter = VariableHelper.CreateInitialized <int>("counter2", 0);
TestSequence ifSequence = new TestSequence("ifSequence");
TestWhile whileAct = new TestWhile("while")
{
ConditionExpression = ((env) => ((int)whileCounter.Get(env)) < 10),
Body = ifSequence,
HintIterationCount = 10,
};
TestWriteLine writeLine = new TestWriteLine("write hello")
{
Message = "Its a small world after all"
};
TestWriteLine writeLine2 = new TestWriteLine("write hello")
{
Message = "Its a small world after all"
};
whileIncrement.ToVariable = whileCounter;
whileIncrement.ValueExpression = ((env) => ((int)whileCounter.Get(env)) + 1);
TestIf ifAct = new TestIf("ifact 1", HintThenOrElse.Else)
{
ConditionExpression = ((env) => ((int)whileCounter.Get(env)) > 10),
ThenActivity = new TestWriteLine("w1", "I'm a non-executing funny writeLine"),
ElseActivity = writeLine2,
};
TestIf ifAct2 = new TestIf("if act 2", HintThenOrElse.Then)
{
ConditionExpression = ((env) => ((int)whileCounter.Get(env)) < 10),
ThenActivity = innerIfSequence,
};
TestIf checkLoopCount = new TestIf("check loop count", HintThenOrElse.Then)
{
ConditionExpression = ((env) => ((int)loopCounter.Get(env)) == 90),
ThenActivity = writeLine,
};
ifSequence.Activities.Add(ifAct);
ifSequence.Activities.Add(ifAct2);
innerIfSequence.Activities.Add(whileIncrement);
innerIfSequence.Activities.Add(loopCounterIncrement);
whileSequence.Variables.Add(whileCounter);
whileSequence.Activities.Add(whileAct);
innerSequence.Activities.Add(increment);
innerSequence.Activities.Add(whileSequence);
outerSequence.Activities.Add(doWhile);
outerSequence.Activities.Add(checkLoopCount);
outerSequence.Variables.Add(doWhileCounter);
outerSequence.Variables.Add(loopCounter);
TestRuntime.RunAndValidateWorkflow(outerSequence);
}
public void ExecuteFiveLevelDeepNestedLoops()
{
TestFlowchart flowchart = new TestFlowchart("Flowchart1");
Variable <int> loop1Counter = VariableHelper.CreateInitialized <int>("Loop1Counter", 0);
flowchart.Variables.Add(loop1Counter);
Variable <int> loop2Counter = VariableHelper.CreateInitialized <int>("Loop2Counter", 0);
flowchart.Variables.Add(loop2Counter);
Variable <int> loop3Counter = VariableHelper.CreateInitialized <int>("Loop3Counter", 0);
flowchart.Variables.Add(loop3Counter);
Variable <int> loop4Counter = VariableHelper.CreateInitialized <int>("Loop4Counter", 0);
flowchart.Variables.Add(loop4Counter);
Variable <int> loop5Counter = VariableHelper.CreateInitialized <int>("Loop5Counter", 0);
flowchart.Variables.Add(loop5Counter);
TestAssign <int> assign1 = new TestAssign <int>("Assign1");
assign1.ValueExpression = ((env) => (int)loop1Counter.Get(env) + 1);
assign1.ToVariable = loop1Counter;
TestAssign <int> assign2 = new TestAssign <int>("Assign2");
assign2.ValueExpression = ((env) => (int)loop2Counter.Get(env) + 1);
assign2.ToVariable = loop2Counter;
TestAssign <int> assign3 = new TestAssign <int>("Assign3");
assign3.ValueExpression = ((env) => (int)loop3Counter.Get(env) + 1);
assign3.ToVariable = loop3Counter;
TestAssign <int> assign4 = new TestAssign <int>("Assign4");
assign4.ValueExpression = ((env) => (int)loop4Counter.Get(env) + 1);
assign4.ToVariable = loop4Counter;
TestAssign <int> assign5 = new TestAssign <int>("Assign5");
assign5.ValueExpression = ((env) => (int)loop5Counter.Get(env) + 1);
assign5.ToVariable = loop5Counter;
List <HintTrueFalse> hintsList = new List <HintTrueFalse>();
for (int i = 0; i < 5; i++)
{
hintsList.Add(HintTrueFalse.True);
}
hintsList.Add(HintTrueFalse.False);
HintTrueFalse[] hints = hintsList.ToArray();
TestFlowConditional flowDecision1 = new TestFlowConditional(hints);
flowDecision1.ConditionExpression = (env => loop1Counter.Get(env) <= 5);
TestFlowConditional flowDecision2 = new TestFlowConditional(hints);
flowDecision2.ConditionExpression = (env => loop2Counter.Get(env) <= 5);
TestFlowConditional flowDecision3 = new TestFlowConditional(hints);
flowDecision3.ConditionExpression = (env => loop3Counter.Get(env) <= 5);
TestFlowConditional flowDecision4 = new TestFlowConditional(hints);
flowDecision4.ConditionExpression = (env => loop4Counter.Get(env) <= 5);
TestFlowConditional flowDecision5 = new TestFlowConditional(hints);
flowDecision5.ConditionExpression = (env => loop5Counter.Get(env) <= 5);
flowchart.AddLink(new TestWriteLine("Start", "Flowchart started"), assign1);
flowchart.AddLink(assign1, assign2);
flowchart.AddLink(assign2, assign3);
flowchart.AddLink(assign3, assign4);
flowchart.AddLink(assign4, assign5);
flowchart.AddConditionalLink(assign5, flowDecision5, assign5, flowDecision4);
flowchart.AddConditionalLink((TestActivity)null, flowDecision4, assign4, flowDecision3);
flowchart.AddConditionalLink((TestActivity)null, flowDecision3, assign3, flowDecision2);
flowchart.AddConditionalLink((TestActivity)null, flowDecision2, assign2, flowDecision1);
flowchart.AddConditionalLink((TestActivity)null, flowDecision1, assign1, new TestWriteLine("End", "Flowchart ended"));
TestRuntime.RunAndValidateWorkflow(flowchart);
}
public void NestedLoopsExecution()
{
TestFlowchart flowchart = new TestFlowchart("Flow1");
Variable <int> innerLoopcounter = VariableHelper.CreateInitialized <int>("InnerLoopCounter", 0);
flowchart.Variables.Add(innerLoopcounter);
Variable <int> outerLoopCounter = VariableHelper.CreateInitialized <int>("OuterLoopCounter", 0);
flowchart.Variables.Add(outerLoopCounter);
TestAssign <int> outerAssign = new TestAssign <int>("OuterAssign");
outerAssign.ValueExpression = ((env) => ((int)outerLoopCounter.Get(env)) + 1);
outerAssign.ToVariable = outerLoopCounter;
TestAssign <int> innerAssign = new TestAssign <int>("InnerAssign");
innerAssign.ValueExpression = (env) => ((int)innerLoopcounter.Get(env)) + 1;
innerAssign.ToVariable = innerLoopcounter;
TestAssign <int> resetInnerCounter = new TestAssign <int>("ResetInnerCounter");
resetInnerCounter.Value = 0;
resetInnerCounter.ToVariable = innerLoopcounter;
List <HintTrueFalse> outerHints = new List <HintTrueFalse>();
for (int i = 0; i < 9; i++)
{
outerHints.Add(HintTrueFalse.True);
}
outerHints.Add(HintTrueFalse.False);
TestFlowConditional outerFlowDecision = new TestFlowConditional(outerHints.ToArray());
outerFlowDecision.ConditionExpression = (context => outerLoopCounter.Get(context) < 10);
List <HintTrueFalse> innerHints = new List <HintTrueFalse>();
for (int i = 0; i < 4; i++)
{
innerHints.Add(HintTrueFalse.True);
}
innerHints.Add(HintTrueFalse.False);
TestFlowConditional innerFlowDecision = new TestFlowConditional(innerHints.ToArray());
innerFlowDecision.ConditionExpression = (context => innerLoopcounter.Get(context) < 5);
innerFlowDecision.ResetHints = true;
flowchart.AddLink(new TestWriteLine("Start", "Flowchart started"), outerAssign);
flowchart.AddLink(outerAssign, resetInnerCounter);
flowchart.AddLink(resetInnerCounter, innerAssign);
flowchart.AddConditionalLink(innerAssign, innerFlowDecision, innerAssign, outerFlowDecision);
flowchart.AddConditionalLink(null, outerFlowDecision, outerAssign, new TestWriteLine("End", "Flowchart completed"));
TestRuntime.RunAndValidateWorkflow(flowchart);
}
public void Flowchart_ForEach()
{
TestFlowchart flowchart = new TestFlowchart("Flow1");
List <int> tenInts = new List <int>()
{
1, 2, 3, 4, 5, 6, 7, 8, 9, 10
};
Variable <List <int> > listOfInts = new Variable <List <int> >("listOfInts",
(env) => new List <int>()
{
1, 2, 3, 4, 5, 6, 7, 8, 9, 10
});
flowchart.Variables.Add(listOfInts);
Variable <int> counter = VariableHelper.CreateInitialized <int>("counter", 0);
flowchart.Variables.Add(counter);
Variable <bool> boolVar = VariableHelper.CreateInitialized <bool>("boolVar", true);
flowchart.Variables.Add(boolVar);
Variable <IEnumerator <int> > intEnumerator = VariableHelper.Create <IEnumerator <int> >("intEnumerator");
flowchart.Variables.Add(intEnumerator);
TestAssign <IEnumerator <int> > assign1 = new TestAssign <IEnumerator <int> >("Assign1")
{
ValueExpression = ((env) => ((List <int>)listOfInts.Get(env)).GetEnumerator()),
ToVariable = intEnumerator
};
TestAssign <bool> assign2 = new TestAssign <bool>("Assign2")
{
ValueExpression = ((env) => ((IEnumerator <int>)intEnumerator.Get(env)).MoveNext()),
ToVariable = boolVar
};
List <HintTrueFalse> hints = new List <HintTrueFalse>();
for (int i = 0; i < 10; i++)
{
hints.Add(HintTrueFalse.True);
}
hints.Add(HintTrueFalse.False);
TestFlowConditional flowDecision = new TestFlowConditional(hints.ToArray())
{
ConditionExpression = (context => boolVar.Get(context) == true)
};
flowchart.AddStartLink(assign1);
flowchart.AddLink(assign1, assign2);
flowchart.AddConditionalLink(assign2, flowDecision, assign2, new TestWriteLine("End", "Flowchart ended"));
TestRuntime.RunAndValidateWorkflow(flowchart);
}
