public void OmitsGenericOverloadedMethodsAppropriately()
{
string trace = null;
try
{
ThrowGenericOverload <int>();
Assert.Fail();
}
catch (InvalidOperationException ex)
{
trace = StackTraceFilter.FilterException(ex).ToString();
TestLog.WriteLine(trace);
}
Assert.Contains(trace, "OmitsGenericOverloadedMethodsAppropriately");
Assert.IsFalse(trace.Contains("ThrowGenericOverload"), "Should exclude the overload that lacks a debugger hidden");
try
{
ThrowGenericOverload <int, string>();
Assert.Fail();
}
catch (InvalidOperationException ex)
{
trace = StackTraceFilter.FilterException(ex).ToString();
TestLog.WriteLine(trace);
}
Assert.Contains(trace, "OmitsGenericOverloadedMethodsAppropriately");
Assert.IsTrue(trace.Contains("ThrowGenericOverload"), "Should include the overload that lacks a debugger hidden");
}
public void TestFinished(TestResult testResult)
{
switch (testResult.ResultState)
{
case ResultState.Error:
case ResultState.Failure:
case ResultState.Cancelled:
testRunCount++;
failureCount++;
if (progress)
{
Console.Write("F");
}
messages.Add(string.Format("{0}) {1} :", failureCount, testResult.Test.TestName.FullName));
messages.Add(testResult.Message.Trim(Environment.NewLine.ToCharArray()));
string stackTrace = StackTraceFilter.Filter(testResult.StackTrace);
if (stackTrace != null && stackTrace != string.Empty)
{
string[] trace = stackTrace.Split(System.Environment.NewLine.ToCharArray());
foreach (string s in trace)
{
if (s != string.Empty)
{
string link = Regex.Replace(s.Trim(), @".* in (.*):line (.*)", "$1($2)");
messages.Add(string.Format("at\n{0}", link));
}
}
}
break;
case ResultState.Inconclusive:
case ResultState.Success:
testRunCount++;
break;
case ResultState.Ignored:
case ResultState.Skipped:
case ResultState.NotRunnable:
testIgnoreCount++;
if (progress)
{
Console.Write("N");
}
break;
}
currentTestName = string.Empty;
if (writeResults)
{
WriteTestResult(testResult);
}
}
private StackTraceData GetStackTraceOrDefault()
{
if (isStackTraceSet)
{
return(stackTrace);
}
return(new StackTraceData(StackTraceFilter.CaptureFilteredStackTrace()));
}
/// <summary>
/// Writes an exception within its own section which provides additional cues for interpretation.
/// </summary>
/// <remarks>
/// <para>
/// The exception will not be terminated by a new line.
/// </para>
/// </remarks>
/// <param name="exception">The exception data to write.</param>
/// <param name="sectionName">The section name, or null if none.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="exception"/> is null.</exception>
public void WriteException(ExceptionData exception, string sectionName)
{
if (exception == null)
{
throw new ArgumentNullException(@"exception");
}
using (sectionName != null ? BeginSection(sectionName) : null)
StackTraceFilter.FilterException(exception).WriteTo(this);
}
private void AppendDetails(StringBuilder str)
{
str.AppendLine(StackTraceFilter.FilterException(exception).ToString());
if (reporterStackTrace != null)
{
if (str[str.Length - 1] != '\n')
{
str.AppendLine();
}
str.AppendLine("Reported by: ").Append(StackTraceFilter.FilterStackTrace(reporterStackTrace));
}
}
/// <summary>
/// Adds an exception to the assertion failure.
/// </summary>
/// <param name="ex">The exception data to add.</param>
/// <returns>The builder, to allow for fluent method chaining.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="ex"/> is null.</exception>
public AssertionFailureBuilder AddException(ExceptionData ex)
{
if (ex == null)
{
throw new ArgumentNullException("ex");
}
if (exceptions == null)
{
exceptions = new List <ExceptionData>();
}
exceptions.Add(StackTraceFilter.FilterException(ex));
return(this);
}
public void TestFinished(TestCaseResult testResult)
{
if (testResult.Executed)
{
testRunCount++;
if (testResult.IsFailure)
{
failureCount++;
if (progress)
{
Console.Write("F");
}
messages.Add(string.Format("{0}) {1} :", failureCount, testResult.Test.TestName.FullName));
messages.Add(testResult.Message.Trim(Environment.NewLine.ToCharArray()));
string stackTrace = StackTraceFilter.Filter(testResult.StackTrace);
if (stackTrace != null && stackTrace != string.Empty)
{
string[] trace = stackTrace.Split(System.Environment.NewLine.ToCharArray());
foreach (string s in trace)
{
if (s != string.Empty)
{
string link = Regex.Replace(s.Trim(), @".* in (.*):line (.*)", "$1($2)");
messages.Add(string.Format("at\n{0}", link));
}
}
}
}
}
else
{
testIgnoreCount++;
if (progress)
{
Console.Write("N");
}
}
if (writeResults)
{
WriteTestResult(testResult);
}
currentTestName = string.Empty;
}
private void WriteSingleResult(XmlNode result)
{
string status = result.GetAttribute("label");
if (status == null)
{
status = result.GetAttribute("result");
}
string fullName = result.GetAttribute("fullname");
Console.WriteLine("{0}) {1} : {2}", ++reportIndex, status, fullName);
XmlNode failureNode = result.SelectSingleNode("failure");
if (failureNode != null)
{
XmlNode message = failureNode.SelectSingleNode("message");
XmlNode stacktrace = failureNode.SelectSingleNode("stack-trace");
if (message != null)
{
Console.WriteLine(message.InnerText);
}
if (stacktrace != null)
{
Console.WriteLine(status == "Failed"
? StackTraceFilter.Filter(stacktrace.InnerText)
: stacktrace.InnerText + Environment.NewLine);
}
//Console.WriteLine(stacktrace.InnerText + Environment.NewLine);
}
XmlNode reasonNode = result.SelectSingleNode("reason");
if (reasonNode != null)
{
XmlNode message = reasonNode.SelectSingleNode("message");
if (message != null)
{
Console.WriteLine(message.InnerText);
}
}
}
public void OmitsInternalGenericMethods()
{
string trace = null;
try
{
ThrowInternalGeneric <int>();
Assert.Fail();
}
catch (InvalidOperationException ex)
{
trace = StackTraceFilter.FilterException(ex).ToString();
TestLog.WriteLine(trace);
}
Assert.Contains(trace, "OmitsInternalGenericMethods");
Assert.IsFalse(trace.Contains("ThrowInternalGeneric"));
}
private static IEnumerable <TestRunners.Shared.Results.StackLine> getStackLines(TestResult testResult)
{
var stackLines = new List <TestRunners.Shared.Results.StackLine>();
string stackTrace = StackTraceFilter.Filter(testResult.StackTrace);
if (stackTrace != null && stackTrace != string.Empty)
{
string[] trace = stackTrace.Split(System.Environment.NewLine.ToCharArray());
foreach (string s in trace)
{
if (s != string.Empty)
{
stackLines.Add(new TestRunners.Shared.Results.StackLine(s));
}
}
}
return(stackLines);
}
public void OmitsDebuggerHiddenConstructors()
{
string trace = null;
try
{
new ThrowHiddenConstructor();
Assert.Fail();
}
catch (InvalidOperationException ex)
{
trace = StackTraceFilter.FilterException(ex).ToString();
TestLog.WriteLine(trace);
}
Assert.Contains(trace, "OmitsDebuggerHiddenConstructors");
Assert.IsFalse(trace.Contains("ThrowHiddenConstructor"));
}
public void OmitsDebuggerNonUserCodeMethods()
{
string trace = null;
try
{
ThrowNonUserCode();
Assert.Fail();
}
catch (InvalidOperationException ex)
{
trace = StackTraceFilter.FilterException(ex).ToString();
TestLog.WriteLine(trace);
}
Assert.Contains(trace, "OmitsDebuggerNonUserCodeMethods");
Assert.IsFalse(trace.Contains("ThrowNonUserCode"));
}
private void FormatStackTrace(NUnit.Core.TestResult testResult)
{
this.outWriter.WriteLine(string.Format("{0}) {1} :", this.s.FailureCount, testResult.Test.TestName.FullName));
this.outWriter.WriteLine(testResult.Message.Trim(Environment.NewLine.ToCharArray()));
string filteredStackTrace = StackTraceFilter.Filter(testResult.StackTrace);
if (filteredStackTrace != null && filteredStackTrace != string.Empty)
{
foreach (string stackTraceLines in filteredStackTrace.Split(Environment.NewLine.ToCharArray()))
{
if (stackTraceLines != string.Empty)
{
this.outWriter.WriteLine(string.Format("at\n{0}",
Regex.Replace(stackTraceLines.Trim(), ".* in (.*):line (.*)", "$1($2)")));
}
}
}
}
/// <summary>
/// Writes a single test result to the output result file.
/// </summary>
void WriteTestResult(TestCaseResult testResult)
{
testResultWriter.WriteLine("Name: " + testResult.Name);
if (testResult.IsFailure)
{
testResultWriter.WriteLine("Result: Failure");
testResultWriter.WriteLine("Message: " + EncodeText(testResult.Message));
testResultWriter.WriteLine("StackTrace: " + EncodeText(StackTraceFilter.Filter(testResult.StackTrace)));
}
else if (!testResult.Executed)
{
testResultWriter.WriteLine("Result: Ignored");
}
else if (testResult.IsSuccess)
{
testResultWriter.WriteLine("Result: Success");
}
}
public void CutsOffAtTestEntryPoint()
{
string trace = null;
try
{
ThrowProxy();
Assert.Fail();
}
catch (InvalidOperationException ex)
{
trace = StackTraceFilter.FilterException(ex).ToString();
TestLog.WriteLine(trace);
}
Assert.IsFalse(trace.Contains("CutsOffAtTestEntryPoint"));
Assert.Contains(trace, "ThrowProxy");
Assert.IsFalse(trace.Contains("ThrowInternal"));
}
private void WriteSingleResult(TestResult result)
{
string status = result.IsFailure || result.IsError
? string.Format("{0} {1}", result.FailureSite, result.ResultState)
: result.ResultState.ToString();
Console.WriteLine("{0}) {1} : {2}", ++reportIndex, status, result.FullName);
if (result.Message != null && result.Message != string.Empty)
{
Console.WriteLine(" {0}", result.Message);
}
if (result.StackTrace != null && result.StackTrace != string.Empty)
{
Console.WriteLine(result.IsFailure
? StackTraceFilter.Filter(result.StackTrace)
: result.StackTrace + Environment.NewLine);
}
}
private void ReportTestFailureInfo(TestCaseResult testResult)
{
Trace.WriteLine(string.Format("###TEST FAILURE! {0}) {1} :", m_testProgressInfo.FailureCount, testResult.Test.TestName.FullName));
Trace.WriteLine(testResult.Message.Trim(Environment.NewLine.ToCharArray()));
string strStackTrace = StackTraceFilter.Filter(testResult.StackTrace);
if (strStackTrace != null && strStackTrace != string.Empty)
{
string[] trace = strStackTrace.Split(System.Environment.NewLine.ToCharArray());
foreach (string s in trace)
{
if (s != string.Empty)
{
string link = Regex.Replace(s.Trim(), @".* in (.*):line (.*)", "$1($2)");
Trace.WriteLine(string.Format("at\n{0}", link));
}
}
}
}
private static void LogMessage(MarkupDocumentWriter markupDocumentWriter, string actionDescription, TestOutcome outcome, string message, Exception ex)
{
if (string.IsNullOrEmpty(message) && ex == null)
{
return;
}
MarkupStreamWriter stream = GetLogStreamWriterForOutcome(markupDocumentWriter, outcome);
using (actionDescription != null ? stream.BeginSection(actionDescription) : null)
{
if (!string.IsNullOrEmpty(message))
{
stream.WriteLine(message);
}
if (ex != null)
{
stream.WriteException(StackTraceFilter.FilterException(ex));
}
}
}
public void FilterStackTraceToStringThrowsIfNull()
{
StackTraceFilter.FilterStackTraceToString(null);
}
public void TestFinished(TestResult testResult)
{
if (testResult.Test.ClassName != null && !describes.Contains(testResult.Test.ClassName))
{
Display.Write("describe", testResult.Test.ClassName);
describes.Add(testResult.Test.ClassName);
}
if (String.IsNullOrEmpty(testResult.Description))
{
if (testResult.Test.MethodName != null)
{
Display.Write("IT", testResult.Test.MethodName);
}
}
else
{
Display.Write("IT", testResult.Description);
}
foreach (string category in testResult.Test.Categories)
{
Display.Prop("tag", category);
}
foreach (string key in testResult.Test.Properties.Keys)
{
if (!key.StartsWith("_", StringComparison.InvariantCulture))
{
Display.Prop(key, testResult.Test.Properties[key].ToString());
}
}
string stackTrace = testResult.StackTrace != null?StackTraceFilter.Filter(testResult.StackTrace).Trim() : null;
if (String.IsNullOrEmpty(stackTrace))
{
stackTrace = testResult.StackTrace;
}
Console.Write(outputWriter.ToString());
if (testResult.IsSuccess)
{
Display.Passed(testResult.Message == null ? "Test Passed" : testResult.Message);
testRunCount++;
}
else if (testResult.IsFailure)
{
testRunCount++;
failureCount++;
if (testResult.Results != null)
{
Console.WriteLine(testResult.Results.Count);
}
if (testResult.AssertCount > 1)
{
Display.Log(String.Format("{0} passed", AssertionsName(testResult.AssertCount - 1)));
}
Display.Failed(testResult.Message);
//Display.Serialize(testResult, label: "-Test Result Info");
Display.Log(testResult.StackTrace, label: "-Stack Trace");
}
else if (testResult.IsError)
{
Display.Error(testResult.Message);
//Display.Serialize(testResult, label: "-Test Result Info");
Display.Log(stackTrace, mode: "ESC", label: "Stack Trace");
}
Console.WriteLine(String.Format("<COMPLETEDIN::>{0}", testResult.Time));
currentTestName = string.Empty;
}
public UnhandledLogMessageException(LogEvent log)
: base(BuildMessage(log))
{
LogEvent = log;
m_CustomStackTrace = StackTraceFilter.Filter(log.StackTrace);
}
private string CaptureOverload(int dummy1, string dummy2)
{
return(StackTraceFilter.CaptureFilteredStackTrace());
}
private string CaptureHidden()
{
return(StackTraceFilter.CaptureFilteredStackTrace());
}
private string CaptureGenericOverload <S, T>()
{
return(StackTraceFilter.CaptureFilteredStackTrace());
}
private string CaptureInternal()
{
return(StackTraceFilter.CaptureFilteredStackTrace());
}
public CaptureHiddenConstructor()
{
Trace = StackTraceFilter.CaptureFilteredStackTrace();
}
public void FilterStackTraceThrowsIfNull()
{
StackTraceFilter.FilterStackTrace(null);
}
public void FilterExceptionDataThrowsIfNull()
{
StackTraceFilter.FilterException((ExceptionData)null);
}
