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 }