C# TestResult.Error方法代码示例

        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 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 TestResult Run(EventListener listener, ITestFilter filter)
        {
            // TODO: Implement logic required for filtering.

            listener.TestStarted(this.TestName);
            long startTime = DateTime.Now.Ticks;

            var result = new TestResult(this);

            try
            {
                _engine.ExecuteScriptFile(_scriptPath);
                result.Success();
            }
            catch (AssertionException assertEx)
            {
                result.SetResult(ResultState.Failure, assertEx.Message, assertEx.StackTrace, FailureSite.Test);
            }
            catch (InconclusiveException inconclusiveEx)
            {
                result.SetResult(ResultState.Inconclusive, inconclusiveEx.Message, inconclusiveEx.StackTrace);
            }
            catch (Exception ex)
            {
                result.Error(ex);
            }
            finally
            {
                long stopTime = DateTime.Now.Ticks;
                double time = ((double)(stopTime - startTime)) / (double)TimeSpan.TicksPerSecond;
                result.Time = time;

                listener.TestFinished(result);
            }

            return result;
        }

        public override TestResult Run(EventListener listener, ITestFilter filter)
        {
            listener.TestStarted(this.TestName);

            Fixture = Reflect.Construct(m_FixtureType);
            RunFixtureSetUp();
            TestResult testResult;
            try
            {
                var testRunner = new DefaultConcordionRunner();
                var concordionResult = testRunner.Run(Fixture);
                testResult = NUnitTestResult(concordionResult, "");
            }
            catch (Exception exception)
            {
                testResult = new TestResult(this);
                testResult.Error(exception);
            }
            RunFixtureTearDown();

            listener.TestFinished(testResult);

            return testResult;
        }

 private void RunAfterActions(TestResult testResult)
 {
     try
     {
         ExecuteActions(ActionPhase.After);
     }
     catch (Exception ex)
     {
         if (ex is NUnitException)
             ex = ex.InnerException;
         // TODO: What about ignore exceptions in teardown?
         testResult.Error(ex, FailureSite.TearDown);
     }
 }

        protected virtual void DoOneTimeSetUp(TestResult suiteResult)
        {
            if (FixtureType != null)
            {
                try
                {
                    if (Fixture == null) // In case TestFixture was created with fixture object
                        CreateUserFixture();

                    if (this.fixtureSetUp != null)
                        Reflect.InvokeMethod(fixtureSetUp, Fixture);
                }
                catch (Exception ex)
                {
                    if (ex is NUnitException || ex is System.Reflection.TargetInvocationException)
                        ex = ex.InnerException;

                    if (IsIgnoreException(ex))
                    {
                        this.RunState = RunState.Ignored;
                        suiteResult.Ignore(ex.Message);
                        suiteResult.StackTrace = ex.StackTrace;
                        this.IgnoreReason = ex.Message;
                    }
                    else
                    {
                        if (IsAssertException(ex))
                            suiteResult.Failure(ex.Message, ex.StackTrace, FailureSite.SetUp);
                        else
                            suiteResult.Error(ex, FailureSite.SetUp);
                    }
                }
            }
        }

		protected void RecordException( Exception ex, TestResult testResult )
		{
			if ( IsIgnoreException( ex ) )
				testResult.Ignore( ex.Message );
			else if ( IsAssertException( ex ) )
				testResult.Failure( ex.Message, ex.StackTrace );
			else	
				testResult.Error( ex );
		}

 private void RunTearDown( TestResult testResult )
 {
     try
     {
         if (tearDownMethods != null)
         {
             int index = tearDownMethods.Length;
             while (--index >= 0)
                 Reflect.InvokeMethod(tearDownMethods[index], tearDownMethods[index].IsStatic ? null : this.Fixture);
         }
     }
     catch(Exception ex)
     {
         if ( ex is NUnitException )
             ex = ex.InnerException;
         // TODO: What about ignore exceptions in teardown?
         testResult.Error( ex,FailureSite.TearDown );
     }
 }

        protected virtual void DoOneTimeBeforeTestSuiteActions(TestResult suiteResult)
        {
            try
            {
                ExecuteActions(ActionPhase.Before);
                TestExecutionContext.CurrentContext.Update();
            }
            catch (Exception ex)
            {
                if (ex is NUnitException || ex is System.Reflection.TargetInvocationException)
                    ex = ex.InnerException;

                if (ex is InvalidTestFixtureException)
                    suiteResult.Invalid(ex.Message);
                else if (IsIgnoreException(ex))
                {
                    this.RunState = RunState.Ignored;
                    suiteResult.Ignore(ex.Message);
                    suiteResult.StackTrace = ex.StackTrace;
                    this.IgnoreReason = ex.Message;
                }
                else if (IsAssertException(ex))
                    suiteResult.Failure(ex.Message, ex.StackTrace, FailureSite.SetUp);
                else
                    suiteResult.Error(ex, FailureSite.SetUp);
            }
        }

        protected virtual void DoOneTimeSetUp(TestResult suiteResult)
        {
            if (FixtureType != null)
            {
                try
                {
					// In case TestFixture was created with fixture object
					if (Fixture == null && !IsStaticClass( FixtureType ) )
						CreateUserFixture();

                    if (this.fixtureSetUpMethods != null)
                        foreach( MethodInfo fixtureSetUp in fixtureSetUpMethods )
                            Reflect.InvokeMethod(fixtureSetUp, fixtureSetUp.IsStatic ? null : Fixture);

                    TestExecutionContext.CurrentContext.Update();
                }
                catch (Exception ex)
                {
                    if (ex is NUnitException || ex is System.Reflection.TargetInvocationException)
                        ex = ex.InnerException;

                    if (ex is InvalidTestFixtureException)
                        suiteResult.Invalid(ex.Message);
                    else if (IsIgnoreException(ex))
                    {
                        this.RunState = RunState.Ignored;
                        suiteResult.Ignore(ex.Message);
                        suiteResult.StackTrace = ex.StackTrace;
                        this.IgnoreReason = ex.Message;
                    }
                    else if (IsAssertException(ex))
                        suiteResult.Failure(ex.Message, ex.StackTrace, FailureSite.SetUp);
                    else
                        suiteResult.Error(ex, FailureSite.SetUp);
                }
            }
        }

 public override TestResult Run(EventListener listener, ITestFilter filter)
 {
     listener.SuiteStarted(TestName);
     var result = new TestResult(this);
     try {
         ITestResult resultAdapter = new NUnitTestResultAdapter(result);
         fixture.WithInitialized(_ => {
             foreach(var item in Tests.Cast<Test>().Where(filter.Pass).Select(x => x.Run(listener, filter)))
      						result.AddResult(item);
             }, ex => {
                 resultAdapter.BeforeFailure(ex);
                 foreach(Test item in Tests) {
                     var failure = new TestResult(item);
                     listener.TestStarted(item.TestName);
                     failure.Error(ex, FailureSite.SetUp);
                     listener.TestFinished(failure);
                     result.AddResult(failure);
             }
         }, resultAdapter.AfterFailure);
     } finally {
         listener.SuiteFinished(result);
     }
     return result;
 }

		/// <summary>
		/// Performs a one-time set-up for this test suite.
		/// </summary>
		/// <remarks>
		/// The implementation calls the base method and then calls all methods decorated
		/// with NUnit's Test Fixture Set Up Attribute that accept a single argument parameter.
		/// </remarks>
		/// <param name="suiteResult">The result of the test.</param>
		protected override void DoOneTimeSetUp(TestResult suiteResult)
		{
			base.DoOneTimeSetUp(suiteResult);
			try
			{
				if (Argument != null)
				{
					foreach (MethodInfo setupMethod in Reflect.GetMethodsWithAttribute(FixtureType, NUnitFramework.FixtureSetUpAttribute, true))
					{
						if (setupMethod.GetParameters().Length == 1)
						{
							Reflect.InvokeMethod(setupMethod, this.Fixture, Argument);
						}
					}
				}
			}
			catch (Exception innerException)
			{
				if (innerException is NUnitException || innerException is TargetInvocationException)
				{
					innerException = innerException.InnerException;
				}

				if (innerException is InvalidTestFixtureException)
				{
					suiteResult.Invalid(innerException.Message);
				}
				else
				{
					if (this.IsIgnoreException(innerException))
					{
						base.RunState = RunState.Ignored;
						suiteResult.Ignore(innerException.Message);
						suiteResult.StackTrace = innerException.StackTrace;
						base.IgnoreReason = innerException.Message;
					}
					else
					{
						if (this.IsAssertException(innerException))
						{
							suiteResult.Failure(innerException.Message, innerException.StackTrace, FailureSite.SetUp);
						}
						else
						{
							suiteResult.Error(innerException, FailureSite.SetUp);
						}
					}
				}
			}
		}

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

            if (concordionResult.hasExceptions())
            {
                testResult.Error(new NUnitException("Exception in Concordion test: please see Concordion test reports"));
            }
            else if (concordionResult.getFailureCount() > 0)
            {
                testResult.Failure("Concordion Test Failures: " + concordionResult.getFailureCount(),
                                   "for stack trace, please see Concordion test reports");
            } else
            {
                testResult.Success(resultPath);
            }

            return testResult;
        }