Example #1
0
            public RunTestDataItemAction(PatternTestExecutor executor, ITestCommand testCommand,
                                         PatternTestState testState, TestContext primaryContext, bool reusePrimaryTestStep,
                                         IDataItem bindingItem)
            {
                this.executor             = executor;
                this.testCommand          = testCommand;
                this.testState            = testState;
                this.primaryContext       = primaryContext;
                this.reusePrimaryTestStep = reusePrimaryTestStep;
                this.bindingItem          = bindingItem;

                outcome = TestOutcome.Skipped;
            }
        /// <summary>
        /// Creates an initial test instance state object.
        /// </summary>
        /// <param name="testStep">The test step used to execute the test instance.</param>
        /// <param name="testInstanceActions">The test instance actions.</param>
        /// <param name="testState">The test state.</param>
        /// <param name="bindingItem">The data item.</param>
        /// <param name="body">The body of the test instance.</param>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="testStep"/>,
        /// <paramref name="testInstanceActions"/> or <paramref name="testState"/> or <paramref name="bindingItem"/> is null.</exception>
        /// <exception cref="ArgumentException">Thrown if <paramref name="testState"/> belongs to a
        /// different test from the <paramref name="testStep"/>.</exception>
        internal PatternTestInstanceState(PatternTestStep testStep,
                                          PatternTestInstanceActions testInstanceActions,
                                          PatternTestState testState, IDataItem bindingItem, TestAction body)
        {
            if (testStep == null)
            {
                throw new ArgumentNullException("testStep");
            }
            if (testInstanceActions == null)
            {
                throw new ArgumentNullException("testInstanceActions");
            }
            if (testState == null)
            {
                throw new ArgumentNullException("testState");
            }
            if (testStep.Test != testState.Test)
            {
                throw new ArgumentException("The test state belongs to a different test from the test step.", "testState");
            }
            if (bindingItem == null)
            {
                throw new ArgumentNullException("bindingItem");
            }
            if (body == null)
            {
                throw new ArgumentNullException("body");
            }

            this.testStep            = testStep;
            this.testInstanceActions = testInstanceActions;
            this.testState           = testState;
            this.bindingItem         = bindingItem;
            this.body = body;

            testParameterValues = new Dictionary <PatternTestParameter, object>();
            slotValues          = new Dictionary <ISlotInfo, object>();
            data         = new UserDataCollection();
            nameBase     = testStep.Name;
            nameSuffixes = string.Empty;
        }
            public RunTestDataItemAction(PatternTestExecutor executor, ITestCommand testCommand,
                PatternTestState testState, TestContext primaryContext, bool reusePrimaryTestStep,
                IDataItem bindingItem)
            {
                this.executor = executor;
                this.testCommand = testCommand;
                this.testState = testState;
                this.primaryContext = primaryContext;
                this.reusePrimaryTestStep = reusePrimaryTestStep;
                this.bindingItem = bindingItem;

                outcome = TestOutcome.Skipped;
            }
 public InitializeTestAction(PatternTestState testState)
 {
     this.testState = testState;
 }
 public DisposeTestAction(PatternTestState testState)
 {
     this.testState = testState;
 }
 public DecorateTestInstanceAction(PatternTestState testState, PatternTestInstanceActions decoratedTestInstanceActions)
 {
     this.testState = testState;
     this.decoratedTestInstanceActions = decoratedTestInstanceActions;
 }
 public BeforeTestAction(PatternTestState testState)
 {
     this.testState = testState;
 }
 public AfterTestAction(PatternTestState testState)
 {
     this.testState = testState;
 }
            public void Run()
            {
                var test = (PatternTest)testCommand.Test;

                TestContextCookie? parentContextCookie = null;
                try
                {
                    if (parentContext != null)
                        parentContextCookie = parentContext.Enter();

                    // The first time we call Run, we check whether the ApartmentState of the
                    // Thread is correct.  If it is not, then we start a new thread and reenter
                    // with a flag set to skip initial processing.
                    if (!reentered)
                    {
                        if (executor.progressMonitor.IsCanceled)
                        {
                            result = new TestResult(TestOutcome.Canceled);
                            return;
                        }

                        if (!testCommand.AreDependenciesSatisfied())
                        {
                            ITestContext context = testCommand.StartPrimaryChildStep(parentTestStep);
                            context.LogWriter.Warnings.WriteLine("Skipped due to an unsatisfied test dependency.");
                            result = context.FinishStep(TestOutcome.Skipped, null);
                            return;
                        }

                        executor.progressMonitor.SetStatus(test.Name);

                        if (test.ApartmentState != ApartmentState.Unknown
                            && Thread.CurrentThread.GetApartmentState() != test.ApartmentState)
                        {
                            reentered = true;

                            ThreadTask task = new TestEnvironmentAwareThreadTask("Test Runner " + test.ApartmentState,
                                (Action) Run, executor.environmentManager);
                            task.ApartmentState = test.ApartmentState;
                            task.Run(null);

                            if (!task.Result.HasValue)
                            {
                                throw new ModelException(
                                    String.Format("Failed to perform action in thread with overridden apartment state {0}.",
                                        test.ApartmentState), task.Result.Exception);
                            }

                            return;
                        }
                    }

                    // Actually run the test.
                    // Yes, this is a monstrously long method due to the inlining optimzation to minimize stack depth.
                    using (Sandbox sandbox = parentSandbox.CreateChild())
                    {
                        using (new ProcessIsolation())
                        {
                            using (sandbox.StartTimer(test.TimeoutFunc()))
                            {
                                TestOutcome outcome;
                                PatternTestActions testActions = test.TestActions;

                                if (testActionsDecorator != null)
                                    outcome = testActionsDecorator(sandbox, ref testActions);
                                else
                                    outcome = TestOutcome.Passed;

                                if (outcome.Status == TestStatus.Passed)
                                {
                                    PatternTestStep primaryTestStep = new PatternTestStep(test, parentTestStep);
                                    PatternTestState testState = new PatternTestState(primaryTestStep, testActions,
                                        executor.converter, executor.formatter, testCommand.IsExplicit);

                                    bool invisibleTest = true;

                                    outcome = outcome.CombineWith(sandbox.Run(TestLog.Writer,
                                        new BeforeTestAction(testState).Run, "Before Test"));

                                    if (outcome.Status == TestStatus.Passed)
                                    {
                                        bool reusePrimaryTestStep = !testState.BindingContext.HasBindings;
                                        if (!reusePrimaryTestStep)
                                            primaryTestStep.IsTestCase = false;

                                        invisibleTest = false;
                                        TestContext primaryContext = TestContext.PrepareContext(
                                            testCommand.StartStep(primaryTestStep), sandbox);
                                        testState.SetInContext(primaryContext);

                                        using (primaryContext.Enter())
                                        {
                                            primaryContext.LifecyclePhase = LifecyclePhases.Initialize;

                                            outcome = outcome.CombineWith(primaryContext.Sandbox.Run(TestLog.Writer,
                                                new InitializeTestAction(testState).Run, "Initialize"));
                                        }

                                        if (outcome.Status == TestStatus.Passed)
                                        {
                                            var actions = new List<RunTestDataItemAction>();
                                            try
                                            {
                                                foreach (IDataItem bindingItem in testState.BindingContext.GetItems(!executor.options.SkipDynamicTests))
                                                    actions.Add(new RunTestDataItemAction(executor, testCommand, testState, primaryContext,
                                                        reusePrimaryTestStep, bindingItem));

                                                if (actions.Count == 0)
                                                {
                                                    TestLog.Warnings.WriteLine("Test skipped because it is parameterized but no data was provided.");
                                                    outcome = TestOutcome.Skipped;
                                                }
                                                else
                                                {
                                                    if (actions.Count == 1 || ! test.IsParallelizable)
                                                    {
                                                        foreach (var action in actions)
                                                            action.Run();
                                                    }
                                                    else
                                                    {
                                                        executor.scheduler.Run(GenericCollectionUtils.ConvertAllToArray<RunTestDataItemAction, Action>(
                                                            actions, action => action.Run));
                                                    }

                                                    TestOutcome combinedOutcome = TestOutcome.Passed;
                                                    foreach (var action in actions)
                                                        combinedOutcome = combinedOutcome.CombineWith(action.Outcome);

                                                    outcome = outcome.CombineWith(reusePrimaryTestStep ? combinedOutcome : combinedOutcome.Generalize());
                                                }
                                            }
                                            catch (TestException ex)
                                            {
                                                if (ex.Outcome.Status == TestStatus.Failed)
                                                {
                                                    TestLog.Failures.WriteException(ex, String.Format("An exception occurred while getting data items for test '{0}'.", testState.Test.FullName));
                                                }
                                                else
                                                {
                                                    TestLog.Warnings.WriteException(ex);
                                                }

                                                outcome = ex.Outcome;
                                            }
                                            catch (Exception ex)
                                            {
                                                TestLog.Failures.WriteException(ex, String.Format("An exception occurred while getting data items for test '{0}'.", testState.Test.FullName));
                                                outcome = TestOutcome.Error;
                                            }
                                        }

                                        primaryContext.SetInterimOutcome(outcome);

                                        using (primaryContext.Enter())
                                        {
                                            primaryContext.LifecyclePhase = LifecyclePhases.Dispose;

                                            outcome = outcome.CombineWith(primaryContext.Sandbox.Run(TestLog.Writer,
                                                new DisposeTestAction(testState).Run, "Dispose"));
                                        }

                                        result = primaryContext.FinishStep(outcome);
                                    }

                                    outcome = outcome.CombineWith(sandbox.Run(TestLog.Writer,
                                        new AfterTestAction(testState).Run, "After Test"));

                                    if (invisibleTest)
                                        result = PublishOutcomeFromInvisibleTest(testCommand, primaryTestStep, outcome);
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    result = ReportTestError(testCommand, parentTestStep, ex, String.Format("An exception occurred while preparing to run test '{0}'.", test.FullName));
                }
                finally
                {
                    if (parentContextCookie.HasValue)
                        parentContextCookie.Value.ExitContext();

                    executor.progressMonitor.SetStatus("");
                    executor.progressMonitor.Worked(1);
                }
            }
        /// <summary>
        /// Creates an initial test instance state object.
        /// </summary>
        /// <param name="testStep">The test step used to execute the test instance.</param>
        /// <param name="testInstanceActions">The test instance actions.</param>
        /// <param name="testState">The test state.</param>
        /// <param name="bindingItem">The data item.</param>
        /// <param name="body">The body of the test instance.</param>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="testStep"/>,
        /// <paramref name="testInstanceActions"/> or <paramref name="testState"/> or <paramref name="bindingItem"/> is null.</exception>
        /// <exception cref="ArgumentException">Thrown if <paramref name="testState"/> belongs to a
        /// different test from the <paramref name="testStep"/>.</exception>
        internal PatternTestInstanceState(PatternTestStep testStep, 
            PatternTestInstanceActions testInstanceActions,
            PatternTestState testState, IDataItem bindingItem, TestAction body)
        {
            if (testStep == null)
                throw new ArgumentNullException("testStep");
            if (testInstanceActions == null)
                throw new ArgumentNullException("testInstanceActions");
            if (testState == null)
                throw new ArgumentNullException("testState");
            if (testStep.Test != testState.Test)
                throw new ArgumentException("The test state belongs to a different test from the test step.", "testState");
            if (bindingItem == null)
                throw new ArgumentNullException("bindingItem");
            if (body == null)
                throw new ArgumentNullException("body");

            this.testStep = testStep;
            this.testInstanceActions = testInstanceActions;
            this.testState = testState;
            this.bindingItem = bindingItem;
            this.body = body;

            testParameterValues = new Dictionary<PatternTestParameter, object>();
            slotValues = new Dictionary<ISlotInfo, object>();
            data = new UserDataCollection();
            nameBase = testStep.Name;
            nameSuffixes = string.Empty;
        }
Example #11
0
 public DecorateTestInstanceAction(PatternTestState testState, PatternTestInstanceActions decoratedTestInstanceActions)
 {
     this.testState = testState;
     this.decoratedTestInstanceActions = decoratedTestInstanceActions;
 }
Example #12
0
 public AfterTestAction(PatternTestState testState)
 {
     this.testState = testState;
 }
Example #13
0
 public DisposeTestAction(PatternTestState testState)
 {
     this.testState = testState;
 }
Example #14
0
 public InitializeTestAction(PatternTestState testState)
 {
     this.testState = testState;
 }
Example #15
0
 public BeforeTestAction(PatternTestState testState)
 {
     this.testState = testState;
 }
Example #16
0
            public void Run()
            {
                var test = (PatternTest)testCommand.Test;

                TestContextCookie?parentContextCookie = null;

                try
                {
                    if (parentContext != null)
                    {
                        parentContextCookie = parentContext.Enter();
                    }

                    // The first time we call Run, we check whether the ApartmentState of the
                    // Thread is correct.  If it is not, then we start a new thread and reenter
                    // with a flag set to skip initial processing.
                    if (!reentered)
                    {
                        if (executor.progressMonitor.IsCanceled)
                        {
                            result = new TestResult(TestOutcome.Canceled);
                            return;
                        }

                        if (!testCommand.AreDependenciesSatisfied())
                        {
                            ITestContext context = testCommand.StartPrimaryChildStep(parentTestStep);
                            context.LogWriter.Warnings.WriteLine("Skipped due to an unsatisfied test dependency.");
                            result = context.FinishStep(TestOutcome.Skipped, null);
                            return;
                        }

                        executor.progressMonitor.SetStatus(test.Name);

                        if (test.ApartmentState != ApartmentState.Unknown &&
                            Thread.CurrentThread.GetApartmentState() != test.ApartmentState)
                        {
                            reentered = true;

                            ThreadTask task = new TestEnvironmentAwareThreadTask("Test Runner " + test.ApartmentState,
                                                                                 (GallioAction)Run, executor.environmentManager);
                            task.ApartmentState = test.ApartmentState;
                            task.Run(null);

                            if (!task.Result.HasValue)
                            {
                                throw new ModelException(
                                          String.Format("Failed to perform action in thread with overridden apartment state {0}.",
                                                        test.ApartmentState), task.Result.Exception);
                            }

                            return;
                        }
                    }

                    // Actually run the test.
                    // Yes, this is a monstrously long method due to the inlining optimzation to minimize stack depth.
                    using (Sandbox sandbox = parentSandbox.CreateChild())
                    {
                        using (new ProcessIsolation())
                        {
                            using (sandbox.StartTimer(test.TimeoutFunc()))
                            {
                                TestOutcome        outcome;
                                PatternTestActions testActions = test.TestActions;

                                if (testActionsDecorator != null)
                                {
                                    outcome = testActionsDecorator(sandbox, ref testActions);
                                }
                                else
                                {
                                    outcome = TestOutcome.Passed;
                                }

                                if (outcome.Status == TestStatus.Passed)
                                {
                                    PatternTestStep  primaryTestStep = new PatternTestStep(test, parentTestStep);
                                    PatternTestState testState       = new PatternTestState(primaryTestStep, testActions,
                                                                                            executor.converter, executor.formatter, testCommand.IsExplicit);

                                    bool invisibleTest = true;

                                    outcome = outcome.CombineWith(sandbox.Run(TestLog.Writer,
                                                                              new BeforeTestAction(testState).Run, "Before Test"));

                                    if (outcome.Status == TestStatus.Passed)
                                    {
                                        bool reusePrimaryTestStep = !testState.BindingContext.HasBindings;
                                        if (!reusePrimaryTestStep)
                                        {
                                            primaryTestStep.IsTestCase = false;
                                        }

                                        invisibleTest = false;
                                        TestContext primaryContext = TestContext.PrepareContext(
                                            testCommand.StartStep(primaryTestStep), sandbox);
                                        testState.SetInContext(primaryContext);

                                        using (primaryContext.Enter())
                                        {
                                            primaryContext.LifecyclePhase = LifecyclePhases.Initialize;

                                            outcome = outcome.CombineWith(primaryContext.Sandbox.Run(TestLog.Writer,
                                                                                                     new InitializeTestAction(testState).Run, "Initialize"));
                                        }

                                        if (outcome.Status == TestStatus.Passed)
                                        {
                                            var actions = new List <RunTestDataItemAction>();
                                            try
                                            {
                                                foreach (IDataItem bindingItem in testState.BindingContext.GetItems(!executor.options.SkipDynamicTests))
                                                {
                                                    actions.Add(new RunTestDataItemAction(executor, testCommand, testState, primaryContext,
                                                                                          reusePrimaryTestStep, bindingItem));
                                                }

                                                if (actions.Count == 0)
                                                {
                                                    TestLog.Warnings.WriteLine("Test skipped because it is parameterized but no data was provided.");
                                                    outcome = TestOutcome.Skipped;
                                                }
                                                else
                                                {
                                                    if (actions.Count == 1 || !test.IsParallelizable)
                                                    {
                                                        foreach (var action in actions)
                                                        {
                                                            action.Run();
                                                        }
                                                    }
                                                    else
                                                    {
                                                        executor.scheduler.Run(GenericCollectionUtils.ConvertAllToArray <RunTestDataItemAction, GallioAction>(
                                                                                   actions, action => action.Run));
                                                    }

                                                    TestOutcome combinedOutcome = TestOutcome.Passed;
                                                    foreach (var action in actions)
                                                    {
                                                        combinedOutcome = combinedOutcome.CombineWith(action.Outcome);
                                                    }

                                                    outcome = outcome.CombineWith(reusePrimaryTestStep ? combinedOutcome : combinedOutcome.Generalize());
                                                }
                                            }
                                            catch (TestException ex)
                                            {
                                                if (ex.Outcome.Status == TestStatus.Failed)
                                                {
                                                    TestLog.Failures.WriteException(ex, String.Format("An exception occurred while getting data items for test '{0}'.", testState.Test.FullName));
                                                }
                                                else
                                                {
                                                    TestLog.Warnings.WriteException(ex);
                                                }

                                                outcome = ex.Outcome;
                                            }
                                            catch (Exception ex)
                                            {
                                                TestLog.Failures.WriteException(ex, String.Format("An exception occurred while getting data items for test '{0}'.", testState.Test.FullName));
                                                outcome = TestOutcome.Error;
                                            }
                                        }

                                        primaryContext.SetInterimOutcome(outcome);

                                        using (primaryContext.Enter())
                                        {
                                            primaryContext.LifecyclePhase = LifecyclePhases.Dispose;

                                            outcome = outcome.CombineWith(primaryContext.Sandbox.Run(TestLog.Writer,
                                                                                                     new DisposeTestAction(testState).Run, "Dispose"));
                                        }

                                        result = primaryContext.FinishStep(outcome);
                                    }

                                    outcome = outcome.CombineWith(sandbox.Run(TestLog.Writer,
                                                                              new AfterTestAction(testState).Run, "After Test"));

                                    if (invisibleTest)
                                    {
                                        result = PublishOutcomeFromInvisibleTest(testCommand, primaryTestStep, outcome);
                                    }
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    result = ReportTestError(testCommand, parentTestStep, ex, String.Format("An exception occurred while preparing to run test '{0}'.", test.FullName));
                }
                finally
                {
                    if (parentContextCookie.HasValue)
                    {
                        parentContextCookie.Value.ExitContext();
                    }

                    executor.progressMonitor.SetStatus("");
                    executor.progressMonitor.Worked(1);
                }
            }