private TestResult SkipTest()
{
TestResult testResult = new TestResult(this);
switch (this.RunState)
{
case RunState.Skipped:
default:
testResult.Skip(IgnoreReason);
break;
case RunState.NotRunnable:
if (BuilderException != null)
{
testResult.Invalid(BuilderException);
}
else
{
testResult.Invalid(IgnoreReason);
}
break;
case RunState.Ignored:
testResult.Ignore(IgnoreReason);
break;
}
return(testResult);
}
public override TestResult Run(EventListener listener, ITestFilter filter)
{
using (new TestContext())
{
TestResult testResult = new TestResult(this);
ContextDictionary context = Context;
context._testResult = testResult;
context["TestName"] = this.TestName.Name;
context["Properties"] = this.Properties;
CallContext.SetData("NUnit.Framework.TestContext", context);
log.Debug("Test Starting: " + this.TestName.FullName);
listener.TestStarted(this.TestName);
long startTime = DateTime.Now.Ticks;
switch (this.RunState)
{
case RunState.Runnable:
case RunState.Explicit:
Run(testResult);
break;
case RunState.Skipped:
default:
testResult.Skip(IgnoreReason);
break;
case RunState.NotRunnable:
if (BuilderException != null)
{
testResult.Invalid(BuilderException);
}
else
{
testResult.Invalid(IgnoreReason);
}
break;
case RunState.Ignored:
testResult.Ignore(IgnoreReason);
break;
}
long stopTime = DateTime.Now.Ticks;
double time = ((double)(stopTime - startTime)) / (double)TimeSpan.TicksPerSecond;
testResult.Time = time;
listener.TestFinished(testResult);
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);
}
}
}
public override TestResult Run(EventListener listener, ITestFilter filter)
{
using (new global::NUnit.Core.TestContext())
{
var testResult = new TestResult(this);
Log.Debug("Test Starting: " + TestName.FullName);
listener.TestStarted(TestName);
var stopwatch = new Stopwatch();
stopwatch.Start();
switch (RunState)
{
case RunState.Runnable:
case RunState.Explicit:
DoTest(_test, testResult);
break;
case RunState.NotRunnable:
testResult.Invalid(IgnoreReason);
break;
case RunState.Ignored:
testResult.Ignore(IgnoreReason);
break;
default:
testResult.Skip(IgnoreReason);
break;
}
stopwatch.Stop();
testResult.Time = stopwatch.Elapsed.Seconds;
listener.TestFinished(testResult);
return testResult;
}
}
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;
}
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);
}
}
}
}
private TestResult SkipTest()
{
TestResult testResult = new TestResult(this);
switch (this.RunState)
{
case RunState.Skipped:
default:
testResult.Skip(IgnoreReason);
break;
case RunState.NotRunnable:
if (BuilderException != null)
testResult.Invalid(BuilderException);
else
testResult.Invalid(IgnoreReason);
break;
case RunState.Ignored:
testResult.Ignore(IgnoreReason);
break;
}
return testResult;
}
private void MarkAllTestsInvalid(TestResult suiteResult, EventListener listener, ITestFilter filter)
{
suiteResult.Invalid(this.IgnoreReason);
MarkTestsNotRun(this.Tests, ResultState.NotRunnable, this.IgnoreReason, suiteResult, listener, filter);
}
private void MarkAllTestsInvalid(TestResult suiteResult, EventListener listener, ITestFilter filter)
{
suiteResult.Invalid(this.IgnoreReason);
MarkTestsNotRun(this.Tests, ResultState.NotRunnable, this.IgnoreReason, suiteResult, listener, filter);
}
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);
}
}
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);
}
}
}
public override TestResult Run(EventListener listener, ITestFilter filter)
{
using (new TestContext())
{
TestResult testResult = new TestResult(this);
log.Debug("Test Starting: " + this.TestName.FullName);
listener.TestStarted(this.TestName);
long startTime = DateTime.Now.Ticks;
switch (this.RunState)
{
case RunState.Runnable:
case RunState.Explicit:
Run(testResult);
break;
case RunState.Skipped:
default:
testResult.Skip(IgnoreReason);
break;
case RunState.NotRunnable:
if (BuilderException != null)
testResult.Invalid(BuilderException);
else
testResult.Invalid(IgnoreReason);
break;
case RunState.Ignored:
testResult.Ignore(IgnoreReason);
break;
}
long stopTime = DateTime.Now.Ticks;
double time = ((double)(stopTime - startTime)) / (double)TimeSpan.TicksPerSecond;
testResult.Time = time;
listener.TestFinished(testResult);
return testResult;
}
}
/// <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);
}
}
}
}
}