static void FillNunitReport(NUnitResultCollector nunitReport, Runner[] runners)
{
foreach (Runner runner in runners)
{
if (runner == null)
{
continue;
}
NUnit.Core.TestResult[] results = runner.GetTestResults();
nunitReport.AddResults(results);
}
}
static void RunLauncher(string customLogFolder, string[] args)
{
TestGroup group = TestConfLoader.LoadFromFile(args[0], args);
LauncherArgs launcherArgs = CliArgsReader.ProcessArgs(args, group);
if ((group == null) || (group.ParallelTests.Count == 0))
{
Console.WriteLine("No tests to run");
return;
}
TestSuiteLoggerParams loggerParams = CliArgsReader.ProcessTestSuiteLoggerArgs(args);
NUnitResultCollector nunitReport = new NUnitResultCollector();
LogWriter logWriter = new LogWriter(launcherArgs.ResultLogFile, launcherArgs.ErrorLogFile);
try
{
string portValue = CliArgsReader.GetArgumentValue("--port=", args);
int port = portValue == null ? DEFAULT_LAUNCHER_PORT : int.Parse(portValue);
string ipToBind = CliArgsReader.GetArgumentValue("--iptobind=", args);
Configurator.ConfigureRemoting(port, ipToBind ?? string.Empty);
DateTime beginTimeStamp = DateTime.Now;
TestSuiteLogger testSuiteLogger = null;
if (loggerParams.IsInitialized())
{
testSuiteLogger = new TestSuiteLogger(loggerParams);
testSuiteLogger.SaveBuild();
testSuiteLogger.CreateSuite();
}
Hashtable userValues = CliArgsReader.GetUserValues(args);
Launcher launcher = new Launcher();
string listenAddress = string.Format("{0}:{1}",
ipToBind ?? Environment.MachineName, port);
List <string> testList = string.IsNullOrEmpty(launcherArgs.ListTestsFile) ?
null :
LoadTestsToRunFromFile(launcherArgs.ListTestsFile);
Runner[] runners = launcher.RunTests(
group,
testList,
launcherArgs.MaxRetry,
launcherArgs.ShellMode,
launcherArgs.RetryOnFailure,
launcherArgs.FailedConfigFile,
testSuiteLogger,
launcherArgs.TestsTimeout,
launcherArgs.TestRange,
userValues,
logWriter,
listenAddress,
launcherArgs.UseFileReport);
DateTime endTimeStamp = DateTime.Now;
FillNunitReport(nunitReport, runners);
if (CliArgsReader.GetArgumentValue("--skipsummarylog", args) != null)
{
return;
}
LogWriter.PrintResults(
runners,
beginTimeStamp, endTimeStamp, logWriter);
}
finally
{
logWriter.WriteFullLog(launcherArgs.ResultFile);
nunitReport.SaveResults(Path.Combine(customLogFolder, "pnunit-results.xml"));
}
}
private static void PrintResults(Runner[] runners,
DateTime beginTimeStamp, DateTime endTimeStamp, NUnitResultCollector nunitReport)
{
double TotalBiggerTime = 0;
int TotalTests = 0;
int TotalExecutedTests = 0;
int TotalIgnoredTests = 0;
int TotalFailedTests = 0;
int TotalSuccessTests = 0;
IList failedTests = new ArrayList();
int j;
foreach (Runner runner in runners)
{
int ExecutedTests = 0;
int FailedTests = 0;
int SuccessTests = 0;
int IgnoredTests = 0;
double BiggerTime = 0;
TestResult[] results = runner.GetTestResults();
Log(string.Format("==== Tests Results for Parallel TestGroup {0} ===", runner.TestGroupName));
j = 0;
nunitReport.AddResults(results);
foreach (TestResult res in results)
{
if (!res.Executed)
{
++IgnoredTests;
continue;
}
if (res.Executed)
++ExecutedTests;
if (res.IsFailure)
++FailedTests;
if (res.IsSuccess)
++SuccessTests;
PrintResult(++j, res);
if (res.Time > BiggerTime)
BiggerTime = res.Time;
if (res.IsFailure)
failedTests.Add(res);
}
Log("Summary:");
Log(string.Format(
"\tTotal: {0}\r\n" +
"\tExecuted: {1}\r\n" +
"\tIgnored: {2}\r\n" +
"\tFailed: {3}\r\n" +
"\tSuccess: {4}\r\n" +
"\t% Success: {5}\r\n" +
"\tBiggest Execution Time: {6} s\r\n",
results.Length, ExecutedTests, IgnoredTests, FailedTests, SuccessTests,
results.Length > 0 ? 100 * SuccessTests / results.Length : 0,
BiggerTime));
TotalTests += results.Length;
TotalExecutedTests += ExecutedTests;
TotalIgnoredTests += IgnoredTests;
TotalFailedTests += FailedTests;
TotalSuccessTests += SuccessTests;
TotalBiggerTime += BiggerTime;
}
// print all failed tests together
if (failedTests.Count > 0)
{
Log("==== Failed tests ===");
for (j = 0; j < failedTests.Count; ++j)
PrintResult(j, failedTests[j] as PNUnitTestResult);
}
if (runners.Length > 1)
{
Log("Summary for all the parallel tests:");
Log(string.Format(
"R00:\tTotal: {0}\r\nR01:\t" +
"Executed: {1}\r\nR02:\t" +
"Ignored: {2}\r\nR03:\t" +
"Failed: {3}\r\nR04:\t" +
"Success: {4}\r\nR05:\t%" +
"Success: {5}\r\nR06:\tBiggest Execution Time: {6} s\r\n",
TotalTests, TotalExecutedTests, TotalIgnoredTests, TotalFailedTests,
TotalSuccessTests,
TotalTests > 0 ? 100 * TotalSuccessTests / TotalTests : 0,
TotalBiggerTime));
}
TimeSpan elapsedTime = endTimeStamp.Subtract(beginTimeStamp);
Log(string.Format("Launcher execution time: {0} seconds", elapsedTime.TotalSeconds));
}
static void Main(string[] args)
{
ProcessNameSetter.SetProcessName("launcher");
NUnitResultCollector nunitReport = new NUnitResultCollector();
string resultfile = null;
string failedfile = null;
int retryOnFailure = 0;
int maxRetry = DEFAULT_TEST_RETRY;
ConfigureLogging();
try
{
if( args.Length == 0 )
{
Console.WriteLine(
"Usage: launcher configfile [--result=filename] [--failed=filename] "+
"[--max_barrier_wait_time=number_of_seconds] "+
"[-D:var=value] [-val:variable=value] [--retry=number] [--range=from-to] "+
"[--test=testname] [--shell]");
return;
}
string configfile = args[0];
mTestPath = Path.GetDirectoryName(configfile);
TestGroup group = TestConfLoader.LoadFromFile(configfile, args);
mEndTest = group.ParallelTests.Count - 1;
failedfile = Path.Combine(mTestPath, "smokefailed.conf");
bool bShellMode = false;
if( args.Length > 1 )
{
foreach( string arg in args )
{
if( arg.StartsWith("--result=") )
{
resultfile = Path.GetFullPath(arg.Substring(9));
}
if( arg.StartsWith("--failed=") )
{
failedfile = Path.GetFullPath(arg.Substring(9));
}
if( arg.StartsWith("--retry=") )
{
retryOnFailure = int.Parse(arg.Substring("--retry=".Length));
log.InfoFormat("Retry on failure activated. {0} retries", retryOnFailure);
maxRetry = retryOnFailure;
}
if (arg.StartsWith("--max_barrier_wait_time="))
{
int maxBarrierTime = int.Parse(arg.Substring("--max_barrier_wait_time=".Length));
log.InfoFormat("Max Barrier wait time set to: {0} seconds", maxBarrierTime);
Barrier.SetMaxWaitTime(maxBarrierTime);
}
if (arg.Equals("--shell"))
{
bShellMode = true;
}
if(arg.StartsWith("--test="))
{
LaunchATest(arg, group);
}
if( arg.StartsWith("--range=") )
{
LaunchARange(arg, group);
}
if (arg.StartsWith("--pattern="))
{
LaunchAPattern(arg, group);
//update test range
SetTestRange(0, group.ParallelTests.Count - 1);
}
}
}
if( (group == null) || (group.ParallelTests.Count == 0) )
{
Console.WriteLine("No tests to run");
return;
}
ConfigureRemoting();
DateTime beginTimeStamp = DateTime.Now;
Runner[] runners = RunTests(args, group, maxRetry, bShellMode,
retryOnFailure, failedfile);
DateTime endTimeStamp = DateTime.Now;
PrintResults(runners, beginTimeStamp, endTimeStamp, nunitReport);
}
finally
{
WriteResult(resultfile);
nunitReport.SaveResults("pnunit-results.xml");
}
}
