public void AddTextWriterExtensionToRuntimeAndUseWriteLineWithTextWriter()
        {
            string stringToWrite = "Writing text to  a file with StreamWriter object";

            using (StreamWriter streamWriter1 = new StreamWriter(new MemoryStream()))
            {
                using (StreamWriter streamWriter2 = new StreamWriter(new FileStream(_tempFilePath, FileMode.Create, FileAccess.Write)))
                {
                    TestProductWriteline writeline = new TestProductWriteline("Write with StreamWriter")
                    {
                        Text = stringToWrite,
                        TextWriterExpression = context => streamWriter2,
                    };

                    using (TestWorkflowRuntime runtime = TestRuntime.CreateTestWorkflowRuntime(writeline))
                    {
                        runtime.CreateWorkflow();
                        runtime.Extensions.Add(streamWriter1);
                        runtime.ResumeWorkflow();
                        runtime.WaitForCompletion();
                    }
                }
            }

            VerifyTextOfWriteLine(_tempFilePath, stringToWrite);
        }
Beispiel #2
0
        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!");
        }
        public void CheckWorkflowProperties()
        {
            TestActivity workflow = new TestWriteLine("Write1", "Write a line");

            TestWorkflowRuntime runtime = TestRuntime.CreateTestWorkflowRuntime(workflow);

            runtime.CreateWorkflow();
            runtime.Extensions.Add(new CheckWorkflowPropertiesExtension(runtime.CurrentWorkflowInstanceId, workflow.ProductActivity));

            runtime.ResumeWorkflow();
            ExpectedTrace expectedTrace = workflow.GetExpectedTrace();

            expectedTrace.AddIgnoreTypes(typeof(UserTrace));
            runtime.WaitForCompletion(expectedTrace);
        }
        public void ThrowFromInterfaceMethods()
        {
            TestActivity workflow = new TestWriteLine("Write1", "Write a line");

            TestWorkflowRuntime runtime = TestRuntime.CreateTestWorkflowRuntime(workflow);

            runtime.PersistenceProviderFactoryType = null;
            runtime.CreateWorkflow();

            ThrowFromAdditionalExtensions throwFromAdditionalExtensions = new ThrowFromAdditionalExtensions();

            CheckExceptionPropagated(throwFromAdditionalExtensions, "Throw from AdditionalExtensionsAdded", runtime);

            ThrowFromSetInstance throwFromSetInstance = new ThrowFromSetInstance();

            CheckExceptionPropagated(throwFromSetInstance, "Throw from SetInstance", runtime);

            runtime.ResumeWorkflow();
            ExpectedTrace expectedTrace = workflow.GetExpectedTrace();

            expectedTrace.AddIgnoreTypes(typeof(UserTrace));
            runtime.WaitForCompletion(expectedTrace);
        }
        public void VerifyAdditionalExtensionsAdded()
        {
            TestActivity        workflow = new TestReadLine <int>("Read1", "Read1");
            TestWorkflowRuntime runtime  = TestRuntime.CreateTestWorkflowRuntime(workflow);

            runtime.OnWorkflowUnloaded += WorkflowInstanceHelper.wfRuntime_OnUnload;
            runtime.CreateWorkflow();
            runtime.Extensions.Add(new AdditionalExtensionsAdded(new Collection <object>()
            {
                new OperationOrderTracePersistExtension(runtime.CurrentWorkflowInstanceId)
            }));

            runtime.ResumeWorkflow();
            runtime.WaitForIdle();
            runtime.ResumeBookMark("Read1", 1);

            ExpectedTrace expectedTrace = workflow.GetExpectedTrace();

            expectedTrace.AddIgnoreTypes(typeof(UserTrace));
            runtime.WaitForCompletion(expectedTrace);
            runtime.WaitForTrace(new UserTrace(WorkflowInstanceHelper.UnloadMessage));
            runtime.WaitForTrace(new UserTrace(OperationOrderTracePersistExtension.TraceSave));
        }
        public void SetTextWriterToNullAndUseATextWriterExtension()
        {
            string stringToWrite = "Writing text to  a file with StreamWriter object";

            using (StreamWriter streamWriter = new StreamWriter(new FileStream(_tempFilePath, FileMode.Create, FileAccess.Write)))
            {
                TestProductWriteline writeline = new TestProductWriteline("Write with StreamWriter")
                {
                    Text = stringToWrite,
                };
                writeline.ProductWriteLine.TextWriter = null;

                using (TestWorkflowRuntime runtime = TestRuntime.CreateTestWorkflowRuntime(writeline))
                {
                    runtime.CreateWorkflow();
                    runtime.Extensions.Add(streamWriter);
                    runtime.ResumeWorkflow();
                    runtime.WaitForCompletion();
                }
            }

            VerifyTextOfWriteLine(_tempFilePath, stringToWrite);
        }