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));
}
public void ProcessNoException(TestResult testResult)
{
testResult.Failure(NoExceptionMessage(), null);
}
/// <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);
}
}
