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; } } }
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); }
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; }
/// <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; }
protected virtual void RecordException( Exception exception, TestResult testResult, FailureSite failureSite ) { if (exception is NUnitException) exception = exception.InnerException; testResult.SetResult(NUnitFramework.GetResultState(exception), exception, failureSite); }