/// <summary>
/// Overridden to run the teardown methods specified on the test.
/// </summary>
/// <param name="context">The TestExecutionContext to be used.</param>
/// <returns>A TestResult</returns>
public override TestResult Execute(TestExecutionContext context)
{
TestResult suiteResult = context.CurrentResult;
if (fixtureType != null)
{
MethodInfo[] teardownMethods =
Reflect.GetMethodsWithAttribute(fixtureType, typeof(TestFixtureTearDownAttribute), true);
try
{
int index = teardownMethods.Length;
while (--index >= 0)
{
MethodInfo fixtureTearDown = teardownMethods[index];
if (!fixtureTearDown.IsStatic && context.TestObject == null)
{
Console.WriteLine("TestObject should not be null!!!");
}
Reflect.InvokeMethod(fixtureTearDown, fixtureTearDown.IsStatic ? null : context.TestObject);
}
IDisposable disposable = context.TestObject as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
catch (Exception ex)
{
// Error in TestFixtureTearDown or Dispose causes the
// suite to be marked as a error, even if
// all the contained tests passed.
NUnitException nex = ex as NUnitException;
if (nex != null)
{
ex = nex.InnerException;
}
// TODO: Can we move this logic into TestResult itself?
string message = "TearDown : " + ExceptionHelper.BuildMessage(ex);
if (suiteResult.Message != null)
{
message = suiteResult.Message + NUnit.Env.NewLine + message;
}
string stackTrace = "--TearDown" + NUnit.Env.NewLine + ExceptionHelper.BuildStackTrace(ex);
if (suiteResult.StackTrace != null)
{
stackTrace = suiteResult.StackTrace + NUnit.Env.NewLine + stackTrace;
}
// TODO: What about ignore exceptions in teardown?
suiteResult.SetResult(ResultState.Error, message, stackTrace);
}
}
return(suiteResult);
}
/// <summary>
/// Does the one time tear down for a suite command.
/// </summary>
/// <param name="context">The execution context to use in running the test.</param>
public virtual void DoOneTimeTearDown(TestExecutionContext context)
{
if (fixtureType != null)
{
TestSuiteResult suiteResult = context.CurrentResult as TestSuiteResult;
try
{
if (suite.OneTimeTearDownMethods != null)
{
int index = suite.OneTimeTearDownMethods.Length;
while (--index >= 0)
{
MethodInfo fixtureTearDown = suite.OneTimeTearDownMethods[index];
Reflect.InvokeMethod(fixtureTearDown, fixtureTearDown.IsStatic ? null : context.TestObject);
}
}
IDisposable disposable = context.TestObject as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
catch (Exception ex)
{
// Error in TestFixtureTearDown or Dispose causes the
// suite to be marked as a error, even if
// all the contained tests passed.
NUnitException nex = ex as NUnitException;
if (nex != null)
{
ex = nex.InnerException;
}
// TODO: Can we move this logic into TestResult itself?
string message = "TearDown : " + ExceptionHelper.BuildMessage(ex);
if (suiteResult.Message != null)
{
message = suiteResult.Message + NUnit.Env.NewLine + message;
}
#if !NETCF_1_0
string stackTrace = "--TearDown" + NUnit.Env.NewLine + ExceptionHelper.BuildStackTrace(ex);
if (suiteResult.StackTrace != null)
{
stackTrace = suiteResult.StackTrace + NUnit.Env.NewLine + stackTrace;
}
// TODO: What about ignore exceptions in teardown?
suiteResult.SetResult(ResultState.Error, message, stackTrace);
#else
Result.SetResult(ResultState.Error, message);
#endif
}
}
}
protected override void DoOneTimeTearDown(TestResult suiteResult)
{
try
{
_testContext.FixtureContext.GlobalSetupManager.Cleanup(_testContext.Position);
}
catch (Exception innerException)
{
NUnitException exception2 = innerException as NUnitException;
if (exception2 != null)
{
innerException = exception2.InnerException;
}
var shim = new TestResultShim();
TestResultUtil.Error(shim, suiteResult.Test.GetMultilineName(), innerException, null, TestResultShim.Site.TearDown);
NativeTestResult.ApplyToNunitResult(shim, suiteResult);
}
}
public virtual void DoOneTimeTearDown(TestExecutionContext context)
{
if (fixtureType == null)
{
return;
}
TestSuiteResult testSuiteResult = context.CurrentResult as TestSuiteResult;
try
{
if (suite.OneTimeTearDownMethods != null)
{
int num = suite.OneTimeTearDownMethods.Length;
while (--num >= 0)
{
MethodInfo methodInfo = suite.OneTimeTearDownMethods[num];
Reflect.InvokeMethod(methodInfo, methodInfo.IsStatic ? null : context.TestObject);
}
}
(context.TestObject as IDisposable)?.Dispose();
}
catch (Exception innerException)
{
NUnitException ex = innerException as NUnitException;
if (ex != null)
{
innerException = ex.InnerException;
}
string text = "TearDown : " + ExceptionHelper.BuildMessage(innerException);
if (testSuiteResult.Message != null)
{
text = testSuiteResult.Message + Env.NewLine + text;
}
string text2 = "--TearDown" + Env.NewLine + ExceptionHelper.BuildStackTrace(innerException);
if (testSuiteResult.StackTrace != null)
{
text2 = testSuiteResult.StackTrace + Env.NewLine + text2;
}
testSuiteResult.SetResult(ResultState.Error, text, text2);
}
}
private static bool HandleException(Type fixtureType, Object instance, MethodInfo method, NUnitException e)
{
var caught = false;
foreach (var field in from f in fixtureType.GetFields(
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance)
where f.FieldType.IsInstanceOfType(e.InnerException) &&
f.GetCustomAttributes(typeof(CatchException), true).OfType <CatchException>()
.Any(a => (a.ThrownFrom ?? fixtureType) == method.ReflectedType)
select f)
{
caught = true;
if (instance == null && !field.IsStatic)
{
throw new InvalidTestFixtureException(
string.Format("When you have nested-tests, [CatchException] field must be made static: {0}", field));
}
field.SetValue(instance, e.InnerException);
}
if (fixtureType != method.ReflectedType)
{
caught |= HandleException(fixtureType.DeclaringType, null, method, e);
}
return(caught);
}
