/// <summary> /// Fault handled from flowchart in a try catch block. /// </summary> /// Disabled in desktop and failing. //[Fact] private void FlowchartInTryCatchBlock_FaultHandled() { TestFlowchart flowchart = new TestFlowchart(); flowchart.AddStartLink(new TestThrow <Exception>() { ExpectedOutcome = Outcome.CaughtException() }); TestTryCatch tryCatchFinally = new TestTryCatch { Try = flowchart, Catches = { new TestCatch <Exception> { Body = new TestWriteLine("ExceptionHandler", "Handled"), } } }; TestRuntime.RunAndValidateWorkflow(tryCatchFinally); }
public void FlowSwitchWithNullFlowNode() { TestFlowchart flowchart = new TestFlowchart(); Variable <int> expression = new Variable <int> { Name = "expression", Default = 1 }; flowchart.Variables.Add(expression); Dictionary <int, TestActivity> cases = new Dictionary <int, TestActivity>(); cases.Add(1, null); List <int> hints = new List <int>() { -1 }; flowchart.AddSwitchLink <int>(new TestWriteLine("Start", "Flowchart started"), cases, hints, expression); TestRuntime.RunAndValidateWorkflow(flowchart); }
public void NullAsValueOfElements() { TestParallelForEach <string> parallelForEach = new TestParallelForEach <string>("Parallel For Each") { Body = new TestWriteLine("Writeline") { Message = "I will be displayed" }, HintValues = new List <string>() { null }, ValuesExpression = (context => new List <string>() { null }), HintIterationCount = 1, }; ExpectedTrace tr = parallelForEach.GetExpectedTrace(); TestRuntime.RunAndValidateWorkflow(parallelForEach, tr); }
public void SimpleEmptyWhile() { // Test case description: // Set condition to a valid rule and run 5-6 iterations without any activities in. Variable <int> counter = VariableHelper.CreateInitialized <int>("counter", 0); TestSequence rootSequence = new TestSequence("rootSequence"); rootSequence.Variables.Add(counter); TestWhile whileAct = new TestWhile("while act") { ConditionExpression = ((env) => ((int)counter.Get(env)) < 0), Body = new TestSequence("innerseq"), HintIterationCount = 10, }; rootSequence.Activities.Add(whileAct); whileAct.Body = null; TestRuntime.RunAndValidateWorkflow(rootSequence); }
public void ConnectFromFlowconditionalTrueToFlowconditional() { TestFlowchart flowchart = new TestFlowchart(); TestWriteLine w1 = new TestWriteLine("w1", "w1"); TestWriteLine w2 = new TestWriteLine("w2", "w2"); TestFlowConditional conditional1 = new TestFlowConditional { Condition = true }; TestFlowConditional conditional2 = new TestFlowConditional { Condition = true }; flowchart.AddConditionalLink(w1, conditional1); flowchart.AddConditionalLink(null, conditional2, w2, (TestActivity)null); flowchart.AddConditionalLink(null, conditional1, conditional2, (TestActivity)null); TestRuntime.RunAndValidateWorkflow(flowchart); }
public void SimpleParallel() { TestWriteLine writeLine1 = new TestWriteLine { Message = "writeLine1", DisplayName = "writeLine1" }; TestWriteLine writeLine2 = new TestWriteLine { Message = "writeLine2", DisplayName = "writeLine2" }; TestParallel parallelActivity = new TestParallel("Parallel Activity"); parallelActivity.Branches.Add(writeLine1); parallelActivity.Branches.Add(writeLine2); ExpectedTrace trace = parallelActivity.GetExpectedTrace(); TestRuntime.RunAndValidateWorkflow(parallelActivity, trace); }
public void TryCatchFinallyInLoops() { Variable <int> count = new Variable <int>("Counter", 0); TestWhile whileAct = new TestWhile { Variables = { count }, ConditionExpression = e => count.Get(e) < 5, Body = new TestSequence { Activities = { new TestTryCatch { Try = new TestThrow <ArgumentException>() { ExpectedOutcome = Outcome.CaughtException() }, Catches = { { new TestCatch <ArgumentException>() { Body = new TestWriteLine("Caught", "Caught") } } }, Finally = new TestSequence{ Activities ={ new TestWriteLine("Finally", "Finally") } } }, new TestIncrement { CounterVariable = count, IncrementCount = 1 } } }, HintIterationCount = 5 }; TestRuntime.RunAndValidateWorkflow(whileAct); }
public void FlowSwitchConnectedToFlowDecision() { TestFlowchart flowchart = new TestFlowchart(); TestWriteLine wStart = new TestWriteLine("Start", "Flowchart started"); TestWriteLine wDefault = new TestWriteLine("Default", "Default"); TestWriteLine w1 = new TestWriteLine("One", "One wont execute"); TestWriteLine w3 = new TestWriteLine("Three", "Three wont execute"); TestWriteLine w2True = new TestWriteLine("True", "True will execute"); TestWriteLine w2False = new TestWriteLine("False", "False wont execute"); TestFlowStep fs1 = new TestFlowStep(w1); TestFlowStep fs3 = new TestFlowStep(w3); Variable <int> margin = VariableHelper.CreateInitialized <int>("Margin", 10); flowchart.Variables.Add(margin); TestFlowConditional flowDecision = new TestFlowConditional(HintTrueFalse.True); flowDecision.ConditionExpression = (context => margin.Get(context) > 0); flowchart.AddConditionalLink(null, flowDecision, w2True, w2False); Dictionary <string, TestFlowElement> cases = new Dictionary <string, TestFlowElement>(); cases.Add("One", fs1); cases.Add("Two", flowDecision); cases.Add("Three", fs3); List <int> hints = new List <int>(); hints.Add(1); flowchart.AddStartLink(wStart); flowchart.AddSwitchLink <string>(wStart, cases, hints, "Two", wDefault); TestRuntime.RunAndValidateWorkflow(flowchart); }
public void ThrowWithCaseInfinity() { TestSwitch <float> switchAct = new TestSwitch <float>(); Variable <float> temp = VariableHelper.CreateInitialized <float>("temp", 3); float temp1 = 1; float temp2 = 0; TestSequence seq = new TestSequence(); seq.Activities.Add(switchAct); seq.Variables.Add(temp); switchAct.AddCase(123, new TestWriteLine("Seq") { Message = "" }); switchAct.AddCase(temp1 / temp2, new TestWriteLine() { Message = "Infinity is the value" }); switchAct.ExpressionExpression = (env) => (float)(1 / (temp.Get(env) - 3)); switchAct.Hints.Add(1); TestRuntime.RunAndValidateWorkflow(seq); }
public void IfThenBodyHasVariable() { const string varValue = "hello world"; Variable <string> var = VariableHelper.CreateInitialized <string>("aVariable", varValue); TestIf testIf = new TestIf("MyIf", HintThenOrElse.Then) { Condition = true, ThenActivity = new TestSequence("then Branch") { Variables = { var, }, Activities = { new TestWriteLine("Then WriteLine", var, varValue), }, }, ElseActivity = new TestWriteLine("else Branch", "it would not be displayed"), }; TestRuntime.RunAndValidateWorkflow(testIf); }
public void AccessFirstItemOfAnArray() { Variable <Complex[]> complexArrayVar = new Variable <Complex[]> { Name = "ComplexArrVar" }; Variable <Complex> result = new Variable <Complex>() { Name = "Result" }; TestSequence seq = new TestSequence { Variables = { complexArrayVar, result }, Activities = { new TestAssign <Complex[]> { ToVariable = complexArrayVar, ValueExpression = (context => new Complex[]{ new Complex(0, 0), new Complex(1, 1) }) }, new TestArrayItemValue <Complex> { DisplayName = "GetValue", ArrayVariable = complexArrayVar, Index = 0, Result = result }, new TestWriteLine { MessageExpression = e => result.Get(e).ToString(), HintMessage = new Complex(0, 0).ToString() } } }; TestRuntime.RunAndValidateWorkflow(seq); }
public void DoWhileConditionExpressionInConstructor() { Variable <bool> var = new Variable <bool>("var", false); TestSequence seq = new TestSequence() { Activities = { new TestDoWhile(env => var.Get(env).Equals(true)) { Body = new TestWriteLine("Hello", "Hello"), HintIterationCount = 1 } }, Variables = { var } }; TestRuntime.RunAndValidateWorkflow(seq); }
public void FlowDecisionAndFlowSwitchNotConnected() { TestFlowchart flowchart1 = new TestFlowchart("flowChart1"); TestWriteLine start1 = new TestWriteLine("Start", "Executing Start"); TestWriteLine w1 = new TestWriteLine("W1", "Executing W1"); TestWriteLine w2 = new TestWriteLine("W2", "Executing W2"); TestWriteLine w3 = new TestWriteLine("W3", "Executing W3"); TestWriteLine wDefault = new TestWriteLine("wDefault", "Executing wDefault"); Dictionary <string, TestActivity> cases = new Dictionary <string, TestActivity>(); cases.Add("One", w1); cases.Add("Two", w2); List <int> hints = new List <int>(); hints.Add(1); flowchart1.AddSwitchLink <string>(null, cases, hints, "Two", wDefault); TestWriteLine w2True = new TestWriteLine("True", "True will execute"); TestWriteLine w2False = new TestWriteLine("False", "False wont execute"); Variable <int> margin = VariableHelper.CreateInitialized <int>("Margin", 10); flowchart1.Variables.Add(margin); TestFlowConditional flowDecision = new TestFlowConditional(HintTrueFalse.True) { ConditionExpression = (context => margin.Get(context) > 0) }; TestFlowElement tCond = flowchart1.AddConditionalLink(null, flowDecision, w2True, w2False); flowchart1.Elements.Add(tCond); TestRuntime.RunAndValidateWorkflow(flowchart1); }
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 BasicParallelForEachTest() { TestSequence outerSequence = new TestSequence("sequence1"); TestSequence innerSequence = new TestSequence("innerSeq"); DelegateInArgument <string> i = new DelegateInArgument <string>() { Name = "i" }; string[] strArray = new string[] { "var1", "var2", "var3" }; TestParallelForEach <string> foreachAct = new TestParallelForEach <string>("foreach"); foreachAct.HintValues = new string[] { "var1", "var2", "var3" }; foreachAct.ValuesExpression = (context => new string[] { "var1", "var2", "var3" }); foreachAct.CurrentVariable = i; foreachAct.HintIterationCount = 3; TestWriteLine writeLine = new TestWriteLine("write hello"); writeLine.MessageExpression = ((env) => string.Format("WriteLine Argument: {0}", i.Get(env))); for (int counter = strArray.Length - 1; counter > -1; counter--) { writeLine.HintMessageList.Add("WriteLine Argument: " + strArray[counter]); } foreachAct.Body = innerSequence; innerSequence.Activities.Add(writeLine); outerSequence.Activities.Add(foreachAct); ExpectedTrace tr = outerSequence.GetExpectedTrace(); TestRuntime.RunAndValidateWorkflow(outerSequence, tr); }
public void FlowSwitchExpressionEvaluationEmptyExecuteEmptyCase() { TestFlowchart flowchart = new TestFlowchart(); Variable <string> expVariable = new Variable <string> { Name = "ExpVar", Default = string.Empty }; flowchart.Variables.Add(expVariable); Dictionary <string, TestActivity> cases = new Dictionary <string, TestActivity>(); cases.Add(string.Empty, new TestWriteLine("Hello0", "Hello0")); cases.Add("One", new TestWriteLine("Hello1", "Hello1")); List <int> hints = new List <int>() { 0 }; flowchart.AddSwitchLink(new TestWriteLine("Start", "Flowchart started"), cases, hints, e => expVariable.Get(e), new TestWriteLine("Default", "Default Activity")); TestRuntime.RunAndValidateWorkflow(flowchart); }
public void OneBranch() { TestPick pick = new TestPick() { DisplayName = "PickActivity", Branches = { new TestPickBranch() { DisplayName = "OneBranch", Trigger = new TestWriteLine("Trigger1") { Message = "Trigger1 Executing", }, Action = new TestWriteLine("Action1") { Message = "Action1", }, }, } }; TestRuntime.RunAndValidateWorkflow(pick); }
/// <summary> /// Simple tcf scenario in a flowchart wf. Exception is thrown then caught. /// </summary> /// Disabled and failed in desktop //[Fact] public void SimpleTryCatchFlowchart() { // try TestSequence trySeq = new TestSequence(); trySeq.Activities.Add(new TestWriteLine("Try", "Try")); trySeq.Activities.Add(new TestThrow <ArgumentException>()); trySeq.Activities.Add(new TestWriteLine("NotCalled", "NotCalled")); // catch TestCatch[] catches = new TestCatch[] { new TestCatch <ArgumentException>() }; catches[0].HintHandleException = true; catches[0].Body = new TestWriteLine("Catch", "Catch"); // finally TestSequence finalSeq = new TestSequence(); finalSeq.Activities.Add(new TestWriteLine("Final", "Final")); TestRuntime.RunAndValidateWorkflow (CreateTryCatchFinally(trySeq, catches, finalSeq, WFType.FLOW, false)); }
public void WriteTextUsingStringWriter() { StringBuilder stringBuilder = new StringBuilder(); string stringToWrite = "\nWriting text to a file with StreamWriter object"; using (StringWriter stringWriter = new StringWriter(stringBuilder)) { TestSequence sequence = new TestSequence { Activities = { new TestProductWriteline("Write with StringWriter") { Text = stringToWrite, TextWriterExpression = context => stringWriter } } }; TestRuntime.RunAndValidateWorkflow(sequence); Assert.True((stringBuilder.ToString().Equals(stringToWrite + "\r\n")), "String builder did not equal the string to be written."); } }
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"); writeLine.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 FlowSwitchWithBothKeyAndValueNull() { TestFlowchart flowchart = new TestFlowchart(); Variable <string> stringVar = VariableHelper.CreateInitialized <string>("stringVar", (string)null); flowchart.Variables.Add(stringVar); Dictionary <object, TestActivity> cases = new Dictionary <object, TestActivity>(); cases.Add("One", new TestWriteLine("One", "One")); cases.Add("Two", new TestWriteLine("Two", "Two")); cases.Add("Three", new TestWriteLine("Three", "Three")); List <int> hints = new List <int> { 3 }; TestFlowSwitch <object> flowSwitch = flowchart.AddSwitchLink <object>(new TestWriteLine("Start", "Flowchart started"), cases, hints, e => stringVar.Get(e)) as TestFlowSwitch <object>; flowSwitch.AddNullCase(null); TestRuntime.RunAndValidateWorkflow(flowchart); }
public void SimpleFlowSwitchWithThreeElements() { TestFlowchart flowchart = new TestFlowchart(); Variable <object> expression = new Variable <object>("expression", context => "Two"); flowchart.Variables.Add(expression); TestWriteLine w1 = new TestWriteLine("One", "One wont execute"); TestWriteLine w2 = new TestWriteLine("Two", "Two will execute"); TestWriteLine w3 = new TestWriteLine("Three", "Three wont execute"); Dictionary <object, TestActivity> cases = new Dictionary <object, TestActivity>(); cases.Add("One", w1); cases.Add("Two", w2); cases.Add("Three", w3); List <int> hints = new List <int>(); hints.Add(1); flowchart.AddSwitchLink(new TestWriteLine("Start", "Flowchart started"), cases, hints, expression, new TestWriteLine("Default", "Default")); TestRuntime.RunAndValidateWorkflow(flowchart); }
public void NestedIfElseWhenTheConditionsAreTotallyOpposite() { // Test case description: // Have nested if-else activities in which: if branch checks if A is true,Its first child is another if // else and checks if A is false, meaning that it will not be executed at all. In this case we probably // will not be having a validation errror that foresees that it wont be executed however this case is // still valid to check the behavior - this leads to the question of if there will be "detection of // unreachable code" TestSequence outerSequence = new TestSequence("sequence1"); TestSequence innerSequence = new TestSequence("inner sequence"); Variable <int> counter = VariableHelper.CreateInitialized <int>("counter", 5); TestWriteLine writeLine = new TestWriteLine("write hello") { Message = "Its a small world after all" }; TestIf ifAct = new TestIf("if1", HintThenOrElse.Else) { ConditionExpression = ((env) => ((int)counter.Get(env)) > 10), ThenActivity = new TestWriteLine("NotExecuting Writeline", "NotExecuting"), ElseActivity = innerSequence, }; TestIf ifAct2 = new TestIf("if2", HintThenOrElse.Then) { ConditionExpression = ((env) => ((int)counter.Get(env)) < 10), ThenActivity = ifAct, }; TestIf ifAct3 = new TestIf("if3", HintThenOrElse.Else) { ConditionExpression = ((env) => ((int)counter.Get(env)) > 10), ThenActivity = new TestWriteLine("NotExecuting Writeline", "NotExecuting"), ElseActivity = ifAct2, }; TestIf ifAct4 = new TestIf("if4", HintThenOrElse.Then) { ConditionExpression = ((env) => ((int)counter.Get(env)) < 10), ThenActivity = ifAct3, }; TestIf ifAct5 = new TestIf("if5", HintThenOrElse.Else) { ConditionExpression = ((env) => ((int)counter.Get(env)) > 10), ThenActivity = new TestWriteLine("NotExecuting Writeline", "NotExecuting"), ElseActivity = ifAct4, }; TestIf ifAct6 = new TestIf("if6", HintThenOrElse.Then) { ConditionExpression = ((env) => ((int)counter.Get(env)) < 10), ThenActivity = ifAct5, }; TestIf ifAct7 = new TestIf("if7", HintThenOrElse.Else) { ConditionExpression = ((env) => ((int)counter.Get(env)) > 10), ThenActivity = new TestWriteLine("NotExecuting Writeline", "NotExecuting"), ElseActivity = ifAct6, }; TestIf ifAct8 = new TestIf("if8", HintThenOrElse.Then) { ConditionExpression = ((env) => ((int)counter.Get(env)) < 10), ThenActivity = ifAct7, }; TestIf ifAct9 = new TestIf("if9", HintThenOrElse.Else) { ConditionExpression = ((env) => ((int)counter.Get(env)) > 10), ThenActivity = new TestWriteLine("NotExecuting Writeline", "NotExecuting"), ElseActivity = ifAct8, }; TestIf ifAct10 = new TestIf("if10", HintThenOrElse.Then) { ConditionExpression = ((env) => ((int)counter.Get(env)) < 10), ThenActivity = ifAct9, }; innerSequence.Activities.Add(writeLine); outerSequence.Variables.Add(counter); outerSequence.Activities.Add(ifAct10); TestRuntime.RunAndValidateWorkflow(outerSequence); }
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 ExecuteEmptyFlowchart() { TestFlowchart flowchart = new TestFlowchart("Flowchart1"); TestRuntime.RunAndValidateWorkflow(flowchart); }
public void StartNodeNullNodeCollectionNull() { TestFlowchart flowchart = new TestFlowchart(); TestRuntime.RunAndValidateWorkflow(flowchart); }
public void DifferentArguments() { //Testing Different argument types for If.Condition // DelegateInArgument // DelegateOutArgument // Activity<T> // Variable<T> , Activity<T> and Expression is already implemented. DelegateInArgument <bool> delegateInArgument = new DelegateInArgument <bool>("Condition"); DelegateOutArgument <bool> delegateOutArgument = new DelegateOutArgument <bool>("Output"); TestCustomActivity <InvokeFunc <bool, bool> > invokeFunc = TestCustomActivity <InvokeFunc <bool, bool> > .CreateFromProduct( new InvokeFunc <bool, bool> { Argument = true, Func = new ActivityFunc <bool, bool> { Argument = delegateInArgument, Result = delegateOutArgument, Handler = new System.Activities.Statements.Sequence { DisplayName = "Sequence1", Activities = { new System.Activities.Statements.If { DisplayName = "If1", Condition = delegateInArgument, Then = new System.Activities.Statements.Sequence { DisplayName = "Sequence2", Activities = { new System.Activities.Statements.Assign <bool> { DisplayName = "Assign1", Value = delegateInArgument, To = delegateOutArgument, }, new System.Activities.Statements.If { DisplayName = "If2", Condition = delegateOutArgument, Then = new System.Activities.Statements.WriteLine { DisplayName = "W1", Text = "Tested DelegateIn and DelegateOut arguments in If condition" }, } } } } }, } } } ); TestSequence sequenceForTracing = new TestSequence { DisplayName = "Sequence1", Activities = { new TestIf(HintThenOrElse.Then) { DisplayName = "If1", ThenActivity = new TestSequence { DisplayName = "Sequence2", Activities = { new TestAssign <bool> { DisplayName = "Assign1" }, new TestIf(HintThenOrElse.Then) { DisplayName = "If2", ThenActivity = new TestSequence("W1"), } } } } } }; invokeFunc.CustomActivityTraces.Add(sequenceForTracing.GetExpectedTrace().Trace); TestIf root = new TestIf(HintThenOrElse.Then) { ConditionActivity = invokeFunc, ThenActivity = new TestWriteLine { Message = "True", HintMessage = "True" }, ElseActivity = new TestWriteLine { Message = "False", HintMessage = "This is not expected" }, }; TestRuntime.RunAndValidateWorkflow(root); }
public void BasicSeqeunceDifferentTypesOfVariables() { // Test case description: // Sequence activity with variables of different data types (i.e. enums, enum with flags, nullables, // Type, collections, generic collections, structs, UDTs) Dictionary <double, Guid> dict = new Dictionary <double, Guid>(); dict.Add(12.123, Guid.Empty); dict.Add(23.44, new Guid("03998230918103948213098130981309")); dict.Add(-0.233, new Guid("99999999-9999-9999-0000-123456789102")); HashSet <ulong> hashSet = new HashSet <ulong>(); hashSet.Add(90923023); hashSet.Add(232300000); hashSet.Add(0); hashSet.Add(333); hashSet.Add(ulong.MaxValue); hashSet.Add(ulong.MinValue); UriBuilder anotherweirdtype = new UriBuilder("http://www.live.com"); Stream stream = new MemoryStream(); Variable <Dictionary <double, Guid> > dictionary = VariableHelper.CreateInitialized <Dictionary <double, Guid> >("dictionary", context => dict); Variable <HashSet <ulong> > hash = VariableHelper.CreateInitialized <HashSet <ulong> >("hash", hashSet); Variable <UriBuilder> uribuild = VariableHelper.CreateInitialized <UriBuilder>("uribuild", anotherweirdtype); Variable <Stream> streaminUSA = VariableHelper.CreateInitialized <Stream>("streaminUSA", stream); Guid outguid = Guid.Empty; TestSequence sequence = new TestSequence("Sequence1") { Variables = { dictionary, hash, uribuild, streaminUSA }, Activities = { new TestIf("if activity") { ConditionExpression = ((env) => ((Dictionary <double, Guid>)dictionary.Get(env)).TryGetValue(-0.233, out outguid)), ThenActivity = new TestWriteLine("In if 1", "In if 1"), }, new TestIf("if activity") { ConditionExpression = ((env) => ((HashSet <ulong>)hash.Get(env)).SetEquals(hashSet)), ThenActivity = new TestWriteLine("In if 2", "In if 2"), }, new TestIf("if activity") { ConditionExpression = ((env) => ((UriBuilder)uribuild.Get(env)).Equals(new Uri("http://www.live.com"))), ThenActivity = new TestWriteLine("In if 3", "In if 3"), }, new TestIf("if activity") { ConditionExpression = ((env) => ((Stream)streaminUSA.Get(env)).Equals(stream)), ThenActivity = new TestWriteLine("In if 4", "In if 4"), }, } }; TestRuntime.RunAndValidateWorkflow(sequence); if (outguid.CompareTo(new Guid("99999999-9999-9999-0000-123456789102")) != 0) { throw new Exception("guid value is wrong"); } }
public void DifferentArguments() { //Testing Different argument types for Switch.Expression // DelegateInArgument // DelegateOutArgument // Activity<T> // Variable<T> , Activity<T> and Expression is already implemented. DelegateInArgument <string> delegateInArgument = new DelegateInArgument <string>("Input"); DelegateOutArgument <string> delegateOutArgument = new DelegateOutArgument <string>("Output"); TestCustomActivity <InvokeFunc <string, string> > invokeFunc = TestCustomActivity <InvokeFunc <string, string> > .CreateFromProduct( new InvokeFunc <string, string> { Argument = "PassedInValue", Func = new ActivityFunc <string, string> { Argument = delegateInArgument, Result = delegateOutArgument, Handler = new CoreWf.Statements.Sequence { DisplayName = "Sequence1", Activities = { new CoreWf.Statements.Switch <string> { DisplayName = "Switch1", Expression = delegateInArgument, Cases = { { "PassedInValue", new CoreWf.Statements.Assign <string> { DisplayName = "Assign1", To = delegateOutArgument, Value = "OutValue", } }, }, Default = new Test.Common.TestObjects.CustomActivities.WriteLine{ DisplayName = "W1", Message = "This should not be printed" }, }, new CoreWf.Statements.Switch <string> { DisplayName = "Switch2", Expression = delegateOutArgument, Cases = { { "OutValue", new Test.Common.TestObjects.CustomActivities.WriteLine { DisplayName = "W2", Message = delegateOutArgument } } }, Default = new Test.Common.TestObjects.CustomActivities.WriteLine{ DisplayName = "W3", Message = "This should not be printed" }, } } } } } ); TestSwitch <string> switch1 = new TestSwitch <string> { DisplayName = "Switch1", Hints = { 0 } }; switch1.AddCase("PassedInValue", new TestAssign <string> { DisplayName = "Assign1" }); switch1.Default = new TestWriteLine { DisplayName = "W1" }; TestSwitch <string> switch2 = new TestSwitch <string> { DisplayName = "Switch2", Hints = { 0 } }; switch2.AddCase("OutValue", new TestWriteLine { DisplayName = "W2", HintMessage = "OutValue" }); switch2.Default = new TestWriteLine { DisplayName = "W3" }; TestSequence sequenceForTracing = new TestSequence { DisplayName = "Sequence1", Activities = { switch1, switch2, } }; invokeFunc.CustomActivityTraces.Add(sequenceForTracing.GetExpectedTrace().Trace); TestRuntime.RunAndValidateWorkflow(invokeFunc); }
public void BasicSequenceWithMultipleChildren() { // Test case description: // Execute sequence activity that has multiple different children in the Activities list and expect the // execution result be sequential as in the order they were added to the Activities list Stack <Guid> stackOfGuids = new Stack <Guid>(); stackOfGuids.Push(new Guid("11111111-1111-1111-1111-111111111111")); TestSequence sequence = new TestSequence("Sequence1"); TestSequence sequence2 = new TestSequence("InnerSequence1"); TestSequence sequence3 = new TestSequence("InnerSequence2"); TestSequence sequence4 = new TestSequence("InnerSequence3"); TestSequence sequence5 = new TestSequence("InnerSequence4"); Variable <Stack <Guid> > stack = VariableHelper.Create <Stack <Guid> >("keyed_collection"); TestInvokeMethod invokeact = new TestInvokeMethod("method invoke act", typeof(Sequence).GetMethod("CheckValue")); invokeact.TargetObject = new TestArgument <Sequence>(Direction.In, "TargetObject", (context => new Sequence())); invokeact.Arguments.Add(new TestArgument <Stack <Guid> >(Direction.In, "stack", stack)); TestSequence sequence6 = new TestSequence("seq5") { Variables = { stack }, Activities = { new TestWriteLine("hello writeline", "Hello from Mars"), new TestAssign <Stack <Guid> >("assign activity ") { ToVariable = stack, ValueExpression = context => stackOfGuids, }, new TestIf("ifact") { Condition = true, ThenActivity = invokeact } } }; TestSequence sequence7 = new TestSequence("seq6"); TestSequence sequence8 = new TestSequence("seq7"); TestSequence sequence9 = new TestSequence("seq8"); TestWriteLine writeLine2 = new TestWriteLine("Hello Two"); writeLine2.Message = string.Format("Hello world in {0} , {1} , {2}!", sequence.DisplayName, sequence3.DisplayName, sequence7.DisplayName); TestWriteLine writeLine3 = new TestWriteLine("Hello Three"); writeLine3.Message = string.Format("Hello world in {0} , {1} , {2}!", sequence.DisplayName, sequence4.DisplayName, sequence8.DisplayName); TestWriteLine writeLine4 = new TestWriteLine("Hello Four"); writeLine4.Message = string.Format("Hello world in {0} , {1} , {2}!", sequence.DisplayName, sequence5.DisplayName, sequence9.DisplayName); sequence7.Activities.Add(writeLine2); sequence8.Activities.Add(writeLine3); sequence9.Activities.Add(writeLine4); sequence2.Activities.Add(sequence6); sequence3.Activities.Add(sequence7); sequence4.Activities.Add(sequence8); sequence5.Activities.Add(sequence9); sequence.Activities.Add(sequence2); sequence.Activities.Add(sequence3); sequence.Activities.Add(sequence4); sequence.Activities.Add(sequence5); TestRuntime.RunAndValidateWorkflow(sequence); }