void Failure(Exception ex, FailureSite site)
{
var invocationException = ex as TargetInvocationException;
if(invocationException != null)
ex = invocationException.InnerException;
result.SetResult(ResultState.Failure, ex.Message, ex.StackTrace, site);
}
/// <summary>
/// Set the result of the test
/// </summary>
/// <param name="resultState">The ResultState to use in the result</param>
/// <param name="message">A message associated with the result state</param>
/// <param name="stackTrace">Stack trace giving the location of the command</param>
/// <param name="site">The FailureSite for any failure or error</param>
public void SetResult(ResultState resultState, string message, string stackTrace, FailureSite site)
{
this.resultState = resultState;
this.message = message;
this.stackTrace = stackTrace;
this.failureSite = site;
}
/// <summary>
/// Marks the result as an error due to an exception thrown
/// from the indicated FailureSite.
/// </summary>
/// <param name="exception">The exception that was caught</param>
/// <param name="failureSite">The site from which it was thrown</param>
public void Error(Exception exception, FailureSite failureSite)
{
this.runState = RunState.Executed;
this.resultState = ResultState.Error;
this.failureSite = failureSite;
string message = BuildMessage(exception);
string stackTrace = BuildStackTrace(exception);
if (failureSite == FailureSite.TearDown)
{
message = "TearDown : " + message;
stackTrace = "--TearDown" + Environment.NewLine + stackTrace;
if (this.messageString != null)
{
message = this.messageString + Environment.NewLine + message;
}
if (this.stackTrace != null)
{
stackTrace = this.stackTrace + Environment.NewLine + stackTrace;
}
}
this.messageString = message;
this.stackTrace = stackTrace;
}
/// <summary>
/// Set the result of the test
/// </summary>
/// <param name="resultState">The ResultState to use in the result</param>
/// <param name="reason">The reason the test was not run</param>
/// <param name="stackTrace">Stack trace giving the location of the command</param>
/// <param name="failureSite">The location of the failure, if any</param>
public void SetResult(ResultState resultState, string reason, string stackTrace, FailureSite failureSite)
{
if (failureSite == FailureSite.SetUp)
{
reason = "SetUp : " + reason;
}
else if (failureSite == FailureSite.TearDown)
{
reason = "TearDown : " + reason;
stackTrace = "--TearDown" + Environment.NewLine + stackTrace;
if (this.message != null)
{
reason = this.message + Environment.NewLine + reason;
}
if (this.stackTrace != null)
{
stackTrace = this.stackTrace + Environment.NewLine + stackTrace;
}
}
this.resultState = resultState;
this.message = reason;
this.stackTrace = stackTrace;
this.failureSite = failureSite;
}
/// <summary>
/// Set the test result based on the type of exception thrown
/// </summary>
/// <param name="ex">The exception that was thrown</param>
/// <param name="site">THe FailureSite to use in the result</param>
public void RecordException(Exception ex, FailureSite site)
{
if (ex is NUnitException)
{
ex = ex.InnerException;
}
if (ex is ResultStateException)
{
SetResult(((ResultStateException)ex).ResultState.WithSite(site),
ex.Message,
StackFilter.Filter(ex.StackTrace));
}
#if !PORTABLE
else if (ex is System.Threading.ThreadAbortException)
{
SetResult(ResultState.Cancelled.WithSite(site),
"Test cancelled by user",
ex.StackTrace);
}
#endif
else
{
SetResult(ResultState.Error.WithSite(site),
ExceptionHelper.BuildMessage(ex),
ExceptionHelper.BuildStackTrace(ex));
}
}
public ExceptionResult(Exception ex, FailureSite site)
{
ex = ValidateAndUnwrap(ex);
if (ex is ResultStateException)
{
ResultState = ((ResultStateException)ex).ResultState.WithSite(site);
Message = ex.Message;
StackTrace = StackFilter.DefaultFilter.Filter(ex.StackTrace);
}
#if !NETSTANDARD1_6
else if (ex is ThreadAbortException)
{
ResultState = ResultState.Cancelled.WithSite(site);
Message = "Test cancelled by user";
StackTrace = ex.StackTrace;
}
#endif
else
{
ResultState = ResultState.Error.WithSite(site);
Message = ExceptionHelper.BuildMessage(ex);
StackTrace = ExceptionHelper.BuildStackTrace(ex);
}
}
public ExceptionResult(Exception ex, FailureSite site)
{
ex = ValidateAndUnwrap(ex);
if (ex is ResultStateException)
{
ResultState = ((ResultStateException)ex).ResultState.WithSite(site);
Message = ex.GetMessageWithoutThrowing();
StackTrace = StackFilter.DefaultFilter.Filter(ex.GetStackTraceWithoutThrowing());
}
#if THREAD_ABORT
else if (ex is ThreadAbortException)
{
ResultState = ResultState.Cancelled.WithSite(site);
Message = "Test cancelled by user";
StackTrace = ex.GetStackTraceWithoutThrowing();
}
#endif
else
{
ResultState = ResultState.Error.WithSite(site);
Message = ExceptionHelper.BuildMessage(ex);
StackTrace = ExceptionHelper.BuildStackTrace(ex);
}
}
/// <summary>
/// Mark the test as a failure due to an
/// assertion having failed.
/// </summary>
/// <param name="message">Message to display</param>
/// <param name="stackTrace">Stack trace giving the location of the failure</param>
/// <param name="failureSite">The site of the failure</param>
public void Failure(string message, string stackTrace, FailureSite failureSite)
{
this.runState = RunState.Executed;
this.resultState = ResultState.Failure;
this.failureSite = failureSite;
this.messageString = message;
this.stackTrace = stackTrace;
}
public void StoreTestResult(TestResult result)
{
CurrentTestResultStatus = result.ResultState.Status;
CurrentTestResultLabel = result.ResultState.Label;
CurrentTestResultSite = result.ResultState.Site;
CurrentTestMessage = result.Message;
CurrentTestStrackTrace = result.StackTrace;
}
public void AddSiteToResult(TestStatus status, string label, FailureSite site)
{
var result = new ResultState(status, label).WithSite(site);
Assert.That(result.Status, Is.EqualTo(status));
Assert.That(result.Label, Is.EqualTo(label));
Assert.That(result.Site, Is.EqualTo(site));
}
public void Reset()
{
NextBeforeStepIndex = 0;
NextBeforeStepPc = 0;
NextAfterStepIndex = 0;
NextAfterStepPc = 0;
TestHasRun = false;
CurrentTestResultStatus = TestStatus.Inconclusive;
CurrentTestResultLabel = null;
CurrentTestResultSite = default(FailureSite);
CurrentTestMessage = null;
CurrentTestStrackTrace = null;
TestAfterStarted = false;
}
/// <summary>
/// Set the result of the test.
/// </summary>
/// <param name="resultState">The ResultState to use in the result</param>
/// <param name="ex">The exception that caused this result</param>
/// <param name="failureSite">The site at which an error or failure occured</param>
public void SetResult(ResultState resultState, Exception ex, FailureSite failureSite)
{
if (resultState == ResultState.Cancelled)
{
SetResult(resultState, "Test cancelled by user", BuildStackTrace(ex));
}
else if (resultState == ResultState.Error)
{
SetResult(resultState, BuildMessage(ex), BuildStackTrace(ex), failureSite);
}
else
{
SetResult(resultState, ex.Message, ex.StackTrace, failureSite);
}
}
/// <summary>
/// Set the test result based on the type of exception thrown
/// and the site of the Failure.
/// </summary>
/// <param name="ex">The exception that was thrown</param>
/// <param name="site">The FailureSite</param>
public override void RecordException(Exception ex, FailureSite site)
{
RecordException(ex);
if (site == FailureSite.SetUp)
{
switch (ResultState.Status)
{
case TestStatus.Skipped:
this.skipCount = this.test.TestCaseCount;
break;
case TestStatus.Failed:
this.failCount = this.test.TestCaseCount;
break;
}
}
}
/// <summary>
/// Set the test result based on the type of exception thrown
/// and the site of the Failure.
/// </summary>
/// <param name="ex">The exception that was thrown</param>
/// <param name="site">The FailureSite</param>
public override void RecordException(Exception ex, FailureSite site)
{
RecordException(ex);
if (site == FailureSite.SetUp)
{
switch (ResultState.Status)
{
case TestStatus.Skipped:
this.skipCount = this.test.TestCaseCount;
break;
case TestStatus.Failed:
this.failCount = this.test.TestCaseCount;
break;
}
}
}
public void RecordException(Exception ex, FailureSite site)
{
RecordException(ex);
if (site == FailureSite.SetUp)
{
switch (base.ResultState.Status)
{
case TestStatus.Skipped:
skipCount = test.TestCaseCount;
break;
case TestStatus.Failed:
failCount = test.TestCaseCount;
break;
case TestStatus.Passed:
break;
}
}
}
/// <summary>
/// Marks the result as an error due to an exception thrown
/// from the indicated FailureSite.
/// </summary>
/// <param name="exception">The exception that was caught</param>
/// <param name="failureSite">The site from which it was thrown</param>
public void Error(Exception exception, FailureSite failureSite)
{
SetResult(ResultState.Error, exception, failureSite);
//string message = BuildMessage(exception);
//string stackTrace = BuildStackTrace(exception);
//if (failureSite == FailureSite.TearDown)
//{
// message = "TearDown : " + message;
// stackTrace = "--TearDown" + Environment.NewLine + stackTrace;
// if (this.message != null)
// message = this.message + Environment.NewLine + message;
// if (this.stackTrace != null)
// stackTrace = this.stackTrace + Environment.NewLine + stackTrace;
//}
//SetResult( ResultState.Error, message, stackTrace );
//this.failureSite = failureSite;
}
/// <summary>
/// Set the result of the test.
/// </summary>
/// <param name="resultState">The ResultState to use in the result</param>
/// <param name="ex">The exception that caused this result</param>
public void SetResult(ResultState resultState, Exception ex, FailureSite failureSite)
{
if (resultState == ResultState.Cancelled)
SetResult(resultState, "Test cancelled by user", BuildStackTrace(ex));
else if (resultState == ResultState.Error)
SetResult( resultState, BuildMessage(ex), BuildStackTrace(ex), failureSite);
else
SetResult(resultState, ex.Message, ex.StackTrace, failureSite);
}
/// <summary>
/// Set the test result based on the type of exception thrown
/// and the site of the Failure.
/// </summary>
/// <param name="ex">The exception that was thrown</param>
/// <param name="site">The FailureSite</param>
public virtual void RecordException(Exception ex, FailureSite site)
{
RecordException(ex);
}
/// <summary>
/// Set the result of the test
/// </summary>
/// <param name="resultState">The ResultState to use in the result</param>
/// <param name="reason">The reason the test was not run</param>
/// <param name="stackTrace">Stack trace giving the location of the command</param>
/// <param name="failureSite">The location of the failure, if any</param>
public void SetResult(ResultState resultState, string reason, string stack, FailureSite failureSite)
{
if (failureSite == FailureSite.SetUp)
reason = "SetUp : " + reason;
else if (failureSite == FailureSite.TearDown)
{
reason = "TearDown : " + reason;
stack = "--TearDown" + Environment.NewLine + stack;
if (this.message != null)
reason = this.message + Environment.NewLine + reason;
if (this.stackTrace != null)
stack = this.stackTrace + Environment.NewLine + stack;
}
this.resultState = resultState;
this.message = reason;
this.stackTrace = stack;
this.failureSite = failureSite;
}
/// <summary>
/// Marks the result as an error due to an exception thrown
/// from the indicated FailureSite.
/// </summary>
/// <param name="exception">The exception that was caught</param>
/// <param name="failureSite">The site from which it was thrown</param>
public void Error( Exception exception, FailureSite failureSite )
{
this.runState = RunState.Executed;
this.resultState = ResultState.Error;
this.failureSite = failureSite;
string message = BuildMessage(exception);
string stackTrace = BuildStackTrace(exception);
if (failureSite == FailureSite.TearDown)
{
message = "TearDown : " + message;
stackTrace = "--TearDown" + Environment.NewLine + stackTrace;
if (this.messageString != null)
message = this.messageString + Environment.NewLine + message;
if (this.stackTrace != null)
stackTrace = this.stackTrace + Environment.NewLine + stackTrace;
}
this.messageString = message;
this.stackTrace = stackTrace;
}
public void RecordException(Exception ex, FailureSite site)
{
var result = new ExceptionResult(ex, site);
SetResult(result.ResultState, result.Message, result.StackTrace);
}
public void Site_ConstructorWithThreeArguments_ReturnsSite(string label, FailureSite site)
{
ResultState resultState = new ResultState(TestStatus.Failed, label, site);
Assert.AreEqual(site, resultState.Site);
}
private static XmlNode CreateResultXml(string element, string testName, string result, FailureSite site)
{
var xmlNode = CreateResultXml(element, testName, result);
xmlNode.AddAttribute("site", site.ToString());
return(xmlNode);
}
/// <summary>
/// Mark the test as a failure due to an
/// assertion having failed.
/// </summary>
/// <param name="message">Message to display</param>
/// <param name="stackTrace">Stack trace giving the location of the failure</param>
/// <param name="failureSite">The site of the failure</param>
public void Failure(string message, string stackTrace, FailureSite failureSite )
{
this.runState = RunState.Executed;
this.resultState = ResultState.Failure;
this.failureSite = failureSite;
this.messageString = message;
this.stackTrace = stackTrace;
}
/// <summary>
/// Mark the test as a failure due to an
/// assertion having failed.
/// </summary>
/// <param name="message">Message to display</param>
/// <param name="stackTrace">Stack trace giving the location of the failure</param>
/// <param name="failureSite">The site of the failure</param>
public void Failure(string message, string stackTrace, FailureSite failureSite)
{
SetResult(Core.ResultState.Failure, message, stackTrace);
this.failureSite = failureSite;
}
/// <summary>
/// Get a new ResultState, which is the same as the current
/// one but with the FailureSite set to the specified value.
/// </summary>
/// <param name="site">The FailureSite to use</param>
/// <returns>A new ResultState</returns>
public ResultState WithSite(FailureSite site)
{
return(new ResultState(this.Status, this.Label, site));
}
protected override void RecordException(Exception exception, TestResult testResult, FailureSite failureSite)
{
this._screenCapture.TakeAndSave(this._screenCapture.GetEtapScreenshotPath(this.TestName.FullName));
base.RecordException(exception, testResult, failureSite);
}
protected virtual void RecordException(Exception exception, TestResult testResult, FailureSite failureSite)
{
if (exception is NUnitException)
{
exception = exception.InnerException;
}
testResult.SetResult(NUnitFramework.GetResultState(exception), exception, failureSite);
}
protected override void RecordException(Exception exception, TestResult testResult, FailureSite failureSite)
{
this._screenCapture.TakeAndSave(this._screenCapture.GetEtapScreenshotPath(this.TestName.FullName));
base.RecordException(exception, testResult, failureSite);
}
public void AddSiteToResult(TestStatus status, string label, FailureSite site)
{
var result = new ResultState(status, label).WithSite(site);
Assert.That(result.Status, Is.EqualTo(status));
Assert.That(result.Label, Is.EqualTo(label));
Assert.That(result.Site, Is.EqualTo(site));
}
public static void Error(TestResult testResult, Exception exception, IEnumerable<string> traceMessages, FailureSite failureSite = FailureSite.Test)
{
traceMessages = traceMessages ?? new List<string>();
testResult.SetResult(ResultState.Error, BuildMessage(exception), BuildStackTrace(exception, testResult.Test, traceMessages), failureSite);
}
protected void FireSuiteFinishedEvent(string testName, string result, FailureSite site)
{
FireSuiteFinishedEvent(CreateResultNode("test-suite", testName, result, site));
}
/// <summary>
/// Initializes a new instance of the <see cref="ResultState"/> class.
/// </summary>
/// <param name="status">The TestStatus.</param>
/// <param name="site">The stage at which the result was produced</param>
public ResultState(TestStatus status, FailureSite site)
: this(status, string.Empty, site)
{
}
public void WhenTestSuiteFinishes_FailuresAndErrorsAreDisplayed(string resultState, FailureSite site, bool shouldDisplay)
{
FireSuiteFinishedEvent("MyTest", resultState, site);
VerifyDisplay(shouldDisplay);
}
/// <summary>
/// Initializes a new instance of the <see cref="ResultState"/> class.
/// </summary>
/// <param name="status">The TestStatus.</param>
/// <param name="label">The label.</param>
/// <param name="site">The stage at which the result was produced</param>
public ResultState(TestStatus status, string label, FailureSite site)
{
Status = status;
Label = label == null ? string.Empty : label;
Site = site;
}
/// <summary>
/// Get a new ResultState, which is the same as the current
/// one but with the FailureSite set to the specified value.
/// </summary>
/// <param name="site">The FailureSite to use</param>
/// <returns>A new ResultState</returns>
public ResultState WithSite(FailureSite site)
{
return new ResultState(this.Status, this.Label, site);
}
private static ResultNode CreateResultNode(string element, string testName, string result, FailureSite site)
{
return(new ResultNode(CreateResultXml(element, testName, result, site)));
}
protected virtual void RecordException( Exception exception, TestResult testResult, FailureSite failureSite )
{
if (exception is NUnitException)
exception = exception.InnerException;
// Ensure that once a test is cancelled, it stays cancelled
ResultState finalResultState = testResult.ResultState == ResultState.Cancelled
? ResultState.Cancelled
: NUnitFramework.GetResultState(exception);
testResult.SetResult(finalResultState, exception, failureSite);
}
/// <summary>
/// Set the test result based on the type of exception thrown
/// </summary>
/// <param name="ex">The exception that was thrown</param>
/// <param name="site">THe FailureSite to use in the result</param>
public void RecordException(Exception ex, FailureSite site)
{
if (ex is NUnitException)
ex = ex.InnerException;
if (ex is ResultStateException)
SetResult(((ResultStateException)ex).ResultState.WithSite(site),
ex.Message,
StackFilter.Filter(ex.StackTrace));
#if !PORTABLE
else if (ex is System.Threading.ThreadAbortException)
SetResult(ResultState.Cancelled.WithSite(site),
"Test cancelled by user",
ex.StackTrace);
#endif
else
SetResult(ResultState.Error.WithSite(site),
ExceptionHelper.BuildMessage(ex),
ExceptionHelper.BuildStackTrace(ex));
}
/// <summary>
/// Marks the result as an error due to an exception thrown
/// from the indicated FailureSite.
/// </summary>
/// <param name="exception">The exception that was caught</param>
/// <param name="failureSite">The site from which it was thrown</param>
public void Error( Exception exception, FailureSite failureSite )
{
SetResult(ResultState.Error, exception, failureSite);
//string message = BuildMessage(exception);
//string stackTrace = BuildStackTrace(exception);
//if (failureSite == FailureSite.TearDown)
//{
// message = "TearDown : " + message;
// stackTrace = "--TearDown" + Environment.NewLine + stackTrace;
// if (this.message != null)
// message = this.message + Environment.NewLine + message;
// if (this.stackTrace != null)
// stackTrace = this.stackTrace + Environment.NewLine + stackTrace;
//}
//SetResult( ResultState.Error, message, stackTrace );
//this.failureSite = failureSite;
}
public void Site_ConstructorWithThreeArguments_ReturnsSite(string label, FailureSite site)
{
ResultState resultState = new ResultState(TestStatus.Failed, label, site);
Assert.AreEqual(site, resultState.Site);
}
/// <summary>
/// Mark the test as a failure due to an
/// assertion having failed.
/// </summary>
/// <param name="message">Message to display</param>
/// <param name="stackTrace">Stack trace giving the location of the failure</param>
/// <param name="failureSite">The site of the failure</param>
public void Failure(string message, string stackTrace, FailureSite failureSite )
{
SetResult( Core.ResultState.Failure, message, stackTrace );
this.failureSite = failureSite;
}
/// <summary>
/// Initializes a new instance of the <see cref="ResultState"/> class.
/// </summary>
/// <param name="status">The TestStatus.</param>
/// <param name="site">The stage at which the result was produced</param>
public ResultState(TestStatus status, FailureSite site) : this(status, string.Empty, site)
{
}
protected virtual void RecordException( Exception exception, TestResult testResult, FailureSite failureSite )
{
if (exception is NUnitException)
exception = exception.InnerException;
testResult.SetResult(NUnitFramework.GetResultState(exception), exception, failureSite);
}
protected virtual void RecordException( Exception exception, TestResult testResult, FailureSite failureSite )
{
if (exception is NUnitException)
exception = exception.InnerException;
// Ensure that once a test is cancelled, it stays cancelled
ResultState finalResultState = testResult.ResultState == ResultState.Cancelled
? ResultState.Cancelled
: NUnitFramework.GetResultState(exception);
testResult.SetResult(finalResultState, exception, failureSite);
}
/// <summary>
/// Initializes a new instance of the <see cref="ResultState"/> class.
/// </summary>
/// <param name="status">The TestStatus.</param>
/// <param name="label">The label.</param>
/// <param name="site">The stage at which the result was produced</param>
public ResultState(TestStatus status, string label, FailureSite site)
{
Status = status;
Label = label == null ? string.Empty : label;
Site = site;
}
