C# TestResult.Failure方法代码示例

        TestResult RunTest(EventListener listener)
        {
            listener.TestStarted(base.TestName);

            TestResult nunitTestResult = new TestResult(this);

            if (_pendingException != null)
            {
                nunitTestResult.Failure(_pendingException.Message, _pendingException.StackTrace, FailureSite.Test);
            }
            else if (RunState == RunState.NotRunnable)
            {
                nunitTestResult.SetResult(ResultState.NotRunnable, IgnoreReason, "", FailureSite.Test);
            }
            else
            {
                var testResult = SpecificationRunner.RunTest(this._testContext, new List<string>());

                NativeTestResult.ApplyToNunitResult(testResult, nunitTestResult);
            }

            listener.TestFinished(nunitTestResult);

            return nunitTestResult;
        }

        public override TestResult Run(EventListener listener, ITestFilter filter)
        {
            var result = new TestResult(this);

            lock (testClosure) {
                try {
                    testClosure.TestMethod();
                    TestNonExceptionCondition(result);
                } catch (IgnoreException iex) {
                    result.Ignore(iex.Message);
                } catch (InconclusiveException icex) {
                    result.Invalid(icex.Message);
                } catch (Exception ex) {
                    TestExceptionCondition(result, ex);
                }

                try {
                    testClosure.TearDown();
                } catch (Exception ex) {
                    result.Failure("Exception in tear-down: "+ex.Message, ex.StackTrace);
                }
            }

            listener.TestFinished(result);
            return result;
        }

        public override void DoFixtureSetUp(TestResult suiteResult)
        {
            try
            {
                _fixture.FixtureSetup();

                Status = SetUpState.SetUpComplete;
            }
            catch (Exception ex)
            {
                if (ex is NunitException || ex is TargetInvocationException)
                    ex = ex.InnerException;

                if (testFramework.IsIgnoreException(ex))
                {
                    ShouldRun = false;
                    suiteResult.NotRun(ex.Message);
                    suiteResult.StackTrace = ex.StackTrace;
                    IgnoreReason = ex.Message;
                }
                else
                {
                    suiteResult.Failure(ex.Message, ex.StackTrace);
                    Status = SetUpState.SetUpFailed;
                }
            }
            finally
            {
                if (testFramework != null)
                    suiteResult.AssertCount = testFramework.GetAssertCount();
            }
        }

 public override TestResult Run(EventListener listener, ITestFilter filter)
 {
     listener.TestStarted(base.TestName);
     long ticks = DateTime.Now.Ticks;
     TestResult testResult = new TestResult(this);
     testResult.Failure(_reason, _stackTrace);
     double num3 = ((double)(DateTime.Now.Ticks - ticks)) / 10000000.0;
     testResult.Time = num3;
     listener.TestFinished(testResult);
     return testResult;
 }

        TestResult CreateTestResultFromExpectation(IExpectation expectation)
        {
            var result = new TestResult(new TestName { Name = expectation.Message });

            if (expectation.IsFail)
                result.Failure(expectation.ToString(), "");
            else if (expectation.IsPass)
                result.Success();
            else if (expectation.IsPending)
                result.Ignore(expectation.ToString(), "");

            return result;
        }

        public override void RunTestMethod(TestResult testResult)
        {
            using (var runner = new Runner(Spec))
            {
                var example = runner.Run(() => RunBaseTestMethod(testResult), new TestResultExampleReporter(testResult));

                if (example.IsFail)
                    testResult.Failure(GetTestResultMessageForResultState(testResult, ResultState.Failure, "Failing"), "");

                if (example.IsPass)
                    testResult.Success();

                if (example.IsPending)
                    testResult.Ignore(GetTestResultMessageForResultState(testResult, ResultState.Ignored, "Pending"));
            }
        }

        private TestResult NUnitTestResult(IResultSummary concordionResult)
        {
            var testResult = new TestResult(this);

            if (concordionResult.HasExceptions)
            {
                testResult.Error(new NUnitException("Exception in Concordion test: please see Concordion test reports"));
            }
            else if (concordionResult.HasFailures)
            {
                testResult.Failure("Concordion Test Failures: " + concordionResult.FailureCount,
                                   "for stack trace, please see Concordion test reports");
            } else
            {
                testResult.Success();
            }

            return testResult;
        }

 private void TestExceptionCondition(TestResult result, Exception ex)
 {
     if (! TestShouldThrowException()) {
         result.Failure("Test or setup failed: "+ex.Message, ex.StackTrace);
     } else {
         if (! ThrownTypeMatchesExpectation(ex)) {
             result.Failure("Expected exception type of "
                            + testClosure.ExpectedExceptionType().Name
                            + " but got " + ex.GetType().Name, "\r\nat\r\n"+ex.StackTrace);
         } else {
             if (! TestExpectsAMessage()) result.Success();
             else {
                 if (ThrownMessageMatchesExpectation(ex)) result.Success();
                 else result.Failure("Expected exception message \r\n\""
                                     + testClosure.ExpectedExceptionMessage()
                                     + "\" but got \r\n\"" + ex.Message, "\"");
             }
         }
     }
 }

        private TestResult NUnitTestResult(IResultSummary concordionResult, string resultPath)
        {
            var testResult = new TestResult(this);

            if (concordionResult.HasExceptions)
            {
                var errorDetails = concordionResult.ErrorDetails.First();
                testResult.Error(errorDetails.Exception);
                testResult.SetResult(testResult.ResultState,
                                     resultPath + Environment.NewLine + testResult.Message,
                                     testResult.StackTrace);
            }
            else if (concordionResult.HasFailures)
            {
                var failureDetails = concordionResult.FailureDetails.First();
                testResult.Failure(resultPath + Environment.NewLine + failureDetails.Message, failureDetails.StackTrace);
            } else
            {
                testResult.Success(resultPath);
            }

            return testResult;
        }

        public override void DoFixtureTearDown(TestResult suiteResult)
        {
            if (ShouldRun)
            {
                try
                {
                    Status = SetUpState.SetUpNeeded;
                    _fixture.FixtureTeardown();
                }
                catch (Exception ex)
                {
                    NunitException nex = ex as NunitException;
                    if (nex != null)
                        ex = nex.InnerException;

                    suiteResult.Failure(ex.Message, ex.StackTrace);
                }
                finally
                {
                    if (testFramework != null)
                        suiteResult.AssertCount += testFramework.GetAssertCount();
                }
            }
        }

		public override void DoTearDown( TestResult suiteResult )
		{
			if (this.ShouldRun) 
			{
				try 
				{
					IsSetUp = false;
					if (this.fixtureTearDown != null)
						Reflect.InvokeMethod(fixtureTearDown, Fixture);
				} 
				catch (Exception ex) 
				{
					// Error in TestFixtureTearDown causes the
					// suite to be marked as a failure, even if
					// all the contained tests passed.
					NunitException nex = ex as NunitException;
					if (nex != null)
						ex = nex.InnerException;

					suiteResult.Failure( ex.Message, ex.StackTrace);
				}
				finally
				{
					suiteResult.AssertCount += NUnit.Framework.Assert.Counter;
				}
			}

			if (this.IgnoreReason == FIXTURE_SETUP_FAILED) 
			{
				this.ShouldRun = true;
				this.IgnoreReason = null;
			}
		}

 protected void RecordException(Exception ex, TestResult testResult)
 {
     if (testFramework.IsIgnoreException(ex))
         testResult.NotRun(ex.Message);
     else if (testFramework.IsAssertException(ex))
         testResult.Failure(ex.Message, ex.StackTrace);
     else
         testResult.Failure(BuildMessage(ex), BuildStackTrace(ex));
 }

        private void MarkTestFailed(
            Test test, TestResult suiteResult, EventListener listener, ITestFilter filter)
        {
            if (test is TestSuite)
            {
                listener.SuiteStarted(test.TestName);
                TestResult result = new TestResult( new TestInfo(test) );
				string msg = this.FixtureType == null
                    ? "Parent SetUp failed"
                    : string.Format( "Parent SetUp failed in {0}", this.FixtureType.Name );

				result.Failure(msg, null, FailureSite.Parent);
                MarkTestsFailed(test.Tests, result, listener, filter);
                suiteResult.AddResult(result);
                listener.SuiteFinished(result);
            }
            else
            {
                listener.TestStarted(test.TestName);
                TestResult result = new TestResult( new TestInfo(test) );
				string msg = this.FixtureType == null
                    ? "TestFixtureSetUp failed"
                    : string.Format( "TestFixtureSetUp failed in {0}", this.FixtureType.Name );
				result.Failure(msg, null, FailureSite.Parent);
				suiteResult.AddResult(result);
                listener.TestFinished(result);
            }
        }

        protected virtual void DoOneTimeAfterTestSuiteActions(TestResult suiteResult)
        {
            try
            {
                ExecuteActions(ActionPhase.After);
            }
            catch (Exception ex)
            {
                // Error in TestFixtureTearDown or Dispose causes the
                // suite to be marked as a failure, even if
                // all the contained tests passed.
                NUnitException nex = ex as NUnitException;
                if (nex != null)
                    ex = nex.InnerException;

                suiteResult.Failure(ex.Message, ex.StackTrace, FailureSite.TearDown);
            }
        }

        protected virtual void DoOneTimeTearDown(TestResult suiteResult)
        {
            if ( this.RunState == RunState.Runnable && this.Fixture != null)
            {
                try
                {
                    if (this.fixtureTearDown != null)
                        Reflect.InvokeMethod(fixtureTearDown, Fixture);
                }
                catch (Exception ex)
                {
                    // Error in TestFixtureTearDown causes the
                    // suite to be marked as a failure, even if
                    // all the contained tests passed.
                    NUnitException nex = ex as NUnitException;
                    if (nex != null)
                        ex = nex.InnerException;

                    suiteResult.Failure(ex.Message, ex.StackTrace, FailureSite.TearDown);
                }
                finally
                {
                    IDisposable disposeable = Fixture as IDisposable;
                    if (disposeable != null)
                        disposeable.Dispose();
                    this.Fixture = null;
                }
            }
        }