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