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; }
public void Visit(TestSuiteResult suiteResult) { if(!suiteResult.Executed) notRunTree.Nodes.Add(MakeNotRunNode(suiteResult)); foreach (TestResult result in suiteResult.Results) { result.Accept(this); } }
public override TestResult Run(EventListener listener, ITestFilter filter) { using (new TestContext()) { TestSuiteResult suiteResult = new TestSuiteResult(new TestInfo(this), TestName.Name); listener.SuiteStarted(this.TestName); long startTime = DateTime.Now.Ticks; switch (this.RunState) { case RunState.Runnable: case RunState.Explicit: suiteResult.RunState = RunState.Executed; DoOneTimeSetUp(suiteResult); if (suiteResult.IsFailure) MarkTestsFailed(Tests, suiteResult, listener, filter); else { try { RunAllTests(suiteResult, listener, filter); } finally { DoOneTimeTearDown(suiteResult); } } break; case RunState.Skipped: suiteResult.Skip(this.IgnoreReason); MarkTestsNotRun(Tests, RunState.Skipped, IgnoreReason, suiteResult, listener, filter); break; default: case RunState.Ignored: case RunState.NotRunnable: suiteResult.Ignore(this.IgnoreReason); MarkTestsNotRun(Tests, RunState.Ignored, IgnoreReason, suiteResult, listener, filter); break; } long stopTime = DateTime.Now.Ticks; double time = ((double)(stopTime - startTime)) / (double)TimeSpan.TicksPerSecond; suiteResult.Time = time; listener.SuiteFinished(suiteResult); return suiteResult; } }
public void Visit(TestSuiteResult suiteResult) { SetNameandTime(suiteResult.Name, suiteResult.Time); foreach (TestResult result in suiteResult.Results) { result.Accept(this); } if(!suiteResult.Executed) suitesNotRun++; }
//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; }
private TestCaseResult findCaseResult(TestSuiteResult suite) { foreach (TestResult r in suite.Results) { if (r is TestCaseResult) { return (TestCaseResult) r; } else { TestCaseResult result = findCaseResult((TestSuiteResult)r); if (result != null) return result; } } return null; }
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); } }
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 ); }
public void SuiteFinished(TestSuiteResult result) { }
public void Visit(TestSuiteResult suiteResult) { xmlWriter.WriteStartElement("test-suite"); xmlWriter.WriteAttributeString("name",suiteResult.Name); if(suiteResult.Description != null) xmlWriter.WriteAttributeString("description", suiteResult.Description); xmlWriter.WriteAttributeString("success", suiteResult.IsSuccess.ToString()); xmlWriter.WriteAttributeString("time", suiteResult.Time.ToString()); xmlWriter.WriteAttributeString("asserts", suiteResult.AssertCount.ToString() ); WriteCategories(suiteResult); xmlWriter.WriteStartElement("results"); foreach (TestResult result in suiteResult.Results) { result.Accept(this); } xmlWriter.WriteEndElement(); xmlWriter.WriteEndElement(); }
/// <summary> /// A suite finished /// </summary> /// <param name="result">Result of the suite</param> public void SuiteFinished(TestSuiteResult result) { events.Enqueue( new SuiteFinishedEvent( result ) ); }
private void MarkTestsFailed( IList tests, TestSuiteResult suiteResult, EventListener listener, ITestFilter filter) { foreach (Test test in ArrayList.Synchronized(tests)) if (filter.Pass(test)) MarkTestFailed(test, suiteResult, listener, filter); }
private void RunAllTests( TestSuiteResult suiteResult, EventListener listener, ITestFilter filter) { foreach (Test test in ArrayList.Synchronized(Tests)) { if (filter.Pass(test)) { RunState saveRunState = test.RunState; if (test.RunState == RunState.Runnable && this.RunState != RunState.Runnable && this.RunState != RunState.Explicit ) { test.RunState = this.RunState; test.IgnoreReason = this.IgnoreReason; } TestResult result = test.Run(listener, filter); suiteResult.AddResult(result); if (saveRunState != test.RunState) { test.RunState = saveRunState; test.IgnoreReason = null; } } } }
/// <summary> /// A suite finished /// </summary> /// <param name="result">Result of the suite</param> public void SuiteFinished(TestSuiteResult result) { events.Enqueue(new SuiteFinishedEvent(result)); }
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); } }
public virtual TestResult EndRun() { TestSuiteResult suiteResult = new TestSuiteResult( aggregateTest, Test.TestName.FullName ); foreach( TestRunner runner in runners ) suiteResult.Results.Add( runner.EndRun() ); return suiteResult; }
public void SuiteFinished(TestSuiteResult result) { TestSuite suite = (TestSuite)result.Test; if (suite.ShouldRun && ! ((suite.Tests.Count > 0) && ((Test)(suite.Tests [0])).IsSuite)) Console.WriteLine (); }
void NUnit.Core.EventListener.SuiteFinished(TestSuiteResult result) { listener.SuiteFinished(result); events.FireSuiteFinished(result); }
public void SuiteFinished(TestSuiteResult suiteResult) { if ( debugger && --level == 0) { Trace.WriteLine( "############################################################################" ); if (messages.Count == 0) { Trace.WriteLine( "############## S U C C E S S #################" ); } else { Trace.WriteLine( "############## F A I L U R E S #################" ); foreach ( string s in messages ) { Trace.WriteLine(s); } } Trace.WriteLine( "############################################################################" ); Trace.WriteLine( "Executed tests : " + testRunCount ); Trace.WriteLine( "Ignored tests : " + testIgnoreCount ); Trace.WriteLine( "Failed tests : " + failureCount ); Trace.WriteLine( "Total time : " + suiteResult.Time + " seconds" ); Trace.WriteLine( "############################################################################"); } }
public SuiteFinishedEvent(TestSuiteResult result) { this.result = result; }
public void Visit(TestSuiteResult suiteResult) { xmlWriter.WriteStartElement("test-suite"); xmlWriter.WriteAttributeString("name",suiteResult.Name); if(suiteResult.Description != null) xmlWriter.WriteAttributeString("description", suiteResult.Description); xmlWriter.WriteAttributeString("success", suiteResult.IsSuccess.ToString()); xmlWriter.WriteAttributeString("time", suiteResult.Time.ToString("#####0.000", NumberFormatInfo.InvariantInfo)); xmlWriter.WriteAttributeString("asserts", suiteResult.AssertCount.ToString() ); WriteCategories(suiteResult); WriteProperties(suiteResult); if ( suiteResult.IsFailure && suiteResult.FailureSite == FailureSite.SetUp ) { xmlWriter.WriteStartElement("failure"); xmlWriter.WriteStartElement("message"); xmlWriter.WriteCData( EncodeCData( suiteResult.Message ) ); xmlWriter.WriteEndElement(); xmlWriter.WriteStartElement("stack-trace"); if(suiteResult.StackTrace != null) xmlWriter.WriteCData( EncodeCData( StackTraceFilter.Filter( suiteResult.StackTrace ) ) ); xmlWriter.WriteEndElement(); xmlWriter.WriteEndElement(); } xmlWriter.WriteStartElement("results"); foreach (TestResult result in suiteResult.Results) { result.Accept(this); } xmlWriter.WriteEndElement(); xmlWriter.WriteEndElement(); }
/// <summary> /// Trigger event when each suite finishes /// </summary> /// <param name="result">Result of the suite that finished</param> void EventListener.SuiteFinished(TestSuiteResult result) { events.FireSuiteFinished( result ); }
public override TestResult Run(EventListener listener, ITestFilter filter) { TestSuiteResult suite_result = new TestSuiteResult (new TestInfo (this), TestName.FullName); DebuggerTestHost host = DebuggerTestHost.Create (); if (host == null) { TestCaseResult error = new TestCaseResult (new TestInfo (this)); string msg = String.Format ("Failed to create DebuggerTestHost in {0}", FixtureType.Name); error.Failure (msg, null, FailureSite.Parent); suite_result.AddResult (error); return suite_result; } int timeout; if (Attribute.Timeout != 0) timeout = Attribute.Timeout; else timeout = DebuggerTestAddIn.DefaultTimeout; int repeat = 1; if (Attribute.Repeat != 0) repeat = Attribute.Repeat; try { for (int i = 0; i < repeat; i++) { if (!host.Run (new TestInfo (this), suite_result, Type.AssemblyQualifiedName, listener, filter, timeout)) break; } return suite_result; } finally { host.Dispose (); } }
public void SuiteFinished(TestSuiteResult result) { this.listener.SuiteFinished( result ); }
void EventListener.SuiteFinished(TestSuiteResult nunitResult)
public SuiteFinishedEvent( TestSuiteResult result ) { this.result = result; }
public void SuiteFinished(TestSuiteResult result){}
public void SuiteFinished (TestSuiteResult result) { testSuites.Pop (); wrapped.SuiteFinished (GetTestName (result.Test), GetLocalTestResult (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); } }
void CountResults (TestSuiteResult ts, ref int s, ref int f, ref int i) { if (ts.Results == null) return; foreach (TestResult t in ts.Results) { if (t is TestCaseResult) { if (t.IsFailure) f++; else if (!t.Executed) i++; else s++; } else if (t is TestSuiteResult) { CountResults ((TestSuiteResult) t, ref s, ref f, ref i); } } }
private void MarkTestsNotRun( IList tests, RunState runState, string ignoreReason, TestSuiteResult suiteResult, EventListener listener, ITestFilter filter) { foreach (Test test in ArrayList.Synchronized(tests)) { if (filter.Pass(test)) MarkTestNotRun(test, runState, ignoreReason, suiteResult, listener, filter); } }
public bool Run(TestInfo test, TestSuiteResult suite_result, string test_name, EventListener listener, ITestFilter filter, int timeout) { listener = new ProxyListener (listener); TestRunnerDelegate runner = new TestRunnerDelegate (delegate { return server.Run (test_name, listener, filter); }); IAsyncResult ar = runner.BeginInvoke (test_name, null, filter, null, null); if (!ar.AsyncWaitHandle.WaitOne (timeout) || !ar.IsCompleted) { TestCaseResult error = new TestCaseResult (test); string msg = String.Format ("Timeout after {0} ms", timeout); error.Failure (msg, null, FailureSite.Parent); suite_result.AddResult (error); return false; } try { TestResult result = runner.EndInvoke (ar); if (result != null) { suite_result.AddResult (result); return true; } TestCaseResult error = new TestCaseResult (test); error.Failure ("Unknown error", null, FailureSite.Parent); suite_result.AddResult (error); return false; } catch (Exception ex) { TestCaseResult error = new TestCaseResult (test); string msg = String.Format ("Unknown exception: {0}", ex); error.Failure (msg, null, FailureSite.Parent); suite_result.AddResult (error); return false; } }
public virtual TestResult Run(EventListener listener, ITestFilter filter ) { // Save active listener for derived classes this.listener = listener; ITest[] tests = new ITest[runners.Length]; for( int index = 0; index < runners.Length; index++ ) tests[index] = runners[index].Test; this.listener.RunStarted( this.Test.TestName.Name, this.CountTestCases( filter ) ); this.listener.SuiteStarted( this.Test.TestName ); long startTime = DateTime.Now.Ticks; TestSuiteResult result = new TestSuiteResult( new TestInfo( testName, tests ), projectName ); result.RunState = RunState.Executed; foreach( TestRunner runner in runners ) result.Results.Add( runner.Run( this, filter ) ); long stopTime = DateTime.Now.Ticks; double time = ((double)(stopTime - startTime)) / (double)TimeSpan.TicksPerSecond; result.Time = time; this.listener.SuiteFinished( result ); this.listener.RunFinished( result ); this.testResult = result; return result; }
void NUnit.Core.EventListener.SuiteFinished(TestSuiteResult result) { listener.SuiteFinished( result ); events.FireSuiteFinished( result ); }