protected virtual void PublishResults(TestResult testResults)
{
TestResultsConfig.PrintConfig();
Log.Info(this.tag, "Publishing results : " + DateTime.Now +
"\nTotal count : {0}, Failed : {1}",
testResults.AssertCount,
testResults.FailCount);
if (TestResultsConfig.IsRemote)
{
switch (TestResultsConfig.TestsResultsFormat)
{
case "plain_text":
// We already published test results because in this case we publish each test results separately. See SetTextWriterForAndroidTestRunner() method.
return;
case "nunit2":
var nunit2Writer = new NUnit2XmlOutputWriter(this.testsStartTime);
var tcpwriter = this.NetworkWriter;
nunit2Writer.WriteResultFile(testResults, tcpwriter);
tcpwriter.Close();
Log.Info(this.tag, "Published tests results in nunit2 format");
return;
case "nunit3":
var nunit3Writer = new NUnit3XmlOutputWriter(this.testsStartTime);
var newtworkWriter = this.NetworkWriter;
nunit3Writer.WriteResultFile(testResults, newtworkWriter);
newtworkWriter.Close();
Log.Info(this.tag, "Published tests results in nunit3 format");
return;
}
}
else
{
// If we don't need to send test results to remote server, just return.
return;
}
}
public override string WriteResultsToFile()
{
if (results == null)
{
return(String.Empty);
}
string ret = GetResultsFilePath();
if (String.IsNullOrEmpty(ret))
{
return(String.Empty);
}
var resultsXml = new NUnit2XmlOutputWriter(DateTime.UtcNow);
resultsXml.WriteResultFile(results, ret);
return(ret);
}
public void CloseWriter()
{
if (Writer == null)
{
return;
}
var outputWriter = new NUnit2XmlOutputWriter();
var tempFilePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "output.xml");
outputWriter.WriteResultFile(TestResult, tempFilePath);
var data = File.ReadAllBytes(tempFilePath);
var tcpTextWriter = Writer as TcpTextWriter;
if (tcpTextWriter != null)
{
tcpTextWriter.Write(data, 0, data.Length);
}
Writer.Close();
Writer = null;
}
public void CloseWriter()
{
var outputWriter = new NUnit2XmlOutputWriter();
var tempFilePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "output.xml");
outputWriter.WriteResultFile(TestResult, tempFilePath);
var data = File.ReadAllBytes(tempFilePath);
if (Writer is TcpTextWriter)
{
(Writer as TcpTextWriter).Write(data, 0, data.Length);
Writer.Close();
}
else
{
int total = passed + inconclusive + failed; // ignored are *not* run
Writer.WriteLine("Tests run: {0} Passed: {1} Inconclusive: {2} Failed: {3} Ignored: {4}", total, passed, inconclusive, failed, ignored);
}
Writer = null;
}
public override void OnStart()
{
base.OnStart();
AddTests();
AndroidRunner.Runner.Options.LoadFromBundle(arguments);
AndroidRunner.Runner.AddTestFilters(GetIncludedCategories(), GetExcludedCategories());
AndroidRunner.Runner.Initialized = true;
var results = new Bundle();
int failed = 0;
try {
Log.Info(TAG, "NUnit automated tests started");
var testResult = AndroidRunner.Runner.Run(AndroidRunner.GetSetupTestTarget(arguments), TargetContext);
var resultsFile = GetResultsPath();
if (resultsFile != null)
{
var startTime = DateTime.Now;
var resultsXml = new NUnit2XmlOutputWriter(startTime);
resultsXml.WriteResultFile(testResult, resultsFile);
results.PutString("nunit2-results-path", ToAdbPath(resultsFile));
}
Log.Info(TAG, "NUnit automated tests completed");
int passed = 0, skipped = 0, inconclusive = 0;
foreach (TestResult result in AndroidRunner.Results.Values)
{
if (result.HasChildren)
{
continue;
}
inconclusive += result.InconclusiveCount;
failed += result.FailCount;
passed += result.PassCount;
skipped += result.SkipCount;
if (result.FailCount > 0)
{
Log.Error(TAG, "Test '{0}' failed: {1}", result.FullName, result.Message);
// Avoid Java.Lang.NullPointerException: println needs a message
if (!String.IsNullOrEmpty(result.StackTrace))
{
Log.Error(TAG, result.StackTrace);
}
results.PutString("failure: " + result.FullName,
result.Message + "\n" + result.StackTrace);
Log.Error(TAG, " "); // makes it easier to read the failures in logcat output
}
}
results.PutInt("passed", passed);
results.PutInt("failed", failed);
results.PutInt("skipped", skipped);
results.PutInt("inconclusive", inconclusive);
string message = string.Format("Passed: {0}, Failed: {1}, Skipped: {2}, Inconclusive: {3}",
passed, failed, skipped, inconclusive);
Log.Info(TAG, message);
} catch (Exception e) {
Log.Error(TAG, "Error: {0}", e);
results.PutString("error", e.ToString());
}
Finish(failed == 0 ? Result.Ok : Result.Canceled, results);
}
/// <summary>
/// Write the result of a test run according to a spec.
/// </summary>
/// <param name="result">The test result</param>
/// <param name="spec">An output specification</param>
/// <param name="runSettings">Settings</param>
/// <param name="filter">Filter</param>
public void WriteResultFile(ITestResult result, OutputSpecification spec, IDictionary <string, object> runSettings, TestFilter filter)
{
//string outputPath = Path.Combine(_workDirectory, spec.OutputPath);
// [DuongNT][BEGIN]: Get configured file path output
// Write results log
ResultSummary summary = new ResultSummary(result);
int totalTCT = summary.TestCount;
int passedTCT = summary.PassCount;
int failedTCT = summary.FailedCount;
int blockTCT = totalTCT - passedTCT - failedTCT;
TLogger.Write("");
TLogger.Write("#####Summary#####");
TLogger.Write("##### Total #####");
TLogger.Write("##### " + totalTCT + " #####");
TLogger.Write("##### PASS #####");
TLogger.Write("##### " + passedTCT + " #####");
TLogger.Write("##### FAIL #####");
TLogger.Write("##### " + failedTCT + " #####");
TLogger.Write("##### BLOCK #####");
TLogger.Write("##### " + blockTCT + " #####");
TLogger.Write("##### Details #####");
TLogger.Write("");
string outputPath = TSettings.GetInstance().GetOutputFilePathName();
if (outputPath == "")
{
outputPath = Path.Combine(_workDirectory, spec.OutputPath);
}
TLogger.Write("Completed test-suite's execution!");
TLogger.Write("Writing results to: " + outputPath + "...");
// [DuongNT][END]: Get configured file path output
OutputWriter outputWriter = null;
switch (spec.Format)
{
case "nunit3":
outputWriter = new NUnit3XmlOutputWriter();
break;
case "nunit2":
outputWriter = new NUnit2XmlOutputWriter();
break;
//case "user":
// Uri uri = new Uri(Assembly.GetExecutingAssembly().CodeBase);
// string dir = Path.GetDirectoryName(uri.LocalPath);
// outputWriter = new XmlTransformOutputWriter(Path.Combine(dir, spec.Transform));
// break;
default:
throw new ArgumentException(
string.Format("Invalid XML output format '{0}'", spec.Format),
"spec");
}
outputWriter.WriteResultFile(result, outputPath, runSettings, filter);
TLogger.Write("Results saved to: " + outputPath);
}
