void Add(Process pnunitTestRunnerProc, PNUnitTestInfo testInfo)
{
lock (mRunningTests)
{
mRunningTests.Add(new RunningTest(pnunitTestRunnerProc, testInfo));
}
}
public static PNUnitTestInfo ReadTestInfo(string testInfoPath)
{
int ini = Environment.TickCount;
PNUnitTestInfo result = null;
try
{
using (FileStream fs = new FileStream(testInfoPath, FileMode.Open, FileAccess.Read))
{
BinaryFormatter bf = new BinaryFormatter();
bf.AssemblyFormat = FormatterAssemblyStyle.Simple;
result = (PNUnitTestInfo)bf.Deserialize(fs);
return(result);
}
}
catch (Exception e)
{
mLog.ErrorFormat("Something wrong happened when reading the agent info: " + e.Message);
return(null);
}
finally
{
TryDelete(testInfoPath);
mLog.DebugFormat(
"Read test info file {0} {1} ms",
testInfoPath, Environment.TickCount - ini);
}
}
internal static void NotifyError(Exception e, PNUnitTestInfo info)
{
TestLogInfo testLogInfo = new TestLogInfo();
testLogInfo.SetOSVersion(Environment.OSVersion.Platform.ToString());
TestName testName = new TestName();
testName.Name = info.TestName;
testName.FullName = info.TestName;
testName.TestID = new TestID();
PNUnitTestResult result = new PNUnitTestResult(
testName, info.GetTestOutput(),
testLogInfo.OSVersion, testLogInfo.BackendType, true);
string fullMessage = string.Format(
"TestName: {0}; Error: {1}; EXCEPTION TYPE: {2}; STACK TRACE: {3}",
testName.Name, e.Message, e.GetType(), e.StackTrace);
result.Failure(fullMessage, string.Empty);
info.DeleteTestOutput();
IPNUnitServices services =
PNUnitServices.GetPNunitServicesProxy(info.PNUnitServicesServer);
services.NotifyResult(info.TestName, result);
}
Process LaunchTestRunner(PNUnitTestInfo testInfo, string testInfoPath)
{
string testingArgs = string.Format(
"\"{0}\" \"{1}\"", testInfoPath, mPathToAssemblies);
// You should customize this section depending on the applications
// you've got and the platform they run on.
Process result = null;
if (testInfo.TestName.StartsWith("windows:"))
{
result = ProcessCreator.CreateGuiApplicationRunnerProcess(
testInfo, "windows.exe", testingArgs, mPathToAssemblies);
}
if (testInfo.TestName.StartsWith("linux:"))
{
result = ProcessCreator.CreateGuiApplicationRunnerProcess(
testInfo, "linux", testingArgs, mPathToAssemblies);
}
if (testInfo.TestName.StartsWith("mac:"))
{
result = ProcessCreator.CreateGuiApplicationRunnerProcess(
testInfo, "macos.app/Contents/MacOS/macos", testingArgs, mPathToAssemblies);
}
if (result == null)
{
result = ProcessCreator.CreateTestRunnerProc(testingArgs, mPathToAssemblies);
}
result.Start();
return(result);
}
internal static PNUnitTestInfo ReadTestInfo(string testInfoPath)
{
int init = Environment.TickCount;
try
{
using (FileStream fs = new FileStream(testInfoPath, FileMode.Open, FileAccess.Read))
{
BinaryFormatter bf = new BinaryFormatter();
bf.AssemblyFormat = FormatterAssemblyStyle.Simple;
PNUnitTestInfo result = (PNUnitTestInfo)bf.Deserialize(fs);
result.TestToRun = CleanTestName(result.TestToRun);
return(result);
}
}
catch (Exception ex)
{
mLog.ErrorFormat(
"Something went wrong while reading the agent info: {0}",
ex.Message);
return(null);
}
finally
{
TryDelete(testInfoPath);
mLog.DebugFormat(
"Read test info file {0} in {1} ms.",
testInfoPath, Environment.TickCount - init);
}
}
public void RunTest(PNUnitTestInfo testInfo)
{
try
{
int ini = Environment.TickCount;
mLog.InfoFormat(
">>RunTest called for Test {0}, AssemblyName {1}, TestToRun {2}",
testInfo.TestName, testInfo.AssemblyName, testInfo.TestToRun);
mTestCounter.Increment();
CreateTestOutputFile(testInfo);
// spawn the test in a new process
string testInfoPath = WriteTestInfo(testInfo);
mProcessPool.RunProcess(testInfo, testInfoPath);
mLog.InfoFormat(
"<<RunTest {0} - {1} launched in {2} ms.",
testInfo.TestName, testInfo.TestToRun, Environment.TickCount - ini);
}
catch (Exception e)
{
mLog.ErrorFormat("<<RunTest {0} - {1} failed {2}",
testInfo.TestName, testInfo.TestToRun, e.Message);
NotifyError(e, testInfo);
}
}
public NUnitTestRunner(
PNUnitTestInfo info,
string pathToAssemblies)
{
mNUnitAssemblyPath = Path.Combine(pathToAssemblies, info.AssemblyName);
mPNUnitTestInfo = info;
}
internal static PNUnitTestResult BuildError(
PNUnitTestInfo pnunitTestInfo,
Exception e,
TestConsoleAccess consoleAccess,
TestLogInfo testLogInfo)
{
TestName testName = new TestName();
testName.Name = pnunitTestInfo.TestName;
testName.FullName = pnunitTestInfo.TestName;
testName.TestID = new TestID();
PNUnitTestResult result = new PNUnitTestResult(
testName,
pnunitTestInfo.GetTestOutput(),
testLogInfo.OSVersion,
testLogInfo.BackendType);
string fullMessage = string.Format(
"{0}; EXCEPTION TYPE: {1}; STACK TRACE: {2}",
e.Message, e.GetType(), e.StackTrace);
result.Failure(fullMessage, string.Empty);
pnunitTestInfo.DeleteTestOutput();
return(result);
}
public void RunTest(PNUnitTestInfo info)
{
log.InfoFormat("RunTest called for Test {0}, AssemblyName {1}, TestToRun {2}",
info.TestName, info.AssemblyName, info.TestToRun);
new PNUnitTestRunner(info, mConfig).Run();
}
private TestResult BuildResult(
TestResult result,
TestConsoleAccess consoleAccess,
PNUnitTestInfo testInfo)
{
//the test namespace contains errors
if (result == null)
{
TestName testName = new TestName();
testName.Name = testInfo.TestName;
string errormsg = "The test {0} couldn't be found in the assembly {1}";
result = new PNUnitTestResult(testName, string.Empty);
result.Failure(
string.Format(errormsg, testInfo.TestToRun, testInfo.AssemblyName),
string.Empty);
return(result);
}
if (!result.IsSuccess /*|| ReturnTestOutput()*/)
{
return(new PNUnitTestResult(result, consoleAccess.GetTestOutput()));
}
else
{
return(result);
}
}
internal void RunProcess(
PNUnitTestInfo testInfo,
string testInfoPath)
{
Process pnunitTestRunnerProc = Run(testInfo, testInfoPath);
Add(pnunitTestRunnerProc, testInfo);
}
public PNUnitTestRunner(
PNUnitTestInfo info,
AgentConfig config)
{
mConfig = config;
mPNUnitTestInfo = info;
mbUseDomainPool = config.UseDomainPool;
}
static void InitPNUnitServices(
PNUnitTestInfo testInfo,
TestRunner testRunner,
IPNUnitServices services,
TestConsoleAccess consoleAccess,
TestLogInfo testLogInfo)
{
// Intialize the singleton
new PNUnitServices(testInfo, services, consoleAccess, testLogInfo);
}
void CreateTestOutputFile(PNUnitTestInfo info)
{
string outputTestFilePath = Path.GetTempFileName();
using (StreamWriter sw = new StreamWriter(outputTestFilePath, false))
{
sw.WriteLine("");
}
info.OutputFile = outputTestFilePath;
}
static void RunPreload(string pathToAssemblies)
{
mLog.Debug("Preload started. Path To assemblies:" + pathToAssemblies);
InitServices.InitNUnitServices();
PNUnitTestRunner runner = new PNUnitTestRunner(pathToAssemblies);
runner.Preload();
int pidOfThisExpectedByAgent = Codice.Test.PlatformIdentifier.IsWindows() ?
System.Diagnostics.Process.GetCurrentProcess().Id :
Mono.Unix.UnixEnvironment.GetParentProcessId();
string testInfoFile = Path.Combine(
Path.GetTempPath(),
PNUnit.Agent.AssemblyPreload.PRELOADED_PROCESS_FILE_PREFIX + pidOfThisExpectedByAgent.ToString());
int count = 0;
while (!File.Exists(testInfoFile))
{
System.Threading.Thread.Sleep(150);
mLog.DebugFormat("Waiting for testinfo file to be created...: {0}", testInfoFile);
count++;
if (count >= 6000) //wait 1,5 minutes for test arrival
{
mLog.Fatal("Tired of waiting: Cannot execute tests without information; exiting ...");
Environment.Exit(1);
}
}
mLog.DebugFormat("Preload read {0} from file", testInfoFile);
PNUnitTestInfo info = TestInfoReader.ReadTestInfo(testInfoFile);
if (info == null)
{
mLog.Fatal("Cannot execute tests without information; exiting ...");
Environment.Exit(1);
}
ProcessNameSetter.SetProcessName(info.TestName);
IPNUnitServices services =
PNUnitServices.GetPNunitServicesProxy(info.PNUnitServicesServer);
runner.Run(info, services, null);
}
string WriteTestInfo(PNUnitTestInfo info)
{
string infoConfigPath = Path.GetTempFileName();
using (FileStream fs = new FileStream(infoConfigPath, FileMode.OpenOrCreate))
{
BinaryFormatter bf = new BinaryFormatter(new RemotingSurrogateSelector(),
new StreamingContext(StreamingContextStates.CrossAppDomain));
bf.AssemblyFormat = FormatterAssemblyStyle.Simple;
bf.Serialize(fs, info);
}
return(infoConfigPath);
}
static void CreatePNUnitServices(
PNUnitTestInfo testInfo,
TestRunner testRunner,
IPNUnitServices services,
TestConsoleAccess consoleAccess,
TestLogInfo testLogInfo,
ITestConsoleAccess extraConsoleAccess)
{
// Intialize the singleton
new PNUnitServices(testInfo, services, consoleAccess, testLogInfo);
if (extraConsoleAccess != null)
{
PNUnitServices.Get().RegisterConsole(extraConsoleAccess);
}
}
Process Run(PNUnitTestInfo testInfo, string testInfoPath)
{
if (!mbUsePreload || !AssemblyPreload.CanUsePreload(testInfo.AssemblyName))
{
return(LaunchTestRunner(testInfo, testInfoPath));
}
Process result = LaunchPreloaded(testInfoPath);
if (result != null)
{
return(result);
}
return(LaunchTestRunner(testInfo, testInfoPath));
}
TestResult RunTest(
PNUnitTestInfo testInfo,
ConsoleWriter outStream,
TestRunner testRunner)
{
EventListener collector = new EventCollector(outStream);
ITestFilter filter = new NUnit.Core.Filters.SimpleNameFilter(
testInfo.TestToRun);
TestResult result = testRunner.Run(
collector, filter, true, LoggingThreshold.All);
result = FindResult(testInfo.TestToRun, result);
return(result);
}
internal static PNUnitTestResult BuildResult(
PNUnitTestInfo pnunittestinfo,
TestResult result,
TestConsoleAccess consoleAccess,
TestLogInfo testLogInfo)
{
string output = pnunittestinfo.GetTestOutput();
pnunittestinfo.DeleteTestOutput();
mLog.Debug("Going to build the result ...");
if (result == null)
{
mLog.Debug("Going to build an error result ...");
TestName testName = new TestName();
testName.Name = pnunittestinfo.TestName;
testName.FullName = pnunittestinfo.TestName;
testName.TestID = new TestID();
string errorMsg = string.Format(
"The test {0} couldn't be found in the assembly {1}",
pnunittestinfo.TestToRun,
pnunittestinfo.AssemblyName);
PNUnitTestResult testResult = new PNUnitTestResult(
testName,
output,
testLogInfo.OSVersion,
testLogInfo.BackendType);
testResult.Failure(errorMsg, string.Empty);
return(testResult);
}
PNUnitTestResult myResult = new PNUnitTestResult(result, output,
testLogInfo.OSVersion, testLogInfo.BackendType);
return(myResult);
}
public void Run(object state)
{
InitServices.InitNUnitServices();
PNUnitTestInfo testInfo = TestInfoReader.ReadTestInfo(mTestInfoFile);
if (testInfo == null)
{
Console.Error.WriteLine("Cannot execute tests without information. Exiting...");
mGuiFinalizer.Finalize(1);
}
IPNUnitServices services = GetPNUnitServices(testInfo.PNUnitServicesServer);
PNUnitTestRunner.PNUnitTestRunner runner =
new PNUnitTestRunner.PNUnitTestRunner(mPathToAssemblies);
runner.Run(testInfo, services, mGuiConsole);
GuiTestAssemblyResolver.UninstallAssemblyResolver();
mGuiFinalizer.Finalize(1);
}
static void RunOnce(string testInfoFile, string pathToAssemblies)
{
PNUnitTestInfo info = TestInfoReader.ReadTestInfo(testInfoFile);
if (info == null)
{
Console.WriteLine("Cannot execute tests without information; exiting ...");
Environment.Exit(1);
}
ProcessNameSetter.SetProcessName(info.TestName);
IPNUnitServices services =
PNUnitServices.GetPNunitServicesProxy(info.PNUnitServicesServer);
if (info.TestName.StartsWith("run-nunit"))
{
new NUnitTestRunner(info, pathToAssemblies).Run(services);
return;
}
new PNUnitTestRunner(pathToAssemblies).Run(info, services, null);
}
internal static Process CreateGuiApplicationRunnerProcess(
PNUnitTestInfo testInfo,
string executableName,
string testingArgs,
string pathToAssemblies)
{
if (testInfo.TestParams.Length == 0)
{
throw new Exception("The test is wrongly defined!");
}
string executablePath = Path.Combine(
pathToAssemblies, testInfo.TestParams[0]);
executablePath = Path.GetFullPath(executablePath);
string processName = Path.Combine(executablePath, executableName);
string arguments = string.Concat(testInfo.TestParams[1], " ", testingArgs);
mLog.DebugFormat(
"Running process [{0} {1}]", processName, arguments);
Console.WriteLine(processName);
Console.WriteLine(arguments);
Process testRunnerProc = new Process();
testRunnerProc.StartInfo.UseShellExecute = false;
testRunnerProc.StartInfo.FileName = processName;
testRunnerProc.StartInfo.CreateNoWindow = false;
testRunnerProc.StartInfo.WorkingDirectory = pathToAssemblies;
testRunnerProc.StartInfo.Arguments = arguments;
return(testRunnerProc);
}
TestRunner SetupTest(
PNUnitTestInfo testInfo,
IPNUnitServices services,
TestConsoleAccess consoleAccess,
TestLogInfo testLogInfo,
ITestConsoleAccess extraConsoleAccess)
{
TestRunner result;
bool testAssemblyLoaded;
if (mPreloader == null)
{
result = new SimpleTestRunner();
int ini = Environment.TickCount;
string fullAssemblyPath = Path.GetFullPath(
Path.Combine(mPathToAssemblies, testInfo.AssemblyName));
mLog.DebugFormat("Loading test assembly from {0}", fullAssemblyPath);
testAssemblyLoaded = MakeTest(result, fullAssemblyPath);
mLog.DebugFormat("Load test assembly {0} ms", Environment.TickCount - ini);
}
else
{
//if (!AssemblyPreload.CanUsePreload(testInfo.AssemblyName))
//{
// throw new Exception(
// "The preloaded and the target assembly don't match!!");
//}
result = mPreloader.TestRunner;
testAssemblyLoaded = mPreloader.TestAssemblyLoaded;
}
if (!testAssemblyLoaded)
{
mLog.InfoFormat("Unable to load test assembly {0} for test {1}",
testInfo.AssemblyName,
testInfo.TestName);
PNUnitTestResult testResult = BuildError(
testInfo, new Exception("Unable to locate tests"),
consoleAccess, testLogInfo);
services.NotifyResult(
testInfo.TestName, testResult);
return(null);
}
mLog.Debug("Test loaded, going to set CurrentDirectory");
Directory.SetCurrentDirectory(mPathToAssemblies);
mLog.Debug("Creating PNUnit services");
CreatePNUnitServices(testInfo, result, services, consoleAccess,
testLogInfo, extraConsoleAccess);
return(result);
}
private void ThreadProc()
{
log.DebugFormat(
"Thread created for TestGroup {0} with {1} tests",
mTestGroup.Name, mTestGroup.Tests.Length);
mFinish = new ManualResetEvent(false);
mBarriers = new Hashtable();
mBarriersOfTests = new Hashtable();
init = false;
RemotingServices.Marshal(this, mTestGroup.Name);
mLaunchedTests = 0;
foreach (TestConf test in mTestGroup.Tests)
{
if (test.Machine.StartsWith(agentkey))
{
test.Machine = mTestGroup.Agents[int.Parse(test.Machine.Substring(agentkey.Length))];
}
Launcher.Log(string.Format("Starting {0} test {1} on {2}",
mTestGroup.Name, test.Name, test.Machine));
// contact the machine
try
{
IPNUnitAgent agent = (IPNUnitAgent)
Activator.GetObject(
typeof(IPNUnitAgent),
string.Format(
"tcp://{0}/{1}",
test.Machine,
PNUnit.Framework.Names.PNUnitAgentServiceName));
lock ( mResultLock )
{
++mLaunchedTests;
}
PNUnitTestInfo testToRun = new PNUnitTestInfo(
test.Name, test.Assembly, test.TestToRun,
test.TestParams, this, test.StartBarrier,
test.EndBarrier, test.WaitBarriers);
testToRun.UserValues = mUserValues;
agent.RunTest(testToRun);
}
catch (Exception e)
{
Launcher.LogError(string.Format(
"An error occurred trying to contact {0} [{1}]",
test.Machine, e.Message));
lock ( mResultLock )
{
--mLaunchedTests;
}
}
}
log.DebugFormat("Thread going to wait for results for TestGroup {0}", mTestGroup.Name);
if (HasToWait())
{
// wait for all tests to end
mFinish.WaitOne();
}
log.DebugFormat("Thread going to wait for NotifyResult to finish for TestGroup {0}", mTestGroup.Name);
Thread.Sleep(500); // wait for the NotifyResult call to finish
RemotingServices.Disconnect(this);
log.DebugFormat("Thread going to finish for TestGroup {0}", mTestGroup.Name);
}
public void Run(
PNUnitTestInfo testInfo,
IPNUnitServices services,
ITestConsoleAccess extraConsoleAccess)
{
try
{
TestResult result = null;
TestRunner testRunner = null;
TestConsoleAccess consoleAccess = new TestConsoleAccess(testInfo.OutputFile);
TestLogInfo testLogInfo = new TestLogInfo();
try
{
mLog.DebugFormat("Running test {0}:{1} Assembly {2}",
testInfo.TestName,
testInfo.TestToRun,
testInfo.AssemblyName);
ConsoleWriter outStream = new ConsoleWriter(Console.Out);
ConsoleWriter errorStream = new ConsoleWriter(Console.Error);
testRunner = SetupTest(testInfo, services, consoleAccess,
testLogInfo, extraConsoleAccess);
if (testRunner == null)
{
return;
}
mLog.DebugFormat("RunTest {0}", testInfo.TestName);
PrintSeparator();
try
{
result = RunTest(testInfo, outStream, testRunner);
}
catch (Exception e)
{
mLog.ErrorFormat("Error running test {0}. {1}", testInfo.TestName, e.Message);
mLog.Debug(e.StackTrace);
result = BuildError(testInfo, e, consoleAccess, testLogInfo);
}
}
catch (Exception e)
{
mLog.ErrorFormat("Error launching tests: {0}", e.Message);
mLog.Debug(e.StackTrace);
result = BuildError(testInfo,
e, consoleAccess, testLogInfo);
}
finally
{
mLog.InfoFormat("Notifying the results {0}",
testInfo.TestName);
PNUnitTestResult pnunitResult = BuildResult(
testInfo,
result, consoleAccess, testLogInfo);
mLog.DebugFormat("Result built!! Now, notify the launcher ... {0}",
testInfo.TestName);
try
{
services.NotifyResult(
testInfo.TestName, pnunitResult);
mLog.DebugFormat("<-Results NOTIFIED - {0}",
testInfo.TestName);
}
catch (Exception e)
{
mLog.ErrorFormat(
"Error notifying back the result of test {0}. {1}",
testInfo.TestName, e.Message);
mLog.Error(
"If you're using a custom launcher.remoting.conf" +
" check that you've defined the binaryFormatter");
}
result = null;
UnloadTests(testRunner);
}
}
catch (Exception ex)
{
mLog.ErrorFormat("Error running test {0} {1}",
testInfo.TestName, ex.Message);
mLog.Debug(ex.StackTrace);
}
}
public PNUnitTestRunner(PNUnitTestInfo info, AgentConfig config)
{
mConfig = config;
mPNUnitTestInfo = info;
}
internal RunningTest(Process p, PNUnitTestInfo info)
{
TestProcess = p;
TestInfo = info;
}
