public void ParallelForEachInTryCatchFinally() { TestTryCatch tcf = new TestTryCatch("TCF") { Try = new TestParallelForEach <string>("Parallel for each") { Body = new TestThrow <InvalidCastException> { ExpectedOutcome = Outcome.CaughtException(typeof(InvalidCastException)) }, HintValues = new List <string>() { "str1", "STR2", "str3" }, ValuesExpression = (context => new List <string>() { "str1", "STR2", "str3" }), CompletionCondition = true, HintIterationCount = 1, }, Catches = { new TestCatch <InvalidCastException>() { HintHandleException = true } } }; ExpectedTrace tr = tcf.GetExpectedTrace(); TestRuntime.RunAndValidateWorkflow(tcf, tr); }
public void TryCatchWithWorkflowInvoker() { TestTryCatch tcf = new TestTryCatch { // try Try = new TestThrow <ArgumentException>() { ExpectedOutcome = Outcome.CaughtException() } }; // catch TestCatch <ArgumentException> tc = new TestCatch <ArgumentException> { Body = new TestWriteLine("Hello world!", "Hello world!") }; tcf.Catches.Add(tc); // finally tcf.Finally = new TestWriteLine("Finally", "Finally"); // Run test TestRuntime.RunAndValidateUsingWorkflowInvoker(tcf, null, null, null); }
public void ThrowCatchRethrow() { TestTryCatch ttc = new TestTryCatch("parent TryCatch") { Try = new TestSequence { Activities = { new TestProductWriteline("W1"), new TestThrow <TAC.ApplicationException> { ExceptionExpression = (context => new TAC.ApplicationException("this is expected uncaught exception")), ExpectedOutcome = Outcome.CaughtException(typeof(TAC.ApplicationException)), } } }, Catches = { new TestCatch <TAC.ApplicationException> { Body = new TestRethrow { ExpectedOutcome = Outcome.UncaughtException(typeof(TAC.ApplicationException)), } } } }; Dictionary <string, string> exceptionProperties = new Dictionary <string, string>(); TestRuntime.RunAndValidateAbortedException(ttc, typeof(TAC.ApplicationException), exceptionProperties); }
private static int Main() { #if !MULTIMODULE_BUILD TestLdstr.Run(); TestException.Run(); TestThreadStaticNotInitialized.Run(); TestUntouchedThreadStaticInitialized.Run(); TestPointers.Run(); TestConstants.Run(); TestArray.Run(); TestMdArray.Run(); TestSimpleObject.Run(); TestFinalizableObject.Run(); TestStoreIntoOtherStatic.Run(); TestCctorCycle.Run(); TestReferenceTypeAllocation.Run(); TestReferenceTypeWithGCPointerAllocation.Run(); TestRelationalOperators.Run(); TestTryFinally.Run(); TestTryCatch.Run(); TestBadClass.Run(); TestRefs.Run(); TestDelegate.Run(); TestInitFromOtherClass.Run(); TestInitFromOtherClassDouble.Run(); TestDelegateToOtherClass.Run(); #else Console.WriteLine("Preinitialization is disabled in multimodule builds for now. Skipping test."); #endif return(100); }
public void TryCatchFinallyWithCaughtExceptionInFinally() { TestTryCatch outer = new TestTryCatch("Outer TCF") { Try = new TestTryCatch("Inner TCF") { Finally = new TestSequence("Finally") { Activities = { new TestThrow <Exception>() { ExpectedOutcome = Outcome.CaughtException() }, new TestWriteLine("Not called", "Not printed"), } } }, Catches = { new TestCatch <Exception>() { Body = new TestWriteLine("Catch", "Catch"), } } }; // run the workflow TestRuntime.RunAndValidateWorkflow(outer); }
public void TryCatchFinallyWithExceptionInCatchingCatch() { TestTryCatch tryCatch = new TestTryCatch("TryCatchTest") { Try = new TestSequence("TrySeq") { Activities = { new TestThrow <ArgumentException>("TryException") { ExpectedOutcome = Outcome.CaughtException() }, }, }, Catches = { new TestCatch <ArgumentException>() { Body = new TestThrow <ArithmeticException>("Throw from catch") { ExceptionExpression = (context => new ArithmeticException()) } }, }, Finally = new TestWriteLine("Finally", "Finally") }; // Run test TestRuntime.RunAndValidateAbortedException(tryCatch, typeof(ArithmeticException), null); }
public void TryCatchFinallyActivityOnly() { TestTryCatch tcf = new TestTryCatch { // try Try = new TestThrow <ArgumentException>() { ExpectedOutcome = Outcome.CaughtException() } }; // catch TestCatch <ArgumentException> tc = new TestCatch <ArgumentException> { Body = new TestWriteLine("Hello world!", "Hello world!") }; tcf.Catches.Add(tc); // finally tcf.Finally = new TestWriteLine("Finally", "Finally"); // Run test TestRuntime.RunAndValidateWorkflow(tcf); }
public void RethrowInTry() { TestRethrow tr = new TestRethrow(); TestTryCatch root = new TestTryCatch("parent TryCatch") { Try = new TestSequence { Activities = { new TestProductWriteline("W1"), new TestThrow <TAC.ApplicationException> { ExceptionExpression = (context => new TAC.ApplicationException("abcd")), }, tr } }, Catches = { new TestCatch <TAC.ApplicationException> { Body = new TestRethrow() } }, }; TestRuntime.ValidateInstantiationException(root, string.Format(ErrorStrings.RethrowNotInATryCatch, tr.DisplayName)); }
public void RethrowExceptionFromInvokeMethodWithAllExceptionPropertiesSet() { TestInvokeMethod im = new TestInvokeMethod { TargetObject = new TestArgument <CustomClassForRethrow>(Direction.In, "TargetObject", (context => new CustomClassForRethrow())), MethodName = "M1", ExpectedOutcome = Outcome.CaughtException(typeof(TestCaseException)), }; TestTryCatch tc = new TestTryCatch(); TestCatch <TestCaseException> tcCatch = new TestCatch <TestCaseException> { Body = new TestRethrow { ExpectedOutcome = Outcome.UncaughtException(typeof(TestCaseException)) } }; tc.Try = im; tc.Catches.Add(tcCatch); using (TestWorkflowRuntime testWorkflowRuntime = TestRuntime.CreateTestWorkflowRuntime(tc)) { testWorkflowRuntime.ExecuteWorkflow(); Exception outEx; testWorkflowRuntime.WaitForAborted(out outEx); Dictionary <string, string> errorProperty = new Dictionary <string, string>(); errorProperty.Add("Message", "this should be caught"); ExceptionHelpers.ValidateException(outEx, typeof(TestCaseException), errorProperty); } }
/// <summary> /// Exception thrown from 5 level deep nested flowchart and handled at the top level. /// </summary> //[Fact] public void FaultFromFiveLevelDeepNestedFlowchart_Handled() { TestFlowchart parent = new TestFlowchart(); TestFlowchart child1 = new TestFlowchart(); TestFlowchart child2 = new TestFlowchart(); TestFlowchart child3 = new TestFlowchart(); TestFlowchart child4 = new TestFlowchart(); child4.AddStartLink(new TestThrow <WorkflowApplicationAbortedException>() { ExpectedOutcome = Outcome.CaughtException() }); child1.AddStartLink(child2); child2.AddStartLink(child3); child3.AddStartLink(child4); TestTryCatch tryCatchFinally = new TestTryCatch(); tryCatchFinally.Try = child1; tryCatchFinally.Catches.Add(new TestCatch <WorkflowApplicationAbortedException>()); parent.AddStartLink(tryCatchFinally); TestRuntime.RunAndValidateWorkflow(parent); }
public void PersistInCatch() { TestBlockingActivity blocking = new TestBlockingActivity("Bookmark"); TestTryCatch tcf = new TestTryCatch { Try = new TestThrow <Exception>() { ExpectedOutcome = Outcome.CaughtException() }, Catches = { { new TestCatch <Exception> { Body = blocking } } } }; JsonFileInstanceStore.FileInstanceStore jsonStore = new JsonFileInstanceStore.FileInstanceStore(".\\~"); using (TestWorkflowRuntime testWorkflowRuntime = TestRuntime.CreateTestWorkflowRuntime(tcf, null, jsonStore, PersistableIdleAction.None)) { testWorkflowRuntime.ExecuteWorkflow(); testWorkflowRuntime.WaitForActivityStatusChange(blocking.DisplayName, TestActivityInstanceState.Executing); testWorkflowRuntime.PersistWorkflow(); testWorkflowRuntime.ResumeBookMark("Bookmark", null); testWorkflowRuntime.WaitForCompletion(); } }
/// <summary> /// Parallel in TryCatch and handled by trycatch. Any executing branch will be cancelled. ( parallel within parallel and all branches are blocking at the same time so that you see the cancel behavior) /// Parallel in TryCatch and handled by trycatch . Any executing branch will be cancelled. ( parallel within parallel and all branches are blocking at the same time so that you see the cancel behavior) /// </summary> /// Disabled and failed in desktop //[Fact] public void ParallelInTryCatch() { TestTryCatch tryCatch = new TestTryCatch("TryCatch") { Try = new TestParallel("TryCatchParallel") { Branches = { new TestWriteLine("WritingFirst", "WritingFirst"), new TestThrow <ArgumentException>("Throwing") { ExpectedOutcome = Outcome.CaughtException() }, new TestWriteLine("AfterThrow", "AfterThrow") { ExpectedOutcome = Outcome.Canceled } } }, Catches = { new TestCatch <ArgumentException>() { Body = new TestWriteLine("Catching ArgumentException", "Catching ArgumentException") } } }; TestRuntime.RunAndValidateWorkflow(tryCatch); }
/// <summary> /// Setup a t/c/f statement. /// </summary> /// <param name="tryBody">Try activity.</param> /// <param name="tc">Array of Catches.</param> /// <param name="finallyBody">Finally activity.</param> /// <param name="type">Type of workflow to create.</param> /// <param name="otherActivities">Flag indicating whether extra activities should be added.</param> public static TestActivity CreateTryCatchFinally(TestActivity tryBody, TestCatch[] tc, TestActivity finallyBody, WFType type, bool otherActivities) { // create the try/catch/finally TestTryCatch tcf = new TestTryCatch("TestTcf"); if (tryBody != null) { tcf.Try = tryBody; } if (tc != null) { foreach (TestCatch testCatch in tc) { tcf.Catches.Add(testCatch); } } if (finallyBody != null) { tcf.Finally = finallyBody; } // extra activities to add around activity if otherActivities is true TestWriteLine before = new TestWriteLine("BeforeTry", "BeforeTry"); TestWriteLine after = new TestWriteLine("AfterTry", "AfterTry"); // sequence if (type == WFType.SEQ) { TestSequence seq = new TestSequence("SequenceOfActivitiesContainingTCF"); if (otherActivities) { seq.Activities.Add(before); } seq.Activities.Add(tcf); if (otherActivities) { seq.Activities.Add(after); } return(seq); } // otherwise do flowchart else // type == wfType.FLOW { TestFlowchart flowchart = new TestFlowchart("FlowchartContainingTCF"); if (otherActivities) { flowchart.AddStartLink(before); flowchart.AddLink(before, tcf); flowchart.AddLink(tcf, after); } else { flowchart.AddStartLink(tcf); } return(flowchart); } }
public void TryTerminatingActivityAfterThrowInTryCatch() { s_exceptionType = typeof(InvalidCastException); s_terminationReason = "I like home!"; TestTryCatch tryCatch = new TestTryCatch("TryCatch") { Try = new TestSequence("TryingSeq") { Activities = { new TestWriteLine() { Message = "I'm Trying here", HintMessage = "I'm Trying here" }, new TestThrow <ArgumentException>("TryException") { ExpectedOutcome = Outcome.CaughtException(), }, new TestTerminateWorkflow() { ExceptionExpression = context => new InvalidCastException("I want to go home now!"), Reason = s_terminationReason } } }, Catches = { new TestCatch <ArgumentException>() { Body = new TestWriteLine("CaughtException") { Message = "aha I caught you!", HintMessage = "aha I caught you!" } } }, Finally = new TestWriteLine("Finally") { Message = "Ha! Now you have to stay", HintMessage = "Ha! Now you have to stay" } }; using (TestWorkflowRuntime testWorkflowRuntime = TestRuntime.CreateTestWorkflowRuntime(tryCatch)) { testWorkflowRuntime.OnWorkflowCompleted += new EventHandler <TestWorkflowCompletedEventArgs>(workflowCompletedNoExceptions); testWorkflowRuntime.ExecuteWorkflow(); testWorkflowRuntime.WaitForCompletion(); } }
public void PersistAfterCatchBeforeRethrow() { TestTryCatch root = new TestTryCatch("parent TryCatch") { Try = new TestSequence { Activities = { new TestProductWriteline("W1"), new TestThrow <TAC.ApplicationException> { ExceptionExpression = (context => new TAC.ApplicationException("abcd")), ExpectedOutcome = Outcome.CaughtException(typeof(TAC.ApplicationException)), } } }, Catches = { new TestCatch <TAC.ApplicationException> { Body = new TestSequence { Activities = { new TestBlockingActivity("Blocking1", "B1"), new TestRethrow { ExpectedOutcome = Outcome.UncaughtException(typeof(TAC.ApplicationException)), } } } } } }; JsonFileInstanceStore.FileInstanceStore jsonStore = new JsonFileInstanceStore.FileInstanceStore(".\\~"); using (TestWorkflowRuntime testWorkflowRuntime = TestRuntime.CreateTestWorkflowRuntime(root, null, jsonStore, CoreWf.PersistableIdleAction.None)) { testWorkflowRuntime.ExecuteWorkflow(); testWorkflowRuntime.WaitForActivityStatusChange("Blocking1", TestActivityInstanceState.Executing); testWorkflowRuntime.PersistWorkflow(); testWorkflowRuntime.ResumeBookMark("Blocking1", null); Exception resultedException; testWorkflowRuntime.WaitForAborted(out resultedException); if (!(resultedException is TAC.ApplicationException)) { throw resultedException; } } }
public void ThrowInNestedTryCatchRethrowInTheTopTryCatch() { TestTryCatch root = new TestTryCatch("parentTryCatch"); root.Catches.Add( new TestCatch <TAC.ApplicationException> { Body = new TestRethrow { ExpectedOutcome = Outcome.UncaughtException(typeof(TAC.ApplicationException)), } }); TestTryCatch level1 = new TestTryCatch("level1"); level1.Catches.Add(new TestCatch <ArithmeticException> { Body = new TestProductWriteline("don't write this 1") }); root.Try = level1; TestTryCatch level2 = new TestTryCatch("level2"); level2.Catches.Add(new TestCatch <ArithmeticException> { Body = new TestProductWriteline("don't write this 2") }); level1.Try = level2; TestTryCatch level3 = new TestTryCatch("level3"); level3.Catches.Add(new TestCatch <ArithmeticException> { Body = new TestProductWriteline("don't write this 3") }); level2.Try = level3; level3.Try = new TestSequence { Activities = { new TestProductWriteline("W1"), new TestThrow <TAC.ApplicationException> { ExceptionExpression = (context => new TAC.ApplicationException("this is expected uncaught exception")), ExpectedOutcome = Outcome.CaughtException(typeof(TAC.ApplicationException)), } } }; Dictionary <string, string> exceptionProperties = new Dictionary <string, string>(); TestRuntime.RunAndValidateAbortedException(root, typeof(TAC.ApplicationException), exceptionProperties); }
public void TerminateActivityInCatch() { s_exceptionType = typeof(InvalidCastException); s_exceptionMsg = "I want to go home now!"; s_terminationReason = "I like home!"; TestTryCatch tryCatch = new TestTryCatch("TryCatch") { Try = new TestSequence("TryingSeq") { Activities = { new TestWriteLine() { Message = "I'm Trying here", HintMessage = "I'm Trying here" }, new TestThrow <ArgumentException>("TryException") { ExpectedOutcome = Outcome.CaughtException(), }, } }, Catches = { new TestCatch <ArgumentException>() { Body = new TestSequence("CatchingSeq") { Activities = { new TestTerminateWorkflow() { ExceptionExpression = ((env) => new InvalidCastException("I want to go home now!")), Reason = s_terminationReason }, new TestWriteLine("CaughtException") { Message = "Should not execute", HintMessage = "A Bug if executed", ExpectedOutcome = Outcome.None } } } } }, }; RunTestWithWorkflowRuntime(tryCatch); }
public void CatchWithEmptyHandler() { TestTryCatch tcf = new TestTryCatch(); // try tcf.Try = new TestThrow <IOException>() { ExpectedOutcome = Outcome.CaughtException() }; // catch TestCatch <IOException> tc = new TestCatch <IOException>(); // do not add to tc.Body, want empty Action.Handler tcf.Catches.Add(tc); // Run test TestRuntime.RunAndValidateWorkflow(tcf); }
public void RethrowAndCatch() { TestTryCatch root = new TestTryCatch("parent TryCatch") { Try = new TestTryCatch("parent TryCatch") { Try = new TestSequence { Activities = { new TestProductWriteline("W1"), new TestThrow <TAC.ApplicationException> { ExceptionExpression = (context => new TAC.ApplicationException("this is expected uncaught exception")), ExpectedOutcome = Outcome.CaughtException(typeof(TAC.ApplicationException)), } } }, Catches = { new TestCatch <TAC.ApplicationException> { Body = new TestRethrow { ExpectedOutcome = Outcome.CaughtException(typeof(TAC.ApplicationException)), } } } }, Catches = { new TestCatch <TAC.ApplicationException> { Body = new TestWriteLine { Message = "You catched the exception :)" } } } }; TestRuntime.RunAndValidateWorkflow(root); }
public void PersistInTry() { TestBlockingActivity blocking = new TestBlockingActivity("Bookmark"); TestTryCatch tryCatch = new TestTryCatch("TryCatchTest") { Try = new TestSequence("TrySeq") { Activities = { blocking, new TestThrow <ArgumentException>("TryException") { ExpectedOutcome = Outcome.CaughtException() }, }, }, Catches = { new TestCatch <ArgumentException>() { Body = new TestWriteLine("Caught", "Caught") } }, Finally = new TestWriteLine("Finally", "Finally") }; JsonFileInstanceStore.FileInstanceStore jsonStore = new JsonFileInstanceStore.FileInstanceStore(".\\~"); using (TestWorkflowRuntime testWorkflowRuntime = TestRuntime.CreateTestWorkflowRuntime(tryCatch, null, jsonStore, PersistableIdleAction.None)) { testWorkflowRuntime.ExecuteWorkflow(); testWorkflowRuntime.WaitForActivityStatusChange(blocking.DisplayName, TestActivityInstanceState.Executing); testWorkflowRuntime.PersistWorkflow(); testWorkflowRuntime.ResumeBookMark("Bookmark", null); testWorkflowRuntime.WaitForCompletion(); } }
public void CancelInTryBlock() { TestBlockingActivity blocking = new TestBlockingActivity("Bookmark") { ExpectedOutcome = Outcome.Canceled }; TestTryCatch tryCatch = new TestTryCatch("TryCatchTest") { Try = new TestSequence("TrySeq") { Activities = { blocking, new TestThrow <ArgumentException>("TryException") { ExpectedOutcome = Outcome.None }, }, }, Catches = { new TestCatch <ArgumentException>() { Body = new TestWriteLine("Caught", "Caught"), ExpectedOutcome = Outcome.None } } }; using (TestWorkflowRuntime testWorkflowRuntime = TestRuntime.CreateTestWorkflowRuntime(tryCatch)) { testWorkflowRuntime.ExecuteWorkflow(); testWorkflowRuntime.WaitForActivityStatusChange(blocking.DisplayName, TestActivityInstanceState.Executing); testWorkflowRuntime.CancelWorkflow(); testWorkflowRuntime.WaitForCanceled(); } }
public void ThrowExceptionInOneCatchAndCatchItInOtherCatch() { TestTryCatch tryCatch = new TestTryCatch("TryCatchTestParent") { Try = new TestTryCatch("TryCatchTestChild") { Try = new TestSequence("TrySeq") { Activities = { new TestThrow <ArgumentException>("TryException") { ExpectedOutcome = Outcome.CaughtException() }, }, }, Catches = { new TestCatch <ArgumentException>() { Body = new TestThrow <ArithmeticException>("Throw from catch") { ExceptionExpression = (context => new ArithmeticException()), ExpectedOutcome = Outcome.CaughtException() } }, }, Finally = new TestWriteLine("Finally", "Finally") }, Catches = { new TestCatch <ArithmeticException>() { Body = new TestWriteLine("CaughtIt", "I caught you") }, } }; // Run test TestRuntime.RunAndValidateWorkflow(tryCatch); }
private static int Main() { #if !MULTIMODULE_BUILD TestLdstr.Run(); TestException.Run(); TestThreadStaticNotInitialized.Run(); TestUntouchedThreadStaticInitialized.Run(); TestPointers.Run(); TestConstants.Run(); TestArray.Run(); TestArrayOutOfRange.Run(); TestMdArray.Run(); TestSimpleObject.Run(); TestFinalizableObject.Run(); TestStoreIntoOtherStatic.Run(); TestCctorCycle.Run(); TestReferenceTypeAllocation.Run(); TestReferenceTypeWithGCPointerAllocation.Run(); TestReferenceTypeWithReadonlyNullGCPointerAllocation.Run(); TestRelationalOperators.Run(); TestTryFinally.Run(); TestTryCatch.Run(); TestBadClass.Run(); TestRefs.Run(); TestDelegate.Run(); TestInitFromOtherClass.Run(); TestInitFromOtherClassDouble.Run(); TestDelegateToOtherClass.Run(); TestLotsOfBackwardsBranches.Run(); TestDrawCircle.Run(); TestValueTypeDup.Run(); TestFunctionPointers.Run(); TestGCInteraction.Run(); TestDuplicatedFields.Run(); TestInstanceDelegate.Run(); #else Console.WriteLine("Preinitialization is disabled in multimodule builds for now. Skipping test."); #endif return(100); }
public void RethrowFromCatchHandlerOfPrivateActivity() { string message = "this is expected uncaught exception"; TestCustomActivity <TestRethrowInPrivateChildren> rethrowAct = new TestCustomActivity <TestRethrowInPrivateChildren>() { ExpectedOutcome = Outcome.UncaughtException(), }; rethrowAct.CustomActivityTraces.Add(new ActivityTrace("Rethrow", CoreWf.ActivityInstanceState.Executing)); rethrowAct.CustomActivityTraces.Add(new ActivityTrace("Rethrow", CoreWf.ActivityInstanceState.Faulted)); TestTryCatch ttc = new TestTryCatch("parent TryCatch") { Try = new TestSequence { Activities = { new TestProductWriteline("W1"), new TestThrow <TestCaseException> { ExceptionExpression = (context => new TestCaseException(message)), ExpectedOutcome = Outcome.CaughtException(typeof(TestCaseException)), } } }, Catches = { new TestCatch <TestCaseException> { Body = rethrowAct } } }; //The validation error has a prefix: string validationError = string.Format(ErrorStrings.ValidationErrorPrefixForHiddenActivity, "2: " + rethrowAct.DisplayName) + string.Format(ErrorStrings.RethrowMustBeAPublicChild, "Rethrow"); TestRuntime.ValidateInstantiationException(ttc, validationError); }
public void TerminateActivityInTry() { s_exceptionType = typeof(InvalidCastException); s_exceptionMsg = "I want to go home now!"; s_terminationReason = "I like home!"; TestTryCatch tryCatch = new TestTryCatch("TryCatch") { Try = new TestSequence("TryingSeq") { Activities = { new TestWriteLine() { Message = "I'm Trying here", HintMessage = "I'm Trying here" }, new TestTerminateWorkflow() { ExceptionExpression = ((env) => new InvalidCastException("I want to go home now!")), Reason = s_terminationReason } } }, Catches = { new TestCatch <ArgumentException>() { Body = new TestWriteLine("CaughtException") { Message = "aha I caught you!", HintMessage = "aha I caught you!" } } }, }; RunTestWithWorkflowRuntime(tryCatch); }
public void RethrowInFinally() { TestRethrow tr = new TestRethrow(); TestTryCatch root = new TestTryCatch("parent TryCatch") { Try = new TestSequence { Activities = { new TestProductWriteline("W1"), new TestThrow <TAC.ApplicationException> { ExceptionExpression = (context => new TAC.ApplicationException("abcd")), ExpectedOutcome = Outcome.CaughtException(typeof(TAC.ApplicationException)), } } }, Catches = { new TestCatch <TAC.ApplicationException>() }, Finally = new TestSequence { Activities = { new TestSequence { Activities = { tr } } } } }; TestRuntime.ValidateInstantiationException(root, string.Format(ErrorStrings.RethrowNotInATryCatch, tr.DisplayName)); }
/// <summary> /// Fault handled from flowchart in a try catch block. /// </summary> /// Disabled in desktop and failing. //[Fact] public 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 RethrowCustomExceptionWithNonSerializableProperty() { //TestParameters.DisableXamlRoundTrip = true; string message = "this is expected uncaught exception"; TestTryCatch ttc = new TestTryCatch("parent TryCatch") { Try = new TestSequence { Activities = { new TestProductWriteline("W1"), new TestThrow <CustomExceptionWithNonSerializableProperty> { ExceptionExpression = context => new CustomExceptionWithNonSerializableProperty(message) { NonSerializableP = new NonSerializableType("A") }, ExpectedOutcome = Outcome.CaughtException(typeof(CustomExceptionWithNonSerializableProperty)), } } }, Catches = { new TestCatch <CustomExceptionWithNonSerializableProperty> { Body = new TestRethrow { ExpectedOutcome = Outcome.UncaughtException(typeof(CustomExceptionWithNonSerializableProperty)), } } } }; Dictionary <string, string> exceptionProperties = new Dictionary <string, string>(); TestRuntime.RunAndValidateAbortedException(ttc, typeof(CustomExceptionWithNonSerializableProperty), exceptionProperties); }
public void CustomParentChildInheritedExceptionCatchAndRethrow() { TestTryCatch ttc = new TestTryCatch("parent TryCatch") { Try = new TestSequence { Activities = { new TestProductWriteline("W1"), new TestThrow <CustomException> { ExceptionExpression = context => new CustomException("this is expected uncaught exception"), ExpectedOutcome = Outcome.CaughtException(typeof(CustomException)), } } }, Catches = { new TestCatch <CustomException> { Body = new TestSequence("seq1 in Catch-TAC.ApplicationException-") { Activities = { new TestWriteLine { Message = "This should be printed", HintMessage = "This should be printed", }, new TestRethrow { DisplayName = "LastRethrow", ExpectedOutcome = Outcome.UncaughtException(typeof(CustomException)), } } } }, new TestCatch <Exception> { Body = new TestSequence("seq1 in Catch-Exception-") { ExpectedOutcome = Outcome.None, Activities = { new TestWriteLine { Message = "This should not be printed", }, new TestRethrow { DisplayName = "FirstRethrow", } } } }, } }; Dictionary <string, string> exceptionProperties = new Dictionary <string, string>(); TestRuntime.RunAndValidateAbortedException(ttc, typeof(CustomException), exceptionProperties); }
/// <summary> /// Nest trycatchfinallies 5 levels deep and catch uncaught exception in outer try catch /// Nest trycatchfinallies 5 levels deep and catch uncatched exception in outer try catch…etc /// </summary> /// Disabled and failed in desktop //[Fact] public void TryCatchFinallyNested() { TestTryCatch NestedTryCatch = new TestTryCatch("Level1Try") { Try = new TestTryCatch("Level2Try") { Try = new TestTryCatch("Level3Try") { Try = new TestTryCatch("Level4Try") { Try = new TestTryCatch("Level5Try") { Try = new TestThrow <ArithmeticException>("Level5Throw") { ExpectedOutcome = Outcome.CaughtException() }, Catches = { new TestCatch <ArgumentOutOfRangeException>() { Body = new TestWriteLine("Not Catching"), } } }, Catches = { new TestCatch <ArithmeticException>() { Body = new TestThrow <MemberAccessException>("Level4Throw") { ExpectedOutcome = Outcome.CaughtException() } } } }, Catches = { new TestCatch <MemberAccessException>() { Body = new TestThrow <FileNotFoundException>("Level3Throw") { ExpectedOutcome = Outcome.CaughtException() } } } }, Catches = { new TestCatch <FileNotFoundException>() { Body = new TestThrow <ArgumentException>("Level2Throw") { ExpectedOutcome = Outcome.CaughtException() } } } }, Catches = { new TestCatch <ArgumentException>() { Body = new TestWriteLine("No More Catching!", "No More Catching!") } } }; TestRuntime.RunAndValidateWorkflow(NestedTryCatch); }