public void RecordException(Exception ex)
{
if (ex is AssertionException)
#if NETCF_1_0
{ this.Failure(ex.Message); }
#else
{ this.Failure(ex.Message, StackFilter.Filter(ex.StackTrace)); }
private void WriteSingleResult(ITestResult result)
{
writer.WriteLine();
writer.WriteLine("{0}) {1} ({2})", ++reportCount, result.Name, result.FullName);
if (result.Message != null && result.Message != string.Empty)
{
writer.WriteLine(" {0}", result.Message);
}
if (result.StackTrace != null && result.StackTrace != string.Empty)
{
writer.WriteLine(result.ResultState == ResultState.Failure
? StackFilter.Filter(result.StackTrace)
: result.StackTrace + NUnit.Env.NewLine);
}
}
public static void RecordPrefixedException(this TestResult testResult, string prefix, Exception ex, ResultState resultState = null)
{
if (ex is NUnitException)
{
ex = ex.InnerException;
}
if (resultState == null)
{
resultState = testResult.ResultState == ResultState.Cancelled
? ResultState.Cancelled
: ResultState.Error;
}
var exceptionMessage = ExceptionHelper.BuildMessage(ex);
string stackTrace = "--" + prefix + NUnit.Env.NewLine + ExceptionHelper.BuildStackTrace(ex);
if (testResult.StackTrace != null)
{
stackTrace = testResult.StackTrace + NUnit.Env.NewLine + stackTrace;
}
if (testResult.Test.IsSuite)
{
resultState = resultState.WithSite(FailureSite.TearDown);
}
if (ex is ResultStateException)
{
exceptionMessage = ex.Message;
resultState = ((ResultStateException)ex).ResultState;
stackTrace = StackFilter.Filter(ex.StackTrace);
}
string message = (string.IsNullOrEmpty(prefix) ? "" : (prefix + " : ")) + exceptionMessage;
if (testResult.Message != null)
{
message = testResult.Message + NUnit.Env.NewLine + message;
}
testResult.SetResult(resultState, message, stackTrace);
}
private void SkipFixture(ResultState resultState, string message, string stackTrace)
{
Result.SetResult(resultState.WithSite(FailureSite.SetUp), message, StackFilter.Filter(stackTrace));
SkipChildren(_suite, resultState.WithSite(FailureSite.Parent), "OneTimeSetUp: " + message);
}
private static void PerformAssertWithConstraint <T>(IResolveConstraint constraint, object actual, Func <string> getExceptionMessage = null, string message = null, object[] args = null)
{
using (var messageWitter = new TextMessageWriter())
{
var resolveConstraint = constraint.Resolve();
TestExecutionContext.CurrentContext.IncrementAssertCount();
var result = actual is ActualValueDelegate <T>?resolveConstraint.ApplyTo <T>(actual as ActualValueDelegate <T>) : resolveConstraint.ApplyTo(actual);
var expectedValue = result.Description;
result.WriteActualValueTo(messageWitter);
var actualValue = messageWitter.ToString();
if (!result.IsSuccess)
{
if (IsSkipBug())
{
TestExecutionContext.CurrentContext.CurrentResult.RecordAssertion(AssertionStatus.Warning, "Triaged test case failure", StackFilter.DefaultFilter.Filter(SystemEnvironmentFilter.Filter(Environment.StackTrace)));
}
else
{
TestExecutionContext.CurrentContext.CurrentResult.RecordAssertion(AssertionStatus.Failed, message, StackFilter.DefaultFilter.Filter(SystemEnvironmentFilter.Filter(Environment.StackTrace)));
AssertionException exceptiopn = null;
if (getExceptionMessage != null)
{
exceptiopn = new AssertionException(getExceptionMessage());
}
else
{
using (var errorMessageWritter = new TextMessageWriter(message, args))
{
result.WriteMessageTo(errorMessageWritter);
exceptiopn = new AssertionException(errorMessageWritter.ToString());
}
}
LogHelper.LoggerForCurrentTest.Assert(FormatAssertFailMessage(getExceptionMessage, message, args), false, actual, expectedValue, actualValue, exceptiopn.ToString());
throw exceptiopn ?? new AssertionException($"Assert.That() failed.{Environment.NewLine} Expected {expectedValue}.{Environment.NewLine} Actual {actualValue}.");
}
}
if (IsSkipBug() && result.IsSuccess)
{
TestExecutionContext.CurrentContext.CurrentResult.RecordAssertion(AssertionStatus.Failed, "Test Cases Marked as Bug, but passed.", StackFilter.DefaultFilter.Filter(SystemEnvironmentFilter.Filter(Environment.StackTrace)));
LogHelper.LoggerForCurrentTest.Assert("Test Cases Marked as Bug, but passed.", false, actual, expectedValue, actualValue);
}
else
{
LogHelper.LoggerForCurrentTest.Assert("Asserting expression -- success.", true, actual, expectedValue, actualValue);
}
}
}
public void FilterLongTrace()
{
Assert.That(StackFilter.Filter(longTrace), Is.EqualTo(longTrace_Result));
}
public void FilterShortTraceWithAssume_Trace1()
{
Assert.That(StackFilter.Filter(shortTrace_Assume), Is.EqualTo(shortTrace_Result));
}
public static string GetStackTrace() => StackFilter.DefaultFilter.Filter(SystemEnvironmentFilter.Filter(Environment.StackTrace));
private string GetStackTrace()
{
return(StackFilter.DefaultFilter.Filter(SystemEnvironmentFilter.Filter(Environment.StackTrace)));
}
public void FilterFailureTrace2()
{
Assert.That(StackFilter.Filter(rawTrace2), Is.EqualTo(filteredTrace2));
}