public void ProcessException(Exception exception, TestResult testResult) { if (exception is NUnitException) { exception = exception.InnerException; } if (IsExpectedExceptionType(exception)) { if (IsExpectedMessageMatch(exception)) { if (exceptionHandler != null) { Reflect.InvokeMethod(exceptionHandler, testMethod.Fixture, exception); } testResult.Success(); } else { testResult.Failure(WrongTextMessage(exception), GetStackTrace(exception)); } } else { switch (NUnitFramework.GetResultState(exception)) { case ResultState.Failure: testResult.Failure(exception.Message, exception.StackTrace); break; case ResultState.Ignored: testResult.Ignore(exception); break; case ResultState.Inconclusive: testResult.SetResult(ResultState.Inconclusive, exception, FailureSite.Test); break; case ResultState.Success: testResult.Success(exception.Message); break; default: testResult.Failure(WrongTypeMessage(exception), GetStackTrace(exception)); break; } } }
protected virtual void DoOneTimeTearDown(TestResult suiteResult) { if (this.Fixture != null) { try { if (this.fixtureTearDown != null) { Reflect.InvokeMethod(fixtureTearDown, Fixture); } IDisposable disposable = Fixture as IDisposable; if (disposable != null) { disposable.Dispose(); } } 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); } this.Fixture = null; } }
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; }
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); } } }
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); } }
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(); } }
/// <summary> /// The doRun method is used to run a test internally. /// It assumes that the caller is taking care of any /// TestFixtureSetUp and TestFixtureTearDown needed. /// </summary> /// <param name="testResult">The result in which to record success or failure</param> public virtual TestResult RunTest() { DateTime start = DateTime.Now; TestResult testResult = new TestResult(this); TestExecutionContext.CurrentContext.CurrentResult = testResult; try { RunSetUp(); RunTestCase( testResult ); } catch(Exception ex) { // doTestCase handles its own exceptions so // if we're here it's a setup exception if (ex is ThreadAbortException) Thread.ResetAbort(); RecordException(ex, testResult, FailureSite.SetUp); } finally { RunTearDown( testResult ); DateTime stop = DateTime.Now; TimeSpan span = stop.Subtract(start); testResult.Time = (double)span.Ticks / (double)TimeSpan.TicksPerSecond; if (testResult.IsSuccess) { if (this.Properties.Contains("MaxTime")) { int elapsedTime = (int)Math.Round(testResult.Time * 1000.0); int maxTime = (int)this.Properties["MaxTime"]; if (maxTime > 0 && elapsedTime > maxTime) testResult.Failure( string.Format("Elapsed time of {0}ms exceeds maximum of {1}ms", elapsedTime, maxTime), null); } if (testResult.IsSuccess && testResult.Message == null && Environment.CurrentDirectory != TestExecutionContext.CurrentContext.prior.CurrentDirectory) { // TODO: Introduce a warning result state in NUnit 3.0 testResult.SetResult(ResultState.Success, "Warning: Test changed the CurrentDirectory", null); } } } log.Debug("Test result = " + testResult.ResultState); return testResult; }
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; }
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.Properties["_SETCULTURE"] != null) { TestContext.CurrentCulture = new System.Globalization.CultureInfo((string)Properties["_SETCULTURE"]); } if (this.fixtureSetUpMethods != null) { foreach (MethodInfo fixtureSetUp in fixtureSetUpMethods) { Reflect.InvokeMethod(fixtureSetUp, fixtureSetUp.IsStatic ? null : 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); } } } } }
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; }
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); } }
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")); } }
/// <summary> /// The doRun method is used to run a test internally. /// It assumes that the caller is taking care of any /// TestFixtureSetUp and TestFixtureTearDown needed. /// </summary> /// <param name="testResult">The result in which to record success or failure</param> public virtual void doRun(TestResult testResult) { DateTime start = DateTime.Now; try { doSetUp(); doTestCase(testResult); } catch (Exception ex) { // doTestCase handles its own exceptions so // if we're here it's a setup exception if (ex is ThreadAbortException) { Thread.ResetAbort(); } RecordException(ex, testResult, FailureSite.SetUp); } finally { doTearDown(testResult); DateTime stop = DateTime.Now; TimeSpan span = stop.Subtract(start); testResult.Time = (double)span.Ticks / (double)TimeSpan.TicksPerSecond; if (testResult.IsSuccess && this.Properties.Contains("MaxTime")) { int elapsedTime = (int)Math.Round(testResult.Time * 1000.0); int maxTime = (int)this.Properties["MaxTime"]; if (maxTime > 0 && elapsedTime > maxTime) { testResult.Failure( string.Format("Elapsed time of {0}ms exceeds maximum of {1}ms", elapsedTime, maxTime), null); } } } }
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); } } } } }
public override void DoSetUp(TestResult suiteResult) { try { if (Fixture == null) { Fixture = Reflect.Construct(fixtureType); } if (this.fixtureSetUp != null) { Reflect.InvokeMethod(fixtureSetUp, Fixture); } IsSetUp = true; } catch (Exception ex) { // Error in TestFixtureSetUp causes the suite and // all contained suites to be ignored. // TODO: Change this to be a failure? NunitException nex = ex as NunitException; if (nex != null) { ex = nex.InnerException; } if (ex is NUnit.Framework.IgnoreException) { this.ShouldRun = false; suiteResult.NotRun(ex.Message); suiteResult.StackTrace = ex.StackTrace; this.IgnoreReason = ex.Message; } else { suiteResult.Failure(ex.Message, ex.StackTrace, true); } } finally { suiteResult.AssertCount = NUnit.Framework.Assert.Counter; } }
/// <summary> /// The doRun method is used to run a test internally. /// It assumes that the caller is taking care of any /// TestFixtureSetUp and TestFixtureTearDown needed. /// </summary> /// <param name="testResult">The result in which to record success or failure</param> public virtual void doRun(TestResult testResult) { DateTime start = DateTime.Now; try { doSetUp(); doTestCase(testResult); } catch (Exception ex) { if (ex is NUnitException) { ex = ex.InnerException; } RecordException(ex, testResult); } finally { doTearDown(testResult); DateTime stop = DateTime.Now; TimeSpan span = stop.Subtract(start); testResult.Time = (double)span.Ticks / (double)TimeSpan.TicksPerSecond; if (testResult.IsSuccess && this.Properties.Contains("MaxTime")) { int elapsedTime = (int)Math.Round(testResult.Time * 1000.0); int maxTime = (int)this.Properties["MaxTime"]; if (maxTime > 0 && elapsedTime > maxTime) { testResult.Failure( string.Format("Elapsed time of {0}ms exceeds maximum of {1}ms", elapsedTime, maxTime), null); } } } }
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, "\""); } } } }
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.FixtureType != null) { try { if (this.fixtureTearDownMethods != null) { int index = fixtureTearDownMethods.Length; while (--index >= 0) { MethodInfo fixtureTearDown = fixtureTearDownMethods[index]; Reflect.InvokeMethod(fixtureTearDown, fixtureTearDown.IsStatic ? null : Fixture); } } IDisposable disposable = Fixture as IDisposable; if (disposable != null) { disposable.Dispose(); } } 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); } this.Fixture = null; } }
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 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; } }
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(); } } }
protected virtual void DoOneTimeTearDown(TestResult suiteResult) { if ( this.FixtureType != null) { try { if (this.fixtureTearDownMethods != null) { int index = fixtureTearDownMethods.Length; while (--index >= 0 ) { MethodInfo fixtureTearDown = fixtureTearDownMethods[index]; Reflect.InvokeMethod(fixtureTearDown, fixtureTearDown.IsStatic ? null : Fixture); } } IDisposable disposable = Fixture as IDisposable; if (disposable != null) disposable.Dispose(); } 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); } this.Fixture = null; } }
public void ProcessNoException(TestResult testResult) { testResult.Failure(NoExceptionMessage(), null); }
public override void DoSetUp( TestResult suiteResult ) { try { if ( Fixture == null ) Fixture = Reflect.Construct( fixtureType ); if (this.fixtureSetUp != null) Reflect.InvokeMethod(fixtureSetUp, Fixture); IsSetUp = true; } catch (Exception ex) { // Error in TestFixtureSetUp causes the suite and // all contained suites to be ignored. // TODO: Change this to be a failure? NunitException nex = ex as NunitException; if (nex != null) ex = nex.InnerException; if ( ex is NUnit.Framework.IgnoreException ) { this.ShouldRun = false; suiteResult.NotRun(ex.Message); suiteResult.StackTrace = ex.StackTrace; this.IgnoreReason = ex.Message; } else { suiteResult.Failure( ex.Message, ex.StackTrace, true ); } } finally { suiteResult.AssertCount = NUnit.Framework.Assert.Counter; } }
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; } }
/// <summary> /// The doRun method is used to run a test internally. /// It assumes that the caller is taking care of any /// TestFixtureSetUp and TestFixtureTearDown needed. /// </summary> /// <param name="testResult">The result in which to record success or failure</param> public virtual void doRun( TestResult testResult ) { DateTime start = DateTime.Now; try { doSetUp(); doTestCase( testResult ); } catch(Exception ex) { // doTestCase handles its own exceptions so // if we're here it's a setup exception if (ex is ThreadAbortException) Thread.ResetAbort(); RecordException(ex, testResult, FailureSite.SetUp); } finally { doTearDown( testResult ); DateTime stop = DateTime.Now; TimeSpan span = stop.Subtract(start); testResult.Time = (double)span.Ticks / (double)TimeSpan.TicksPerSecond; if (testResult.IsSuccess && this.Properties.Contains("MaxTime")) { int elapsedTime = (int)Math.Round(testResult.Time * 1000.0); int maxTime = (int)this.Properties["MaxTime"]; if (maxTime > 0 && elapsedTime > maxTime) testResult.Failure( string.Format("Elapsed time of {0}ms exceeds maximum of {1}ms", elapsedTime, maxTime), null); } } }
public void SetResult_Failure() { TestSuiteTreeNode node = new TestSuiteTreeNode( testCaseInfo ); TestResult result = new TestResult( testCaseInfo ); result.Failure("message", "stacktrace"); node.Result = result; Assert.AreEqual( TestSuiteTreeNode.FailureIndex, node.ImageIndex ); Assert.AreEqual( TestSuiteTreeNode.FailureIndex, node.SelectedImageIndex ); Assert.AreEqual( "Failure", node.StatusText ); }
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; } } }
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 ); }
public void WhenResultIsCleared_IndexReflectsRunState(string testName, int expectedIndex) { Test test = TestFinder.Find(testName, testFixture, false); TestResult result = new TestResult( test ); result.Failure("message", "stacktrace"); TestSuiteTreeNode node = new TestSuiteTreeNode( result ); Assert.AreEqual( TestSuiteTreeNode.FailureIndex, node.ImageIndex ); Assert.AreEqual( TestSuiteTreeNode.FailureIndex, node.SelectedImageIndex ); node.ClearResults(); Assert.AreEqual( null, node.Result ); Assert.AreEqual( expectedIndex, node.ImageIndex ); Assert.AreEqual( expectedIndex, node.SelectedImageIndex ); }
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); } }
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); } }
public void ClearResult() { TestResult result = new TestResult( testCaseInfo ); result.Failure("message", "stacktrace"); TestSuiteTreeNode node = new TestSuiteTreeNode( result ); Assert.AreEqual( TestSuiteTreeNode.FailureIndex, node.ImageIndex ); Assert.AreEqual( TestSuiteTreeNode.FailureIndex, node.SelectedImageIndex ); node.ClearResults(); Assert.AreEqual( null, node.Result ); Assert.AreEqual( TestSuiteTreeNode.InitIndex, node.ImageIndex ); Assert.AreEqual( TestSuiteTreeNode.InitIndex, node.SelectedImageIndex ); }
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)); }
/// <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); } } } } }
public override void doRun(TestResult testResult) { DateTime start = DateTime.Now; try { doSetUp(); doTestCase(testResult); } finally { doTearDown(testResult); DateTime stop = DateTime.Now; TimeSpan span = stop.Subtract(start); testResult.Time = (double) span.Ticks / (double) TimeSpan.TicksPerSecond; if (testResult.IsSuccess && this.Properties.Contains("MaxTime")) { int elapsedTime = (int) Math.Round(testResult.Time * 1000.0); int maxTime = (int) this.Properties["MaxTime"]; if (maxTime > 0 && elapsedTime > maxTime) testResult.Failure( string.Format("Elapsed time of {0}ms exceeds maximum of {1}ms", elapsedTime, maxTime), null); } } }
public void ProcessException(Exception exception, TestResult testResult) { if (exception is NUnitException) exception = exception.InnerException; if (IsExpectedExceptionType(exception)) { if (IsExpectedMessageMatch(exception)) { if (exceptionHandler != null) Reflect.InvokeMethod(exceptionHandler, testMethod.Fixture, exception); testResult.Success(); } else { testResult.Failure(WrongTextMessage(exception), GetStackTrace(exception)); } } else { switch (NUnitFramework.GetResultState(exception)) { case ResultState.Failure: testResult.Failure(exception.Message, exception.StackTrace); break; case ResultState.Ignored: testResult.Ignore(exception); break; case ResultState.Inconclusive: testResult.SetResult(ResultState.Inconclusive, exception, FailureSite.Test); break; case ResultState.Success: testResult.Success(exception.Message); break; default: testResult.Failure(WrongTypeMessage(exception), GetStackTrace(exception)); break; } } }
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 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); } } }
/// <summary> /// The doRun method is used to run a test internally. /// It assumes that the caller is taking care of any /// TestFixtureSetUp and TestFixtureTearDown needed. /// </summary> /// <param name="testResult">The result in which to record success or failure</param> public virtual TestResult RunTest() { DateTime start = DateTime.Now; TestResult testResult = new TestResult(this); TestExecutionContext.CurrentContext.CurrentResult = testResult; try { RunSetUp(); #if CLR_2_0 || CLR_4_0 RunBeforeActions(testResult); #endif RunTestCase( testResult ); } catch(Exception ex) { // doTestCase handles its own exceptions so // if we're here it's a setup exception if (ex is ThreadAbortException) Thread.ResetAbort(); RecordException(ex, testResult, FailureSite.SetUp); } finally { #if CLR_2_0 || CLR_4_0 RunAfterActions(testResult); #endif RunTearDown( testResult ); DateTime stop = DateTime.Now; TimeSpan span = stop.Subtract(start); testResult.Time = (double)span.Ticks / (double)TimeSpan.TicksPerSecond; if (testResult.IsSuccess) { if (this.Properties.Contains("MaxTime")) { int elapsedTime = (int)Math.Round(testResult.Time * 1000.0); int maxTime = (int)this.Properties["MaxTime"]; if (maxTime > 0 && elapsedTime > maxTime) testResult.Failure( string.Format("Elapsed time of {0}ms exceeds maximum of {1}ms", elapsedTime, maxTime), null); } if (testResult.IsSuccess && testResult.Message == null && Environment.CurrentDirectory != TestExecutionContext.CurrentContext.prior.CurrentDirectory) { // TODO: Introduce a warning result state in NUnit 3.0 testResult.SetResult(ResultState.Success, "Warning: Test changed the CurrentDirectory", null); } } } log.Debug("Test result = " + testResult.ResultState); return testResult; }
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); } }