public override void RunTestMethod(TestCaseResult testResult) #endif { object[] arguments = _arguments != null ? _arguments : new object[] { null }; Reflect.InvokeMethod(this.Method, this.Fixture, arguments); testResult.Success(); // If no exception occured }
public virtual void doRun(TestCaseResult testResult) { DateTime start = DateTime.Now; try { _fixture.Setup(); 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; } }
private TestResult SimulateTest( TestNode test, bool ignore ) { if ( test.RunState != RunState.Runnable ) ignore = true; if ( test.IsSuite ) { FireSuiteStarting( test.TestName ); TestSuiteResult result = new TestSuiteResult( test, test.TestName.Name ); foreach( TestNode childTest in test.Tests ) result.AddResult( SimulateTest( childTest, ignore ) ); FireSuiteFinished( result ); return result; } else { FireTestStarting( test.TestName ); TestCaseResult result = new TestCaseResult( test ); result.RunState = ignore ? RunState.Ignored : RunState.Executed; FireTestFinished( result ); return result; } }
private TestSuiteResult MockSuiteResult(string suiteName, bool failure) { TestSuiteResult result = new TestSuiteResult(suiteName); result.Time = time; result.RunState = RunState.Executed; TestSuiteResult level1SuiteA = new TestSuiteResult("level 1 A"); result.AddResult(level1SuiteA); level1SuiteA.RunState = RunState.Executed; TestSuiteResult level1SuiteB = new TestSuiteResult("level 1 B"); result.AddResult(level1SuiteB); level1SuiteB.RunState = RunState.Executed; testCase = new TestCaseResult("a test case"); if(failure) testCase.Failure("argument exception",null); else testCase.Success(); level1SuiteA.AddResult(testCase); testCase = new TestCaseResult("a successful test"); testCase.Success(); level1SuiteB.AddResult(testCase); testCase = new TestCaseResult("a not run test"); testCase.Ignore("test not run"); level1SuiteB.AddResult(testCase); return result; }
protected override internal void ProcessException(Exception exception, TestCaseResult testResult) { if (expectedException.Equals(exception.GetType())) { if (expectedMessage != null && !expectedMessage.Equals(exception.Message)) { string message = string.Format("Expected exception to have message: \"{0}\" but received message \"{1}\"", expectedMessage, exception.Message); testResult.Failure(message, exception.StackTrace); } else { testResult.Success(); } } else if (exception is Framework.AssertionException) { RecordException(exception,testResult); } else { string message = "Expected: " + expectedException.Name + " but was " + exception.GetType().Name; testResult.Failure(message, exception.StackTrace); } return; }
public override void Run(TestCaseResult testResult) { if (ShouldRun) { bool doParentSetUp = false; if (Parent != null) { doParentSetUp = !Parent.IsSetUp; } try { if (doParentSetUp) { Parent.DoSetUp(testResult); } if (Fixture == null && Parent != null) { Fixture = Parent.Fixture; } if (!testResult.IsFailure) { doRun(testResult); } } catch (Exception ex) { if (ex is NunitException) { ex = ex.InnerException; } if (ex is NUnit.Framework.IgnoreException) { testResult.NotRun(ex.Message); } else { RecordException(ex, testResult); } } finally { if (doParentSetUp) { Parent.DoTearDown(testResult); } } } else { testResult.NotRun(this.IgnoreReason); } }
public override void RunTestMethod(TestCaseResult testResult) { DecompilationTestAttribute attribute = DecompilationTestFactory.GetDecompilationTestAttribute (Method); var body = attribute.GetMethodBody(this.type); string path = string.Concat(DecompilationTestFixture.TestCasesDirectory, Path.DirectorySeparatorChar + resultFilename); if(attribute.Mode==Mode.MethodDefinition) Reflect.InvokeMethod(Method, Fixture, new object[] { body.Method, File.ReadAllText(path) }); else Reflect.InvokeMethod(Method,Fixture, new object[] {body, File.ReadAllText(path)}); }
protected internal virtual void ProcessNoException(TestCaseResult testResult) { if (ExceptionExpected) { testResult.Failure(NoExceptionMessage(), null); } else { testResult.Success(); } }
public void RunTestMethod_WithArguments() { object[] arguments = new object[] { 42, 53 }; TestClass testFixture = new TestClass(); RowTestCase testCase = CreateRowTestCase(testFixture, Method_RowTestMethodWith2Rows, arguments); TestCaseResult result = new TestCaseResult(testCase.TestName.Name); testCase.RunTestMethod(result); Assert.That(testFixture.Arguments, Is.Not.Null); Assert.That(testFixture.Arguments[0], Is.EqualTo(arguments[0])); Assert.That(testFixture.Arguments[1], Is.EqualTo(arguments[1])); }
public void Visit(TestCaseResult caseResult) { SetNameandTime(caseResult.Name, caseResult.Time); if(caseResult.Executed) { totalCount++; if(caseResult.IsFailure) failureCount++; } else testsNotRun++; }
public void Visit(TestCaseResult caseResult) { xmlWriter.WriteStartElement("test-case"); xmlWriter.WriteAttributeString("name",caseResult.Name); if(caseResult.Description != null) xmlWriter.WriteAttributeString("description", caseResult.Description); xmlWriter.WriteAttributeString("executed", caseResult.Executed.ToString()); if(caseResult.Executed) { xmlWriter.WriteAttributeString("success", caseResult.IsSuccess.ToString() ); xmlWriter.WriteAttributeString("time", caseResult.Time.ToString("#####0.000", NumberFormatInfo.InvariantInfo)); xmlWriter.WriteAttributeString("asserts", caseResult.AssertCount.ToString() ); WriteCategories(caseResult); WriteProperties(caseResult); if(caseResult.IsFailure) { if(caseResult.IsFailure) xmlWriter.WriteStartElement("failure"); else xmlWriter.WriteStartElement("error"); xmlWriter.WriteStartElement("message"); xmlWriter.WriteCData( EncodeCData( caseResult.Message ) ); xmlWriter.WriteEndElement(); xmlWriter.WriteStartElement("stack-trace"); if(caseResult.StackTrace != null) xmlWriter.WriteCData( EncodeCData( StackTraceFilter.Filter( caseResult.StackTrace ) ) ); xmlWriter.WriteEndElement(); xmlWriter.WriteEndElement(); } } else { WriteCategories(caseResult); // WriteProperties(caseResult); xmlWriter.WriteStartElement("reason"); xmlWriter.WriteStartElement("message"); xmlWriter.WriteCData(caseResult.Message); xmlWriter.WriteEndElement(); xmlWriter.WriteEndElement(); } xmlWriter.WriteEndElement(); }
public void ClearResult() { TestCaseResult result = new TestCaseResult( testCaseInfo ); result.Failure("message", "stacktrace"); TestSuiteTreeNode node = new TestSuiteTreeNode( result ); Assert.AreEqual( TestSuiteTreeNode.FailureIndex, node.ImageIndex ); Assert.AreEqual( TestSuiteTreeNode.FailureIndex, node.SelectedImageIndex ); node.ClearResult(); Assert.AreEqual( null, node.Result ); Assert.AreEqual( TestSuiteTreeNode.InitIndex, node.ImageIndex ); Assert.AreEqual( TestSuiteTreeNode.InitIndex, node.SelectedImageIndex ); }
public override TestResult Run(EventListener listener) { using (new TestContext()) { TestCaseResult testResult = MakeTestCaseResult(); listener.TestStarted(this.TestName); // The babysitter's enter/leave "listeners" specifically exist to track crashes, // so unfortunately they can't work through the (asynchronous) listener interface. bool willRun = this.RunState == RunState.Runnable || this.RunState == RunState.Explicit; if (willRun) { BabysitterSupport.RecordEnterTest(this.TestName.FullName); } long startTime = DateTime.Now.Ticks; switch (this.RunState) { case RunState.Runnable: case RunState.Explicit: Run(testResult); break; case RunState.Skipped: testResult.Skip(IgnoreReason); break; default: case RunState.NotRunnable: case RunState.Ignored: testResult.Ignore(IgnoreReason); break; } long stopTime = DateTime.Now.Ticks; if (willRun) { BabysitterSupport.RecordLeaveTest(this.TestName.FullName); } double time = ((double)(stopTime - startTime)) / (double)TimeSpan.TicksPerSecond; testResult.Time = time; listener.TestFinished(testResult); return(testResult); } }
private void doTearDown(TestCaseResult testResult) { try { Reflect.InvokeTearDown(this.Fixture); } catch (Exception ex) { if (ex is NunitException) { ex = ex.InnerException; } RecordException(ex, testResult, true); } }
//private TestCaseResult testCase; private TestSuiteResult MockSuiteResult( bool failure ) { TestCaseResult testCaseResult = new TestCaseResult("a test case"); if ( failure ) testCaseResult.Failure( "case failed", null ); TestSuiteResult level1SuiteA = new TestSuiteResult("level 1 A"); level1SuiteA.AddResult(testCaseResult); TestSuiteResult level1SuiteB = new TestSuiteResult("level 1 B"); level1SuiteB.AddResult(new TestCaseResult("a successful test")); TestSuiteResult result = new TestSuiteResult("base"); result.AddResult(level1SuiteA); result.AddResult(level1SuiteB); return result; }
public void Visit(TestCaseResult result) { if(result.Executed) { if(result.IsFailure) { TestResultItem item = new TestResultItem(result); //string resultString = String.Format("{0}:{1}", result.Name, result.Message); testDetails.BeginUpdate(); testDetails.Items.Insert(testDetails.Items.Count, item); testDetails.EndUpdate(); } } else { notRunTree.Nodes.Add(MakeNotRunNode(result)); } }
public override TestResult Run( EventListener listener ) { TestCaseResult testResult = new TestCaseResult(this); listener.TestStarted(this); long startTime = DateTime.Now.Ticks; Run( testResult ); testResult.AssertCount = NUnit.Framework.Assert.Counter; long stopTime = DateTime.Now.Ticks; double time = ((double)(stopTime - startTime)) / (double)TimeSpan.TicksPerSecond; testResult.Time = time; listener.TestFinished(testResult); return testResult; }
public void TestFinished(TestCaseResult result) { ++TestCount; if (result.IsFailure == false) return; String failureText; var stackTrace = result.StackTrace; if (String.IsNullOrEmpty(stackTrace) == false) { var stackTraceSplit = stackTrace.Split(new[] { " at " }, StringSplitOptions.RemoveEmptyEntries); var failSiteIndex = (stackTraceSplit.Length - 1); var failSite = stackTraceSplit[failSiteIndex]; var failSiteSplit = failSite.Split(new[] { " in " }, StringSplitOptions.RemoveEmptyEntries); var fileLine = failSiteSplit[1]; var fileLineSplit = fileLine.Split(new[] { ":line " }, StringSplitOptions.None); var failingTest = failSiteSplit[0]; var file = fileLineSplit[0]; var line = fileLineSplit[1]; var message = String.Empty; if (String.IsNullOrEmpty(result.Message) == false) message = "\r\n" + result.Message; failureText = file + "(" + line + "): error UT0000: " + failingTest + message; } else failureText = result.Name + ": " + result.Message; m_consoleOut.WriteLine(failureText); m_consoleOut.Flush(); ++FailedTestCount; }
public void TestFinished(TestCaseResult testResult) { if(testResult.Executed) { testRunCount++; if(testResult.IsFailure) { failureCount++; if ( progress ) Console.Write("F"); messages.Add( string.Format( "{0}) {1} :", failureCount, testResult.Test.TestName.FullName ) ); messages.Add( testResult.Message.Trim( Environment.NewLine.ToCharArray() ) ); string stackTrace = StackTraceFilter.Filter( testResult.StackTrace ); if ( stackTrace != null && stackTrace != string.Empty ) { string[] trace = stackTrace.Split( System.Environment.NewLine.ToCharArray() ); foreach( string s in trace ) { if ( s != string.Empty ) { string link = Regex.Replace( s.Trim(), @".* in (.*):line (.*)", "$1($2)"); messages.Add( string.Format( "at\n{0}", link ) ); } } } BabysitterSupport.RecordFailedTest(currentTestName); } } else { testIgnoreCount++; if ( progress ) Console.Write("N"); } currentTestName = string.Empty; }
private void doTearDown(TestCaseResult testResult) { try { if (tearDownMethod != null) { tearDownMethod.Invoke(this.Fixture, new object[0]); } } catch (Exception ex) { if (ex is NUnitException) { ex = ex.InnerException; } // TODO: What about ignore exceptions in teardown? testResult.Error(ex, FailureSite.TearDown); } }
public override TestResult Run(EventListener listener) { TestCaseResult testResult = new TestCaseResult(this); listener.TestStarted(this); long startTime = DateTime.Now.Ticks; Run(testResult); testResult.AssertCount = NUnit.Framework.Assert.Counter; long stopTime = DateTime.Now.Ticks; double time = ((double)(stopTime - startTime)) / (double)TimeSpan.TicksPerSecond; testResult.Time = time; listener.TestFinished(testResult); return(testResult); }
public override void Run(TestCaseResult testResult) { if ( ShouldRun ) { bool doParentSetUp = false; if ( Parent != null ) { doParentSetUp = !Parent.IsSetUp; } try { if ( doParentSetUp ) Parent.DoSetUp( testResult ); if ( Fixture == null && Parent != null) Fixture = Parent.Fixture; if ( !testResult.IsFailure ) doRun( testResult ); } catch(Exception ex) { if ( ex is NunitException ) ex = ex.InnerException; if ( ex is NUnit.Framework.IgnoreException ) testResult.NotRun( ex.Message ); else RecordException( ex, testResult ); } finally { if ( doParentSetUp ) Parent.DoTearDown( testResult ); } } else { testResult.NotRun(this.IgnoreReason); } }
public override void Run(TestCaseResult result) { if (ShouldRun) { DateTime start = DateTime.Now; try { List<string> expectedLines = CreateStringList(WomDocument.Parse(_expected)); WomDocument parseResult = ParseWikiText(_source); List<string> actualLines = CreateStringList(parseResult); CompareStringLists(expectedLines, actualLines); result.Success(); } catch (Exception ex) { if (ex is NunitException) { ex = ex.InnerException; } if (testFramework.IsIgnoreException(ex)) { result.NotRun(BuildMessage(ex), BuildStackTrace(ex)); } else { result.Failure(BuildMessage(ex), BuildStackTrace(ex)); } } finally { DateTime stop = DateTime.Now; TimeSpan span = stop.Subtract(start); result.Time = (double)span.Ticks / (double)TimeSpan.TicksPerSecond; } } else { result.NotRun(this.IgnoreReason); } }
protected void RecordException(Exception exception, TestCaseResult testResult, bool inTearDown) { StringBuilder msg = new StringBuilder(); StringBuilder st = new StringBuilder(); if (inTearDown) { msg.Append(testResult.Message); msg.Append(Environment.NewLine); msg.Append("TearDown : "); st.Append(testResult.StackTrace); st.Append(Environment.NewLine); st.Append("--TearDown"); st.Append(Environment.NewLine); } msg.Append(BuildMessage(exception)); st.Append(BuildStackTrace(exception)); testResult.Failure(msg.ToString(), st.ToString()); }
public override void Run(TestCaseResult testResult) { DriverTestFixture fixtureInstance = base.Parent.Fixture as DriverTestFixture; if (fixtureInstance != null) { if (needsDriverBefore) { EnvironmentManager.Instance.CreateFreshDriver(); fixtureInstance.DriverInstance = EnvironmentManager.Instance.GetCurrentDriver(); } base.Run(testResult); if (needsDriverAfter) { EnvironmentManager.Instance.CreateFreshDriver(); fixtureInstance.DriverInstance = EnvironmentManager.Instance.GetCurrentDriver(); } } }
public override void Run(TestCaseResult testResult) { if (ShouldRun) { bool needParentTearDown = false; try { if (Parent != null) { if (Parent.SetUpNeeded) { Parent.DoOneTimeSetUp(testResult); needParentTearDown = Parent.SetUpComplete; } if (Parent.SetUpFailed) testResult.Failure("TestFixtureSetUp Failed", testResult.StackTrace); } if (!testResult.IsFailure) doRun(testResult); } catch (Exception ex) { if (ex is NunitException) ex = ex.InnerException; RecordException(ex, testResult); } finally { if (needParentTearDown) Parent.DoOneTimeTearDown(testResult); } } else { testResult.NotRun(IgnoreReason); } }
private void MarkTestNotRun( Test test, RunState runState, string ignoreReason, TestSuiteResult suiteResult, EventListener listener, ITestFilter filter) { if (test is TestSuite) { listener.SuiteStarted(test.TestName); TestSuiteResult result = new TestSuiteResult(new TestInfo(test), test.TestName.FullName); result.NotRun(runState, ignoreReason, null); MarkTestsNotRun(test.Tests, runState, ignoreReason, suiteResult, listener, filter); suiteResult.AddResult(result); listener.SuiteFinished(result); } else { listener.TestStarted(test.TestName); TestCaseResult result = new TestCaseResult(new TestInfo(test)); result.NotRun(runState, ignoreReason, null); suiteResult.AddResult(result); listener.TestFinished(result); } }
public override void Run(TestCaseResult testResult) { try { if (this.Parent != null) { Fixture = this.Parent.Fixture; } if (!testResult.IsFailure) { // Temporary... to allow for tests that directly execute a test case if (Fixture == null) { Fixture = Reflect.Construct(this.FixtureType); } if (this.Properties["_SETCULTURE"] != null) { TestContext.CurrentCulture = new System.Globalization.CultureInfo((string)Properties["_SETCULTURE"]); } doRun(testResult); } } catch (Exception ex) { if (ex is NUnitException) { ex = ex.InnerException; } RecordException(ex, testResult); } finally { Fixture = null; } }
public void Visit(TestCaseResult caseResult) { SetNameandTime(caseResult.Name, caseResult.Time); switch( caseResult.RunState ) { case RunState.Executed: resultCount++; if(caseResult.IsFailure) failureCount++; break; case RunState.Ignored: ignoreCount++; break; case RunState.Explicit: case RunState.NotRunnable: case RunState.Runnable: case RunState.Skipped: default: skipCount++; break; } }
private void MarkTestFailed( Test test, TestSuiteResult suiteResult, EventListener listener, ITestFilter filter) { if (test is TestSuite) { listener.SuiteStarted(test.TestName); TestSuiteResult result = new TestSuiteResult(new TestInfo(test), test.TestName.FullName); string msg = string.Format("Parent SetUp failed in {0}", this.FixtureType.Name); result.Failure(msg, null, FailureSite.Parent); MarkTestsFailed(test.Tests, suiteResult, listener, filter); suiteResult.AddResult(result); listener.SuiteFinished(result); } else { listener.TestStarted(test.TestName); TestCaseResult result = new TestCaseResult(new TestInfo(test)); string msg = string.Format("TestFixtureSetUp failed in {0}", this.FixtureType.Name); result.Failure(msg, null, FailureSite.Parent); suiteResult.AddResult(result); listener.TestFinished(result); } }
private void doTestCase(TestCaseResult testResult) { try { Reflect.InvokeMethod(this.method, this.Fixture); ProcessNoException(testResult); } catch (Exception ex) { if (ex is NunitException) { ex = ex.InnerException; } if (ex is NUnit.Framework.IgnoreException) { testResult.NotRun(ex.Message); } else { ProcessException(ex, testResult); } } }
private void doTestCase(TestCaseResult testResult) { try { RunTestMethod(testResult); ProcessNoException(testResult); } catch (Exception ex) { if (ex is NUnitException) { ex = ex.InnerException; } if (IsIgnoreException(ex)) { testResult.Ignore(ex); } else { ProcessException(ex, testResult); } } }
public void ClearResults() { TestCaseResult testCaseResult = new TestCaseResult( testCaseInfo ); testCaseResult.Success(); TestSuiteResult testSuiteResult = new TestSuiteResult( fixtureInfo, "MockTestFixture" ); testSuiteResult.AddResult( testCaseResult ); testSuiteResult.RunState = RunState.Executed; TestSuiteTreeNode node1 = new TestSuiteTreeNode( testSuiteResult ); TestSuiteTreeNode node2 = new TestSuiteTreeNode( testCaseResult ); node1.Nodes.Add( node2 ); Assert.AreEqual( TestSuiteTreeNode.SuccessIndex, node1.ImageIndex ); Assert.AreEqual( TestSuiteTreeNode.SuccessIndex, node1.SelectedImageIndex ); Assert.AreEqual( TestSuiteTreeNode.SuccessIndex, node2.ImageIndex ); Assert.AreEqual( TestSuiteTreeNode.SuccessIndex, node2.SelectedImageIndex ); node1.ClearResults(); Assert.AreEqual( TestSuiteTreeNode.InitIndex, node1.ImageIndex ); Assert.AreEqual( TestSuiteTreeNode.InitIndex, node1.SelectedImageIndex ); Assert.AreEqual( TestSuiteTreeNode.InitIndex, node2.ImageIndex ); Assert.AreEqual( TestSuiteTreeNode.InitIndex, node2.SelectedImageIndex ); }
protected internal abstract void ProcessNoException(TestCaseResult testResult);
protected internal override void ProcessNoException(TestCaseResult testResult) { testResult.Success(); }
public abstract void Run(TestCaseResult result);
public void TestFinished(TestCaseResult result) { }
public void SetResult_Init() { TestSuiteTreeNode node = new TestSuiteTreeNode( testCaseInfo ); TestCaseResult result = new TestCaseResult( testCaseInfo ); node.Result = result; Assert.AreEqual( "NUnit.Tests.Assemblies.MockTestFixture.MockTest1", node.Result.Name ); Assert.AreEqual( TestSuiteTreeNode.InitIndex, node.ImageIndex ); Assert.AreEqual( TestSuiteTreeNode.InitIndex, node.SelectedImageIndex ); Assert.AreEqual( "Runnable", node.StatusText ); }
public void SetResult_Success() { TestSuiteTreeNode node = new TestSuiteTreeNode( testCaseInfo ); TestCaseResult result = new TestCaseResult( testCaseInfo ); result.Success(); node.Result = result; Assert.AreEqual( TestSuiteTreeNode.SuccessIndex, node.ImageIndex ); Assert.AreEqual( TestSuiteTreeNode.SuccessIndex, node.SelectedImageIndex ); Assert.AreEqual( "Success", node.StatusText ); }
private void MarkTestFailed( Test test, TestSuiteResult suiteResult, EventListener listener, ITestFilter filter) { if (test is TestSuite) { listener.SuiteStarted(test.TestName); TestSuiteResult result = new TestSuiteResult( new TestInfo(test), test.TestName.FullName); string msg = string.Format( "Parent SetUp failed in {0}", this.FixtureType.Name ); result.Failure(msg, null, FailureSite.Parent); MarkTestsFailed(test.Tests, suiteResult, listener, filter); suiteResult.AddResult(result); listener.SuiteFinished(result); } else { listener.TestStarted(test.TestName); TestCaseResult result = new TestCaseResult( new TestInfo(test) ); string msg = string.Format( "TestFixtureSetUp failed in {0}", this.FixtureType.Name ); result.Failure(msg, null, FailureSite.Parent); suiteResult.AddResult(result); listener.TestFinished(result); } }
protected internal virtual void ProcessNoException(TestCaseResult testResult) { if ( ExceptionExpected ) testResult.Failure(NoExceptionMessage(), null); else testResult.Success(); }
public virtual void RunTestMethod(TestCaseResult testResult) { Reflect.InvokeMethod(this.method, this.Fixture); }
protected void RecordException(Exception exception, TestCaseResult testResult) { RecordException(exception, testResult, false); }
public override void Run(TestCaseResult result) { result.NotRun(base.IgnoreReason); }
public virtual void RunTestMethod(TestCaseResult testResult) { Reflect.InvokeMethod( this.method, this.Fixture ); }
public TestFinishedEvent(TestCaseResult result) { this.result = result; }
protected internal virtual void ProcessException(Exception exception, TestCaseResult testResult) { if (!ExceptionExpected) { RecordException(exception, testResult); return; } if (IsExpectedExceptionType(exception)) { if (IsExpectedMessageMatch(exception)) { if ( exceptionHandler != null ) Reflect.InvokeMethod( exceptionHandler, this.Fixture, exception ); testResult.Success(); } else { testResult.Failure(WrongTextMessage(exception), GetStackTrace(exception)); } } else if (IsAssertException(exception)) { testResult.Failure(exception.Message, exception.StackTrace); } else { testResult.Failure(WrongTypeMessage(exception), GetStackTrace(exception)); } }
void NUnit.Core.EventListener.TestFinished(TestCaseResult result) { listener.TestFinished(result); events.FireTestFinished(result); }
private void MarkTestNotRun( Test test, RunState runState, string ignoreReason, TestSuiteResult suiteResult, EventListener listener, ITestFilter filter) { if (test is TestSuite) { listener.SuiteStarted(test.TestName); TestSuiteResult result = new TestSuiteResult( new TestInfo(test), test.TestName.FullName); result.NotRun( runState, ignoreReason, null ); MarkTestsNotRun(test.Tests, runState, ignoreReason, suiteResult, listener, filter); suiteResult.AddResult(result); listener.SuiteFinished(result); } else { listener.TestStarted(test.TestName); TestCaseResult result = new TestCaseResult( new TestInfo(test) ); result.NotRun( runState, ignoreReason, null ); suiteResult.AddResult(result); listener.TestFinished(result); } }
/// <summary> /// A test case finished /// </summary> /// <param name="result">Result of the test case</param> public void TestFinished(TestCaseResult result) { events.Enqueue(new TestFinishedEvent(result)); }
public void SetResult_Skipped() { TestSuiteTreeNode node = new TestSuiteTreeNode( testCaseInfo ); TestCaseResult result = new TestCaseResult( testCaseInfo ); result.RunState = RunState.Skipped; node.Result = result; Assert.AreEqual( TestSuiteTreeNode.SkippedIndex, node.ImageIndex ); Assert.AreEqual( TestSuiteTreeNode.SkippedIndex, node.SelectedImageIndex ); Assert.AreEqual( "Skipped", node.StatusText ); }
/// <summary> /// Run a test returning the result. Overrides TestMethod /// to count assertions. /// </summary> /// <param name="testResult"></param> public override void Run(TestCaseResult testResult) { base.Run(testResult); testResult.AssertCount = NUnitFramework.GetAssertCount(); }
protected override internal void ProcessNoException(TestCaseResult testResult) { testResult.Failure(expectedException.Name + " was expected", null); }
protected internal override void ProcessException(Exception exception, TestCaseResult testResult) { RecordException(exception, testResult); }
public void SetResult_Failure() { TestSuiteTreeNode node = new TestSuiteTreeNode( testCaseInfo ); TestCaseResult result = new TestCaseResult( 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 internal abstract void ProcessException(Exception exception, TestCaseResult testResult);