void WriteResultsToXml(ITestResultAdaptor result, XmlWriter xmlWriter)
{
// XML format as specified at https://github.com/nunit/docs/wiki/Test-Result-XML-Format
var testRunNode = new TNode(k_TestRunNode);
testRunNode.AddAttribute(k_Id, "2");
testRunNode.AddAttribute(k_Testcasecount, (result.PassCount + result.FailCount + result.SkipCount + result.InconclusiveCount).ToString());
testRunNode.AddAttribute(k_Result, result.ResultState.ToString());
testRunNode.AddAttribute(k_Total, (result.PassCount + result.FailCount + result.SkipCount + result.InconclusiveCount).ToString());
testRunNode.AddAttribute(k_Passed, result.PassCount.ToString());
testRunNode.AddAttribute(k_Failed, result.FailCount.ToString());
testRunNode.AddAttribute(k_Inconclusive, result.InconclusiveCount.ToString());
testRunNode.AddAttribute(k_Skipped, result.SkipCount.ToString());
testRunNode.AddAttribute(k_Asserts, result.AssertCount.ToString());
testRunNode.AddAttribute(k_EngineVersion, k_nUnitVersion);
testRunNode.AddAttribute(k_ClrVersion, Environment.Version.ToString());
testRunNode.AddAttribute(k_StartTime, result.StartTime.ToString(k_TimeFormat));
testRunNode.AddAttribute(k_EndTime, result.EndTime.ToString(k_TimeFormat));
testRunNode.AddAttribute(k_Duration, result.Duration.ToString());
var resultNode = result.ToXml();
testRunNode.ChildNodes.Add(resultNode);
testRunNode.WriteTo(xmlWriter);
}
public TestState GetTestStateFromResult(ITestResultAdaptor result)
{
var state = TestState.Failure;
if (result.TestStatus == TestStatus.Passed)
{
state = TestState.Success;
}
else if (result.TestStatus == TestStatus.Skipped)
{
state = TestState.Skipped;
if (result.ResultState.ToLowerInvariant().EndsWith("ignored"))
{
state = TestState.Ignored;
}
}
else
{
if (result.ResultState.ToLowerInvariant().Equals("inconclusive"))
{
state = TestState.Inconclusive;
}
if (result.ResultState.ToLowerInvariant().EndsWith("cancelled") ||
result.ResultState.ToLowerInvariant().EndsWith("error"))
{
state = TestState.Error;
}
}
return(state);
}
public void RunFinished(ITestResultAdaptor result)
{
if (RerunCallbackData.instance.runFilters == null)
{
RerunCallbackData.instance.runFilters = new[] { new TestRunnerFilter() }
}
;
var runFilter = RerunCallbackData.instance.runFilters[0];
if (useMockRunFilter)
{
runFilter = mockRunFilter;
}
runFilter.testRepetitions--;
if (runFilter.testRepetitions <= 0 || result.TestStatus != TestStatus.Passed)
{
ExitCallbacks.preventExit = false;
return;
}
ExitCallbacks.preventExit = true;
if (EditorApplication.isPlaying)
{
EditorApplication.playModeStateChanged += WaitForExitPlaymode;
return;
}
if (!useMockRunFilter)
{
ExecuteTestRunnerAPI();
}
}
public void RunFinished(ITestResultAdaptor result)
{
if (!result.HasChildren)
{
EditorUtility.DisplayDialog("Validation Test Result", "No tests were found to run. Are you sure this is a scene that can be validated?", "OK");
}
else if (result.FailCount == 0)
{
EditorUtility.DisplayDialog("Validation Test Result", $"All {result.PassCount} validation tests passed.", "OK");
}
else
{
IEnumerable <string> GetFailedTestNames(ITestResultAdaptor test)
{
if (test.HasChildren)
{
return(test.Children.SelectMany(GetFailedTestNames));
}
return(test.TestStatus == TestStatus.Failed ? new[] { test.Name } : Array.Empty <string>());
}
string failedTestNames = string.Join("\n", GetFailedTestNames(result));
EditorUtility.DisplayDialog("Validation Test Result", $"{result.FailCount} tests failed:\n{failedTestNames}", "Go to Test Runner");
EditorApplication.ExecuteMenuItem("Window/General/Test Runner");
}
DestroyImmediate(this);
}
public TestResultAdaptor(ITestResultAdaptor testResultAdaptor, int parent)
{
Name = testResultAdaptor.Name;
FullName = testResultAdaptor.FullName;
PassCount = testResultAdaptor.PassCount;
FailCount = testResultAdaptor.FailCount;
InconclusiveCount = testResultAdaptor.InconclusiveCount;
SkipCount = testResultAdaptor.SkipCount;
switch (testResultAdaptor.TestStatus)
{
case UnityEditor.TestTools.TestRunner.Api.TestStatus.Passed:
TestStatus = TestStatusAdaptor.Passed;
break;
case UnityEditor.TestTools.TestRunner.Api.TestStatus.Skipped:
TestStatus = TestStatusAdaptor.Skipped;
break;
case UnityEditor.TestTools.TestRunner.Api.TestStatus.Inconclusive:
TestStatus = TestStatusAdaptor.Inconclusive;
break;
case UnityEditor.TestTools.TestRunner.Api.TestStatus.Failed:
TestStatus = TestStatusAdaptor.Failed;
break;
}
Parent = parent;
}
public void RunFinished(ITestResultAdaptor result)
{
if (m_TimeoutCallback != null)
{
m_TimeoutCallback.Clear();
}
}
private static string ExtractOutput(ITestResultAdaptor testResult)
{
var stringBuilder = new StringBuilder();
if (testResult.Message != null)
{
stringBuilder.AppendLine("Message: ");
stringBuilder.AppendLine(testResult.Message);
}
if (!string.IsNullOrEmpty(testResult.Output))
{
stringBuilder.AppendLine("Output: ");
stringBuilder.AppendLine(testResult.Output);
}
if (!string.IsNullOrEmpty(testResult.StackTrace))
{
stringBuilder.AppendLine("Stacktrace: ");
stringBuilder.AppendLine(testResult.StackTrace);
}
var result = stringBuilder.ToString();
if (result.Length > 0)
{
return(result);
}
return(testResult.Output ?? string.Empty);
}
public void RunFinished(ITestResultAdaptor result)
{
Result = result;
PassCount = Result.PassCount;
SkipCount = Result.SkipCount;
Failed = Result.FailCount > 0;
}
public void RunFinished(ITestResultAdaptor result)
{
if (!result.HasChildren)
{
EditorUtility.DisplayDialog("알림", "해당씬은 등록된 테스트Case가 없습니다.", "OK");
}
else if (result.FailCount == 0)
{
EditorUtility.DisplayDialog("알림", "테스트가 모두 성공했습니다.", "OK");
}
else
{
IEnumerable <string> GetFailedTestNames(ITestResultAdaptor test)
{
if (test.HasChildren)
{
return(test.Children.SelectMany(GetFailedTestNames));
}
return(test.TestStatus == TestStatus.Failed ? new[] { test.Name } : Array.Empty <string>());
}
string failedTestNames = string.Join("\n", GetFailedTestNames(result));
EditorUtility.DisplayDialog("알림",
$"실패하였습니다. ({result.FailCount} 개)\n" +
$"{failedTestNames}",
"OK");
EditorApplication.ExecuteMenuItem("Window/General/Test Runner");
}
DestroyImmediate(this);
}
public void TestFinished(ITestResultAdaptor result)
{
if (!result.Test.IsSuite && (result.TestStatus == TestStatus.Failed))
{
m_RunFailed = true;
}
}
public void RunFinished(ITestResultAdaptor testResults)
{
if (!Coverage.enabled)
{
return;
}
if (CoverageRunData.instance.isRecording || m_IsConnectedToPlayer)
{
return;
}
CoverageRunData.instance.Stop();
if (!CoverageRunData.instance.DidTestsRun())
{
return;
}
ICoverageReporter coverageReporter = m_CoverageReporterManager.CoverageReporter;
if (coverageReporter != null)
{
coverageReporter.OnRunFinished(testResults);
}
m_CoverageReporterManager.GenerateReport();
}
public void TestFinished(ITestResultAdaptor result)
{
if (!result.Test.IsSuite && (result.TestStatus == TestStatus.Failed || result.TestStatus == TestStatus.Inconclusive))
{
ExitCallbacksDataHolder.instance.RunFailed = true;
}
}
private static void ReportRunFinished(ITestResultAdaptor testResult)
{
SetUpIfNeeded();
var activeRuns = TestJobDataHolder.instance.TestRuns;
if (activeRuns.Count == 0)
{
return;
}
var executionSettings = activeRuns[0].executionSettings;
var filter = executionSettings.filters.First();
var runFinishedData = new RunFinishedData()
{
totalTests = testResult.Test.TestCaseCount,
numPassedTests = testResult.PassCount,
numFailedTests = testResult.FailCount,
numInconclusiveTests = testResult.InconclusiveCount,
numSkippedTests = testResult.SkipCount,
testModeFilter = (int)filter.testMode,
targetPlatform = executionSettings.targetPlatform != null?executionSettings.targetPlatform.ToString() : "editor",
runSynchronously = executionSettings.runSynchronously,
isCustomRunner = false,
isFiltering = executionSettings.filters.Any(f => f.HasAny()),
isAutomated = IsCommandLineArgSet("-automated"),
isFromCommandLine = IsCommandLineArgSet("-runTests"),
totalTestDuration = testResult.Duration,
totalRunDuration = (DateTime.Now - Convert.ToDateTime(activeRuns[0].startTime)).TotalSeconds
};
EditorAnalytics.SendEventWithLimit(RunFinishedEventName, runFinishedData, 1);
}
public string GetRunStateFromResultNunitXml(ITestResultAdaptor result)
{
var doc = new XmlDocument();
doc.LoadXml(result.ToXml().OuterXml);
return(doc.FirstChild.Attributes["runstate"].Value);
}
public void OnTestFinished(ITestResultAdaptor result)
{
if (m_OutputPerTest)
{
OutputCoverageReport(result);
}
}
public void RunFinished(ITestResultAdaptor results)
{
if (silent && results.FailCount == 0)
{
return;
}
if (verbose || results.FailCount > 0)
{
CLITools.PrintBanner("Tests");
PrintTest(results, 0);
}
Console.WriteLine();
CLITools.PrintInlineBanner("Test Summary");
Console.WriteLine(" Passed: " + results.PassCount);
Console.WriteLine(" Failed: " + results.FailCount);
Console.WriteLine(" Skipped/Inconclusive: " + (results.SkipCount + results.InconclusiveCount));
CLITools.PrintBannerBar();
Console.WriteLine();
if (results.FailCount > 0)
{
throw new Exception("Fix your tests, dag nabbit!");
}
}
public void RunFinished(ITestResultAdaptor testResults)
{
if (TestRunnerWindow.s_Instance != null)
{
TestRunnerWindow.s_Instance.RebuildUIFilter();
}
}
public void TestFinished(ITestResultAdaptor result)
{
if (!result.HasChildren && result.ResultState != "Success")
{
string resultStr = string.Format("Test {0} {1}", result.Test.Name, result.ResultState);
testResultDes.Append(resultStr);
}
}
public void TestFinished(ITestResultAdaptor result)
{
if (!result.HasChildren /* && result.ResultState != "Passed"*/)
{
//Debug.Log(string.Format("Test {0} {1}", result.Test.Name, result.ResultState));
//Debug.Log(result.m_Node.OuterXml);
}
}
public void RunFinished(ITestResultAdaptor result)
{
CallbackData.instance.isRider = false;
CallbackData.instance.events.Add(
new TestEvent(EventType.RunFinished, "", "", "", 0, ParseTestStatus(result.TestStatus), ""));
CallbackData.instance.RaiseChangedEvent();
}
public void TestFinished(ITestResultAdaptor result)
{
if (!result.HasChildren && result.ResultState.Equals("Failed"))
{
log.Append(
$"[{result.FullName}][{result.Test.Name}] : {result.ResultState}\n{result.Message}\n");
}
}
public void OnRunFinished(ITestResultAdaptor testResults)
{
if (!m_OutputPerTest)
{
OutputCoverageReport(testResults, false);
}
Events.InvokeOnCoverageSessionFinished();
}
public void RunFinished(ITestResultAdaptor result)
{
string resultPath = Application.persistentDataPath + "/testResult-" + DateTime.Now.Ticks + ".log";
FileStream fs = new FileStream(resultPath, FileMode.Create);
var sw = new StreamWriter(fs);
sw.Write(parser(result));
sw.Close();
}
private string Serialize(ITestResultAdaptor testResultAdaptor)
{
return(Serialize(
testResultAdaptor,
(a, parentIndex) => new TestResultAdaptor(a, parentIndex),
(a) => a.Children,
(r) => new TestResultAdaptorContainer {
TestResultAdaptors = r
}));
}
public virtual void RunFinished(ITestResultAdaptor testResults)
{
if (string.IsNullOrEmpty(m_ResultFilePath))
{
m_ResultFilePath = GetDefaultResultFilePath();
}
var resultWriter = new ResultsWriter();
resultWriter.WriteResultToFile(testResults, m_ResultFilePath);
}
public void ReportTestFinished(ITestResultAdaptor result)
{
if (result.Test.IsSuite)
{
return;
}
var msg = TestRunnerApiMapper.TestResultToTestFinishedMessage(result);
Logger.Log(msg);
}
public void TestFinished(ITestResultAdaptor result)
{
if (result.Test.Method == null)
{
return;
}
CallbackData.instance.events.Add(
new TestEvent(EventType.TestFinished, GetUniqueName(result.Test), result.Test.Method.TypeInfo.Assembly.GetName().Name, ExtractOutput(result), result.Duration, ParseTestStatus(result.TestStatus), result.Test.ParentFullName));
CallbackData.instance.RaiseChangedEvent();
}
public void TestFinished(ITestResultAdaptor test)
{
if (TestRunnerWindow.s_Instance == null)
{
return;
}
var result = new TestRunnerResult(test);
TestRunnerWindow.s_Instance.m_SelectedTestTypes.UpdateResult(result);
}
public void TestFinished(ITestResultAdaptor result)
{
if (result.Test.Method == null)
{
return;
}
CallbackData.instance.events.Add(
new TestEvent(EventType.TestFinished, GenerateId(result.Test), result.Test.Method.TypeInfo.Assembly.GetName().Name, ExtractOutput(result), (result.EndTime - result.StartTime).Milliseconds, ParseTestStatus(result.TestStatus), GenerateId(result.Test.Parent)));
CallbackData.instance.RaiseChangedEvent();
}
public TestFinishedMessage TestResultToTestFinishedMessage(ITestResultAdaptor result)
{
return(new TestFinishedMessage
{
name = result.Test.FullName,
duration = Convert.ToUInt64(result.Duration * 1000),
durationMicroseconds = Convert.ToUInt64(result.Duration * 1000000),
message = result.Message,
state = GetTestStateFromResult(result)
});
}
