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 );
}
