async Task WriteXmlResultFile(ITestResult testResult)
{
const string OutputFolderName = "NUnitTestOutput";
const string OutputXmlReportName = "TestResults.xml";
var localStorageFolder = FileSystem.Current.LocalStorage;
var existResult = await localStorageFolder.CheckExistsAsync(OutputFolderName);
if (existResult == ExistenceCheckResult.FileExists)
{
var existingFile = await localStorageFolder.GetFileAsync(OutputFolderName);
await existingFile.DeleteAsync();
}
var outputFolder = await localStorageFolder.CreateFolderAsync(OutputFolderName, CreationCollisionOption.OpenIfExists);
IFile xmlResultFile = await outputFolder.CreateFileAsync(OutputXmlReportName, CreationCollisionOption.ReplaceExisting);
using (var resultFileStream = new StreamWriter(await xmlResultFile.OpenAsync(FileAccess.ReadAndWrite)))
{
string xmlString = testResult.ToXml(true).OuterXml;
await resultFileStream.WriteAsync(xmlString);
}
}
private static XmlNode ToXml(ITestResult testResult)
{
var doc = new XmlDocument();
doc.LoadXml("<foo />");
return(testResult.ToXml(doc.ChildNodes[0]));
}
internal RemoteTestResultData(ITestResult result, bool isTopLevel)
{
testId = result.Test.Id;
name = result.Name;
fullName = result.FullName;
resultState = result.ResultState.ToString();
testStatus = result.ResultState.Status;
duration = result.Duration;
startTime = result.StartTime;
endTime = result.EndTime;
message = result.Message;
stackTrace = result.StackTrace;
assertCount = result.AssertCount;
failCount = result.FailCount;
passCount = result.PassCount;
skipCount = result.SkipCount;
inconclusiveCount = result.InconclusiveCount;
hasChildren = result.HasChildren;
output = result.Output;
if (isTopLevel)
{
xml = result.ToXml(true).OuterXml;
}
childrenIds = result.Children.Select(child => child.Test.Id).ToArray();
}
public TNode ToXml()
{
if (m_Node == null)
{
m_Node = m_Result.ToXml(true);
}
return(m_Node);
}
private async Task WriteResult(ITestResult testResult)
{
using (var tcpWriter = new TcpWriter(Options.TcpWriterParameters))
{
await tcpWriter.Connect().ConfigureAwait(false);
tcpWriter.Write(testResult.ToXml(true).OuterXml);
}
}
private void WriteXmlResultOutput(ITestResult result, XmlWriter xmlWriter)
{
this.xmlWriter = xmlWriter;
InitializeXmlFile(result);
result.ToXml(true).WriteTo(xmlWriter);
TerminateXmlFile();
}
private void WriteXmlResultOutput(ITestResult result, XmlWriter xmlWriter)
{
this.xmlWriter = xmlWriter;
InitializeXmlFile(result);
result.ToXml(true).WriteTo(xmlWriter);
TerminateXmlFile();
}
/// <summary>
/// Called when a test has finished. Sends a result summary to the callback.
/// to
/// </summary>
/// <param name="result">The result of the test</param>
public void TestFinished(ITestResult result)
{
try
{
handler.RaiseCallbackEvent(result.ToXml(false).OuterXml);
}
catch (Exception ex)
{
log.Error("Exception processing " + result.FullName + NUnit.Env.NewLine + ex.ToString());
}
}
private void RunTests(ICallbackEventHandler handler, string filter)
{
Guard.ArgumentNotNull(filter, "filter");
ITestResult result = Runner.Run(new TestProgressReporter(handler), TestFilter.FromXml(filter));
// Ensure that the CallContext of the thread is not polluted
// by our TestExecutionContext, which is not serializable.
TestExecutionContext.ClearCurrentContext();
handler.RaiseCallbackEvent(result.ToXml(true).OuterXml);
}
static bool OnTestResult(ITestResult result, ExecutorCallback callback)
{
XmlDocument doc = new XmlDocument();
doc.LoadXml("<foo/>");
XmlNode node = result.ToXml(doc.ChildNodes[0]);
if (node != null)
callback.Notify(node.OuterXml);
return callback.ShouldContinue();
}
public void RunFinished(ITestResult testResults)
{
var path = Path.Combine(Application.persistentDataPath, TestResultFileName);
using (var xw = XmlWriter.Create(path, new XmlWriterSettings {
Indent = true
})) {
testResults.ToXml(true).WriteTo(xw);
}
System.Console.WriteLine($"***\n\nTEST RESULTS WRITTEN TO\n\n\t{path}\n\n***");
Application.Quit(testResults.FailCount > 0 ? 1 : 0);
}
private static void TryWriteToFile(ITestResult testResults)
{
try
{
var xml = testResults.ToXml(true).OuterXml;
var savePath = Path.Combine(Application.persistentDataPath, "PlayerWithTests-results.xml");
Debug.Log($"Saving results to {savePath}");
File.WriteAllText(savePath, xml);
}
catch (Exception e)
{
Debug.LogException(e);
}
}
/// <summary>
/// Called when a test has finished. Sends a result summary to the callback.
/// to
/// </summary>
/// <param name="result">The result of the test</param>
public void TestFinished(ITestResult result)
{
try
{
var node = result.ToXml(false);
var parent = GetParent(result.Test);
node.Attributes.Add("parentId", parent != null ? parent.Id : string.Empty);
handler.RaiseCallbackEvent(node.OuterXml);
}
catch (Exception ex)
{
log.Error("Exception processing " + result.FullName + NUnit.Env.NewLine + ex.ToString());
}
}
static bool OnTestResult(ITestResult result, ExecutorCallback callback)
{
XmlDocument doc = new XmlDocument();
doc.LoadXml("<foo/>");
XmlNode node = result.ToXml(doc.ChildNodes[0]);
if (node != null)
{
callback.Notify(node.OuterXml);
}
return(callback.ShouldContinue());
}
private void RunTests()
{
ITestResult result = runner.Run(TestListener.NULL, TestFilter.Empty);
ReportResults(result);
string resultFile = commandLineOptions.ResultFile;
if (resultFile != null)
{
XmlTextWriter resultWriter = new XmlTextWriter(resultFile, System.Text.Encoding.UTF8);
resultWriter.Formatting = Formatting.Indented;
result.ToXml(true).WriteTo(resultWriter);
resultWriter.Close();
}
}
public static void SaveXmlToFile(this ITestResult aTestResult, string aFilePath)
{
var xDocument = aTestResult.ToXml();
var xWriterSettings = new XmlWriterSettings()
{
Encoding = Encoding.UTF8,
Indent = true,
OmitXmlDeclaration = true
};
using (var xWriter = XmlWriter.Create(aFilePath, xWriterSettings))
{
xDocument.Save(xWriter);
}
}
static bool OnTestResult(ITestResult result, ICallbackEventHandler callback)
{
if (callback == null)
return true;
XmlDocument doc = new XmlDocument();
doc.LoadXml("<foo/>");
XmlNode node = result.ToXml(doc.ChildNodes[0]);
if (node != null)
callback.RaiseCallbackEvent(node.OuterXml);
return bool.Parse(callback.GetCallbackResult());
}
private void WriteXmlResultOutput(ITestResult result, XmlWriter xmlWriter, IDictionary<string, object> runSettings, TestFilter filter)
{
TNode resultNode = result.ToXml(true);
// Insert elements as first child in reverse order
if (runSettings != null) // Some platforms don't have settings
FrameworkController.InsertSettingsElement(resultNode, runSettings);
FrameworkController.InsertEnvironmentElement(resultNode);
TNode testRun = MakeTestRunElement(result);
testRun.ChildNodes.Add(MakeCommandLineElement());
testRun.ChildNodes.Add(MakeTestFilterElement(filter));
testRun.ChildNodes.Add(resultNode);
testRun.WriteTo(xmlWriter);
}
/// <summary>
/// Writes the test result to the specified TextWriter
/// </summary>
/// <param name="result">The result to be written to a file</param>
/// <param name="writer">A TextWriter to which the result is written</param>
public override void WriteResultFile(ITestResult result, TextWriter writer)
{
// NOTE: Under .NET 1.1, XmlTextWriter does not implement IDisposable,
// but does implement Close(). Hence we cannot use a 'using' clause.
//using (XmlTextWriter xmlWriter = new XmlTextWriter(writer))
XmlTextWriter xmlWriter = new XmlTextWriter(writer);
xmlWriter.Formatting = Formatting.Indented;
try
{
xmlWriter.WriteStartDocument(false);
result.ToXml(true).WriteTo(xmlWriter);
}
finally
{
xmlWriter.Close();
}
}
private void WriteXmlResultOutput(ITestResult result, XmlWriter xmlWriter, IDictionary <string, object> runSettings, TestFilter filter)
{
TNode resultNode = result.ToXml(true);
// Insert elements as first child in reverse order
if (runSettings != null) // Some platforms don't have settings
{
FrameworkController.InsertSettingsElement(resultNode, runSettings);
}
FrameworkController.InsertEnvironmentElement(resultNode);
TNode testRun = MakeTestRunElement(result);
testRun.ChildNodes.Add(MakeCommandLineElement());
testRun.ChildNodes.Add(MakeTestFilterElement(filter));
testRun.ChildNodes.Add(resultNode);
testRun.WriteTo(xmlWriter);
}
async Task WriteXmlResultFile(ITestResult testResult)
{
string outputFolderName = Path.GetDirectoryName(Options.ResultFilePath);
string outputXmlReportName = Path.GetFileName(Options.ResultFilePath);
await CreateFolderRecursive(outputFolderName);
IFolder outputFolder =
await FileSystem.Current.GetFolderFromPathAsync(outputFolderName, CancellationToken.None);
IFile xmlResultFile =
await outputFolder.CreateFileAsync(outputXmlReportName, CreationCollisionOption.ReplaceExisting);
using (var resultFileStream = new StreamWriter(await xmlResultFile.OpenAsync(FileAccess.ReadAndWrite)))
{
string xmlString = testResult.ToXml(true).OuterXml;
await resultFileStream.WriteAsync(xmlString);
}
}
/// <summary>
/// Writes the test result to the specified TextWriter
/// </summary>
/// <param name="result">The result to be written to a file</param>
/// <param name="writer">A TextWriter to which the result is written</param>
public override void WriteResultFile(ITestResult result, TextWriter writer)
{
// NOTE: Under .NET 1.1, XmlTextWriter does not implement IDisposable,
// but does implement Close(). Hence we cannot use a 'using' clause.
//using (XmlTextWriter xmlWriter = new XmlTextWriter(writer))
XmlTextWriter xmlWriter = new XmlTextWriter(writer);
xmlWriter.Formatting = Formatting.Indented;
try
{
xmlWriter.WriteStartDocument(false);
result.ToXml(true).WriteTo(xmlWriter);
}
finally
{
xmlWriter.Close();
}
}
private void RunTests(ICallbackEventHandler handler, string filter)
{
try
{
ITestResult result = Runner.Run(new TestProgressReporter(handler), TestFilter.FromXml(filter));
// Ensure that the CallContext of the thread is not polluted
// by our TestExecutionContext, which is not serializable.
TestExecutionContext.ClearCurrentContext();
handler.RaiseCallbackEvent(result.ToXml(true).OuterXml);
}
catch (Exception ex)
{
handler.RaiseCallbackEvent(FormatErrorReport(ex));
}
finally
{
//InternalTrace.Flush();
}
}
internal TestResultAdaptor(ITestResult result)
{
Test = new TestAdaptor(result.Test);
Name = result.Name;
FullName = result.FullName;
ResultState = result.ResultState.ToString();
TestStatus = ParseTestStatus(result.ResultState.Status);
Duration = result.Duration;
StartTime = result.StartTime;
EndTime = result.EndTime;
Message = result.Message;
StackTrace = result.StackTrace;
AssertCount = result.AssertCount;
FailCount = result.FailCount;
PassCount = result.PassCount;
SkipCount = result.SkipCount;
InconclusiveCount = result.InconclusiveCount;
HasChildren = result.HasChildren;
Output = result.Output;
Children = result.Children.Select(child => new TestResultAdaptor(child)).ToArray();
m_Node = result.ToXml(true);
}
internal TestResultAdaptor(ITestResult result, ITestAdaptor test, ITestResultAdaptor[] children = null)
{
Test = test;
Name = result.Name;
FullName = result.FullName;
ResultState = result.ResultState.ToString();
TestStatus = ParseTestStatus(result.ResultState.Status);
Duration = result.Duration;
StartTime = result.StartTime;
EndTime = result.EndTime;
Message = result.Message;
StackTrace = result.StackTrace;
AssertCount = result.AssertCount;
FailCount = result.FailCount;
PassCount = result.PassCount;
SkipCount = result.SkipCount;
InconclusiveCount = result.InconclusiveCount;
HasChildren = result.HasChildren;
Output = result.Output;
Children = children;
m_Node = result.ToXml(true);
}
/// <summary>
/// Writes the test result to the specified TextWriter
/// </summary>
/// <param name="result">The result to be written to a file</param>
/// <param name="writer">A TextWriter to which the result is written</param>
public override void WriteResultFile(ITestResult result, TextWriter writer)
{
// NOTE: Under .NET 1.1, XmlTextWriter does not implement IDisposable,
// but does implement Close(). Hence we cannot use a 'using' clause.
#if CLR_2_0 || CLR_4_0
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
XmlWriter xmlWriter = XmlWriter.Create(writer, settings);
#else
XmlTextWriter xmlWriter = new XmlTextWriter(writer);
xmlWriter.Formatting = Formatting.Indented;
#endif
try
{
xmlWriter.WriteStartDocument(false);
result.ToXml(true).WriteTo(xmlWriter);
}
finally
{
xmlWriter.Close();
}
}
/// <summary>
/// Writes the test result to the specified TextWriter
/// </summary>
/// <param name="result">The result to be written to a file</param>
/// <param name="writer">A TextWriter to which the result is written</param>
public override void WriteResultFile(ITestResult result, TextWriter writer)
{
// NOTE: Under .NET 1.1, XmlTextWriter does not implement IDisposable,
// but does implement Close(). Hence we cannot use a 'using' clause.
#if CLR_2_0 || CLR_4_0
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
XmlWriter xmlWriter = XmlWriter.Create(writer, settings);
#else
XmlTextWriter xmlWriter = new XmlTextWriter(writer);
xmlWriter.Formatting = Formatting.Indented;
#endif
try
{
xmlWriter.WriteStartDocument(false);
result.ToXml(true).WriteTo(xmlWriter);
}
finally
{
xmlWriter.Close();
}
}
private static XmlNode ToXml(ITestResult testResult)
{
var doc = new XmlDocument();
doc.LoadXml("<foo />");
return testResult.ToXml(doc.ChildNodes[0]);
}
/// <summary>
/// Called when a test has finished. Sends a result summary to the callback.
/// to
/// </summary>
/// <param name="result">The result of the test</param>
public void TestFinished(ITestResult result)
{
try
{
handler.RaiseCallbackEvent(result.ToXml(false).OuterXml);
}
catch (Exception ex)
{
log.Error("Exception processing " + result.FullName + NUnit.Env.NewLine + ex.ToString());
}
}
/// <summary>
/// Called when a test has finished. Sends a result summary to the callback.
/// to
/// </summary>
/// <param name="result">The result of the test</param>
public void TestFinished(ITestResult result)
{
try
{
var node = result.ToXml(false);
var parent = GetParent(result.Test);
node.Attributes.Add("parentId", parent != null ? parent.Id : string.Empty);
handler.RaiseCallbackEvent(node.OuterXml);
}
catch (Exception ex)
{
log.Error("Exception processing " + result.FullName + NUnit.Env.NewLine + ex.ToString());
}
}
