private int ExploreTests(TestPackage package, TestFilter filter)
{
ITestEngineResult engineResult = engine.Explore(package, filter);
int returnCode = ConsoleRunner.OK;
if (engineResult.HasErrors)
{
DisplayErrorMessages(engineResult);
returnCode = ConsoleRunner.UNEXPECTED_ERROR;
}
else if (options.ExploreOutputSpecifications.Count == 0)
{
new TestCaseOutputWriter().WriteResultFile(engineResult.Xml, Console.Out);
}
else
{
var outputManager = new OutputManager(engineResult.Xml, this.workDirectory);
foreach (OutputSpecification spec in options.ExploreOutputSpecifications)
{
outputManager.WriteTestFile(spec);
}
}
return(returnCode);
}
/// <summary>
/// Runs tests specified in the test package, applying
/// the supplied filter.
/// </summary>
/// <param name="package">A TestPackage.</param>
/// <param name="filter">A TestFilter (currently ignored)</param>
/// <returns>An XmlNode representing the test results.</returns>
public ITestEngineResult Run(TestPackage package, ITestEventHandler listener, TestFilter filter)
{
using (ITestRunner runner = GetRunner())
{
ITestEngineResult loadResult = runner.Load(package);
return(loadResult.HasErrors
? loadResult
: runner.Run(listener, filter));
}
}
/// <summary>
/// Returns an xml representation of the tests specified
/// by a TestPackage.
/// </summary>
/// <param name="package">A TestPackage.</param>
/// <returns>An XmlNode representing the tests.</returns>
public ITestEngineResult Explore(TestPackage package, TestFilter filter)
{
using (ITestRunner runner = GetRunner())
{
ITestEngineResult loadResult = runner.Load(package);
return(loadResult.HasErrors
? loadResult
: runner.Explore(filter));
}
}
private static string CreateXmlOutput(ITestEngineResult result)
{
StringBuilder builder = new StringBuilder();
XmlTextWriter writer = new XmlTextWriter(new StringWriter(builder));
writer.Formatting = Formatting.Indented;
result.Xml.WriteTo(writer);
writer.Close();
return(builder.ToString());
}
private static void DisplayErrorMessages(ITestEngineResult errorReport)
{
foreach (TestEngineError error in errorReport.Errors)
{
if (error.Message != null)
{
ColorConsole.WriteLine(ColorStyle.Error, "Load failure: " + error.Message);
if (error.StackTrace != null)
{
ColorConsole.WriteLine(ColorStyle.Error, error.StackTrace);
}
}
}
}
/// <summary>
/// Load a TestPackage for possible execution
/// </summary>
/// <param name="package">The TestPackage to be loaded</param>
/// <returns>A TestEngineResult.</returns>
public override TestEngineResult Load(TestPackage package)
{
log.Info("Loading " + package.Name);
Unload();
this.package = package;
string frameworkSetting = package.GetSetting("RuntimeFramework", "");
this.runtimeFramework = frameworkSetting != ""
? RuntimeFramework.Parse(frameworkSetting)
: RuntimeFramework.CurrentFramework;
bool enableDebug = package.GetSetting("AgentDebug", false);
bool verbose = package.GetSetting("Verbose", false);
string agentArgs = string.Empty;
if (enableDebug)
{
agentArgs += " --pause";
}
if (verbose)
{
agentArgs += " --verbose";
}
bool loaded = false;
try
{
CreateAgentAndRunner(enableDebug, agentArgs);
ITestEngineResult result = this.remoteRunner.Load(package);
loaded = !result.HasErrors;
return(result as TestEngineResult); // TODO: Remove need for this cast
}
finally
{
// Clean up if the load failed
if (!loaded)
{
Unload();
}
}
}
private int RunTests(TestPackage package, TestFilter filter)
{
// TODO: We really need options as resolved by engine for most of these
DisplayRequestedOptions();
// TODO: Incorporate this in EventCollector?
RedirectOutputAsRequested();
TestEventHandler eventHandler = new TestEventHandler(options, outWriter, errorWriter);
ITestEngineResult engineResult = null;
// Save things that might be messed up by a bad test
TextWriter savedOut = Console.Out;
TextWriter savedError = Console.Error;
DateTime startTime = DateTime.Now;
try
{
using (new ColorConsole(ColorStyle.Output))
#if true
engineResult = engine.Run(package, eventHandler, filter);
#else
using (ITestRunner runner = engine.GetRunner(package))
{
if (runner.Load(package))
{
engineResult = runner.Run(eventHandler, testFilter);
}
}
#endif
}
finally
{
Console.SetOut(savedOut);
Console.SetError(savedError);
RestoreOutput();
}
//Console.WriteLine();
int returnCode = UNEXPECTED_ERROR;
if (engineResult.HasErrors)
{
DisplayErrorMessages(engineResult);
}
else
{
ResultReporter reporter = new ResultReporter(engineResult.Xml, options);
reporter.ReportResults();
// TODO: Inject this?
var outputManager = new OutputManager(engineResult.Xml, this.workDirectory);
foreach (var outputSpec in options.ResultOutputSpecifications)
{
outputManager.WriteResultFile(outputSpec, startTime);
}
returnCode = reporter.Summary.ErrorsAndFailures;
//if ( collector.HasExceptions )
//{
// collector.WriteExceptions();
// returnCode = UNEXPECTED_ERROR;
//}
}
return(returnCode);
}
/// <summary>
/// Explore a TestPackage and return information about
/// the tests found.
/// </summary>
/// <param name="package">The TestPackage to be explored</param>
/// <returns>A TestEngineResult.</returns>
public override TestEngineResult Explore(TestFilter filter)
{
ITestEngineResult result = this.remoteRunner.Explore(filter);
return(result as TestEngineResult); // TODO: Remove need for this cast
}
