C# Commands.TestCommand类代码示例

        /// <summary>
        /// Initializes a new instance of the <see cref="SetUpTearDownCommand"/> class.
        /// </summary>
        /// <param name="innerCommand">The inner command.</param>
        public SetUpTearDownCommand(TestCommand innerCommand)
            : base(innerCommand)
        {
            Guard.ArgumentValid(innerCommand.Test is TestMethod, "SetUpTearDownCommand may only apply to a TestMethod", "innerCommand");
            Guard.OperationValid(Test.TypeInfo != null, "TestMethod must have a non-null TypeInfo");

            _setUpTearDownItems = CommandBuilder.BuildSetUpTearDownList(Test.TypeInfo.Type, typeof(SetUpAttribute), typeof(TearDownAttribute));
        }

 /// <summary>
 /// Construct a WorkItem for a particular test.
 /// </summary>
 /// <param name="test">The test that the WorkItem will run</param>
 /// <param name="context">The context to be used for running this test</param>
 public WorkItem(Test test, TestExecutionContext context)
 {
     _test = test;
     _context = context.Save();
     testResult = test.MakeTestResult();
     _command = test.GetTestCommand();
     _state = WorkItemState.Ready;
 }

        /// <summary>
        /// Runs a TestCommand, sending notifications to a listener.
        /// </summary>
        /// <param name="command">A TestCommand to be executed.</param>
        /// <param name="context">The context in which to execute the command.</param>
        /// <returns>A TestResult.</returns>
        public static TestResult Execute(TestCommand command)
        {
            TestResult testResult;

            TestExecutionContext.Save();
            TestExecutionContext context = TestExecutionContext.CurrentContext;
            //context = new TestExecutionContext(context);

            context.CurrentTest = command.Test;
            context.CurrentResult = command.Test.MakeTestResult();

            context.Listener.TestStarted(command.Test);
            long startTime = DateTime.Now.Ticks;

            try
            {
                TestSuiteCommand suiteCommand = command as TestSuiteCommand;
                if (suiteCommand != null)
                    testResult = ExecuteSuiteCommand(suiteCommand, context);
                //{
                //    suiteCommand.DoOneTimeSetup();
                //    foreach (TestCommand childCommand in suiteCommand.Children)
                //        Execute(childCommand, context);
                //    suiteCommand.DoOneTimeTearDown();
                //}
                else
                    testResult = command.Execute(context);

                testResult.AssertCount = context.AssertCount;

                long stopTime = DateTime.Now.Ticks;
                double time = ((double)(stopTime - startTime)) / (double)TimeSpan.TicksPerSecond;
                testResult.Time = time;

                context.Listener.TestFinished(testResult);
            }
            catch (Exception ex)
            {
#if !NETCF
                if (ex is ThreadAbortException)
                    Thread.ResetAbort();
#endif
                context.CurrentResult.RecordException(ex);
                return context.CurrentResult;
            }
            finally
            {
                TestExecutionContext.Restore();
                //context.ReverseChanges();
                //context = context.prior;
            }

            return testResult;
        }

 public ApplyChangesToContextCommand(TestCommand innerCommand, IEnumerable<IApplyToContext> changes)
     : base(innerCommand)
 {
     _changes = changes;
 }

 /// <summary>
 /// Construct a simple work item for a test.
 /// </summary>
 /// <param name="test">The test to be executed</param>
 public SimpleWorkItem(TestMethod test, FinallyDelegate fd) : base(test, fd)
 {
     _command = test.MakeTestCommand();
 }

 TestCommand ICommandDecorator.Decorate(TestCommand command)
 {
     return new SetUpTearDownCommand(command);
 }

        private TestCommand ApplyDecoratorsToCommand(TestCommand command)
        {
            CommandDecoratorList decorators = new CommandDecoratorList();

            // Add Standard stuff
            decorators.Add(new SetUpTearDownDecorator());

            // Add Decorators supplied by attributes
            foreach (ICommandDecoratorSource source in Method.GetCustomAttributes(typeof(ICommandDecoratorSource), true))
                foreach (ICommandDecorator decorator in source.GetDecorators())
                    decorators.Add(decorator);

            // Add Decorators from the parameter set
            if (parms != null)
                foreach (ICommandDecorator decorator in parms.GetDecorators())
                    decorators.Add(decorator);

            decorators.OrderByStage();

            foreach (ICommandDecorator decorator in decorators)
            {
                command = decorator.Decorate(command);
            }

            return command;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="MaxTimeCommand"/> class.
 /// TODO: Add a comment about where the max time is retrieved.
 /// </summary>
 /// <param name="innerCommand">The inner command.</param>
 public MaxTimeCommand(TestCommand innerCommand)
     : base(innerCommand)
 {
     this.maxTime = Test.Properties.GetSetting(PropertyNames.MaxTime, 0);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="TestActionCommand"/> class.
 /// </summary>
 /// <param name="innerCommand">The inner command.</param>
 public TestActionCommand(TestCommand innerCommand)
     : base(innerCommand)
 {
     Guard.ArgumentValid(innerCommand.Test is TestMethod, "TestActionCommand may only apply to a TestMethod", "innerCommand");
 }

 /// <summary>
 /// Construct a simple work item for a test.
 /// </summary>
 /// <param name="test">The test to be executed</param>
 /// <param name="context">The execution context to be used</param>
 public SimpleWorkItem(TestMethod test, TestExecutionContext context) : base(test, context) 
 {
     _command = test.MakeTestCommand();
 }

 TestCommand ICommandDecorator.Decorate(TestCommand command)
 {
     return new MaxTimeCommand(command);
 }

 TestCommand ICommandDecorator.Decorate(TestCommand command)
 {
     return new RepeatedTestCommand(command);
 }

        /// <summary>
        /// Gets a test command to be used in executing this test
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        public TestCommand GetTestCommand(ITestFilter filter)
        {
            if (testCommand == null)
                testCommand = runState != RunState.Runnable && runState != RunState.Explicit
                    ? new SkipCommand(this)
                    : MakeTestCommand(filter);

            return testCommand;
        }

 /// <summary>
 /// Construct a simple work item for a test command.
 /// </summary>
 /// <param name="command">The command to be executed</param>
 public SimpleWorkItem(TestCommand command) : base(command.Test)
 {
     _command = command;
 }

 /// <summary>
 /// Constructs a TheoryResultCommand 
 /// </summary>
 /// <param name="command">The command to be wrapped by this one</param>
 public TheoryResultCommand(TestCommand command) : base(command) { }