public void SetUp() { _test = new TestMethod(new MethodWrapper(typeof(DummySuite), "DummyMethod")); _testResult = _test.MakeTestResult(); _suite = new TestSuite(typeof(DummySuite)); _suiteResult = (TestSuiteResult)_suite.MakeTestResult(); }
public void SaveTestResults(TestSuiteResult testSuiteResult) { if (testSuiteResult == null) { throw new ArgumentException("The parameter 'testSuiteResult' cannot be null"); } // // Turn off current performance test on this thread so we don't log the // statistics for this save -- the added TimingData records will cause // problems in the save to the database since the IDs won't be set // TestResult tr = GetCurrentTestResult(); SetCurrentTestResult(null); // Save test results perfTestDAL.SaveTestResults(testSuiteResult); // Resume any performance testing SetCurrentTestResult(tr); }
private TestSuiteResult MockSuiteResult(string suiteName, bool failure) { TestSuiteResult result = new TestSuiteResult(suiteName); result.Time = time; result.RunState = RunState.Executed; TestSuiteResult level1SuiteA = new TestSuiteResult("level 1 A"); result.AddResult(level1SuiteA); level1SuiteA.RunState = RunState.Executed; TestSuiteResult level1SuiteB = new TestSuiteResult("level 1 B"); result.AddResult(level1SuiteB); level1SuiteB.RunState = RunState.Executed; testCase = new TestCaseResult("a test case"); if (failure) { testCase.Failure("argument exception", null); } else { testCase.Success(); } level1SuiteA.AddResult(testCase); testCase = new TestCaseResult("a successful test"); testCase.Success(); level1SuiteB.AddResult(testCase); testCase = new TestCaseResult("a not run test"); testCase.Ignore("test not run"); level1SuiteB.AddResult(testCase); return(result); }
/// <inheritDoc/> public virtual void SaveTestResults(TestSuiteResult testSuiteResult) { // Set parent objects in children if not already set foreach (TestResult testResult in testSuiteResult.TestResultList) { if (testResult.TestSuiteResult == null) testResult.TestSuiteResult = testSuiteResult; foreach (TimingData timingData in testResult.TimingDataList.Where( timingData => timingData.TestResult == null)) { timingData.TestResult = testResult; } } foreach (SystemInfo systemInfo in testSuiteResult.SystemInfoList.Where( systemInfo => systemInfo.TestSuiteResult == null)) { systemInfo.TestSuiteResult = testSuiteResult; } // Cascades save to persist/update children performance test data as well ISession session = sessionFactory.GetCurrentSession(); session.Save(testSuiteResult); }
private TestSuiteTreeNode AddTreeNodes(IList nodes, TestResult rootResult, bool highlight) { TestSuiteTreeNode node = new TestSuiteTreeNode(rootResult); AddToMap(node); nodes.Add(node); TestSuiteResult suiteResult = rootResult as TestSuiteResult; if (suiteResult != null) { foreach (TestResult result in suiteResult.Results) { AddTreeNodes(node.Nodes, result, highlight); } } node.UpdateImageIndex(); return(node); }
public bool Run(TestInfo test, TestSuiteResult suite_result, string test_name, EventListener listener, ITestFilter filter, int timeout) { listener = new ProxyListener(listener); TestRunnerDelegate runner = new TestRunnerDelegate(delegate { return(server.Run(test_name, listener, filter)); }); IAsyncResult ar = runner.BeginInvoke(test_name, null, filter, null, null); if (!ar.AsyncWaitHandle.WaitOne(timeout) || !ar.IsCompleted) { TestCaseResult error = new TestCaseResult(test); string msg = String.Format("Timeout after {0} ms", timeout); error.Failure(msg, null, FailureSite.Parent); suite_result.AddResult(error); return(false); } try { TestResult result = runner.EndInvoke(ar); if (result != null) { suite_result.AddResult(result); return(true); } TestCaseResult error = new TestCaseResult(test); error.Failure("Unknown error", null, FailureSite.Parent); suite_result.AddResult(error); return(false); } catch (Exception ex) { TestCaseResult error = new TestCaseResult(test); string msg = String.Format("Unknown exception: {0}", ex); error.Failure(msg, null, FailureSite.Parent); suite_result.AddResult(error); return(false); } }
void OutputSuiteResult(TestSuiteResult result) { if (!(result.Test is TestFixture)) { return; } var label = new Label { Text = $"{result.Name} Finished.", LineBreakMode = LineBreakMode.HeadTruncation }; var counts = new Label { Text = $"Passed: {result.PassCount}; Failed: {result.FailCount}; Inconclusive: {result.InconclusiveCount}" }; if (result.FailCount > 0) { label.TextColor = _failColor; _runFailed = true; } else if (result.InconclusiveCount > 0) { label.TextColor = _inconclusiveColor; _runInconclusive = true; } else { label.TextColor = _successColor; SetupPassedLabelBindings(label); SetupPassedLabelBindings(counts); } counts.TextColor = label.TextColor; Device.BeginInvokeOnMainThread(() => { Results.Children.Add(label); Results.Children.Add(counts); }); }
public Task <TestSuiteResult> RunTestsAsync(string dllPath) { var directoryPath = Path.GetDirectoryName(dllPath); return(Task.Run(() => { using (var command = Command.Run( GetDotNetExe(), new[] { "vstest", dllPath, $"--logger:trx;LogFileName={_resultId}", $"--ResultsDirectory:{directoryPath}" }, o => { o.StartInfo(si => { si.CreateNoWindow = true; si.UseShellExecute = false; si.RedirectStandardError = true; si.RedirectStandardInput = true; si.RedirectStandardOutput = true; }); o.DisposeOnExit(); })) { var success = ReadToEnd(command.StandardError, out var error); if (!success) { command.Kill(); } if (!success || (!command.Result.Success && !error.ToLower().Contains("test run failed"))) { return TestSuiteResult.Error(error, TimeSpan.Zero); } return CreateResult(Path.GetFileNameWithoutExtension(dllPath), directoryPath); } })); }
public static TestResult Find(string name, TestResult result) { if (result.Test.TestName.Name == name) { return(result); } TestSuiteResult suiteResult = result as TestSuiteResult; if (suiteResult != null) { foreach (TestResult r in suiteResult.Results) { TestResult myResult = Find(name, r); if (myResult != null) { return(myResult); } } } return(null); }
public void Visit(TestSuiteResult suiteResult) { xmlWriter.WriteStartElement("test-suite"); xmlWriter.WriteAttributeString("name", suiteResult.Name); if (suiteResult.Description != null) { xmlWriter.WriteAttributeString("description", suiteResult.Description); } xmlWriter.WriteAttributeString("success", suiteResult.IsSuccess.ToString()); xmlWriter.WriteAttributeString("time", suiteResult.Time.ToString()); xmlWriter.WriteAttributeString("asserts", suiteResult.AssertCount.ToString()); WriteCategories(suiteResult); xmlWriter.WriteStartElement("results"); foreach (TestResult result in suiteResult.Results) { result.Accept(this); } xmlWriter.WriteEndElement(); xmlWriter.WriteEndElement(); }
private TestResult findResult(string name, TestResult result) { if (result.Test.Name == name) { return(result); } TestSuiteResult suiteResult = result as TestSuiteResult; if (suiteResult != null) { foreach (TestResult r in suiteResult.Results) { TestResult myResult = findResult(name, r); if (myResult != null) { return(myResult); } } } return(null); }
private void MarkTestFailed( Test test, TestSuiteResult suiteResult, EventListener listener, ITestFilter filter) { if (test is TestSuite) { listener.SuiteStarted(test.TestName); TestSuiteResult result = new TestSuiteResult(new TestInfo(test), test.TestName.FullName); string msg = string.Format("Parent SetUp failed in {0}", this.FixtureType.Name); result.Failure(msg, null, FailureSite.Parent); MarkTestsFailed(test.Tests, suiteResult, listener, filter); suiteResult.AddResult(result); listener.SuiteFinished(result); } else { listener.TestStarted(test.TestName); TestCaseResult result = new TestCaseResult(new TestInfo(test)); string msg = string.Format("TestFixtureSetUp failed in {0}", this.FixtureType.Name); result.Failure(msg, null, FailureSite.Parent); suiteResult.AddResult(result); listener.TestFinished(result); } }
public virtual TestResult Run(EventListener listener, ITestFilter filter) { // Save active listener for derived classes this.listener = listener; ITest[] tests = new ITest[runners.Length]; for (int index = 0; index < runners.Length; index++) { tests[index] = runners[index].Test; } this.listener.RunStarted(this.Test.TestName.Name, this.CountTestCases(filter)); this.listener.SuiteStarted(this.Test.TestName); long startTime = DateTime.Now.Ticks; TestSuiteResult result = new TestSuiteResult(new TestInfo(testName, tests), projectName); result.RunState = RunState.Executed; foreach (TestRunner runner in runners) { result.Results.Add(runner.Run(this, filter)); } long stopTime = DateTime.Now.Ticks; double time = ((double)(stopTime - startTime)) / (double)TimeSpan.TicksPerSecond; result.Time = time; this.listener.SuiteFinished(result); this.listener.RunFinished(result); this.testResult = result; return(result); }
/// <inheritdoc /> public async Task <ITestResult> GetTestResultsAsync(Assembly assembly) { if (assembly == null) { throw ExceptionHelper.ThrowArgumentNullException(nameof(assembly)); } Task <ITestResult> task = Task.Run(() => { lock (TestSuite) { TestSuiteResult results = new TestSuiteResult(TestSuite); ITestAssemblyRunner runner = TestSuite.GetTestAssemblyRunner(assembly); if (runner?.Result != null) { results.AddResult(runner.Result); } return((ITestResult)results); } }); return(await task.ConfigureAwait(false)); }
public void HandleExceptionInFixtureConstructor() { TestSuite suite = TestBuilder.MakeFixture(typeof(ExceptionInConstructor)); TestSuiteResult result = (TestSuiteResult)suite.Run(NullListener.NULL); // should have one suite and one fixture ResultSummarizer summ = new ResultSummarizer(result); Assert.AreEqual(1, summ.ResultCount); Assert.AreEqual(0, summ.TestsNotRun); Assert.AreEqual(0, summ.SuitesNotRun); Assert.IsTrue(result.Executed, "Suite should have executed"); Assert.IsTrue(result.IsFailure, "Suite should have failed"); Assert.AreEqual("System.Exception : This was thrown in constructor", result.Message, "TestSuite Message"); Assert.IsNotNull(result.StackTrace, "TestSuite StackTrace should not be null"); TestResult testResult = ((TestResult)result.Results[0]); Assert.IsTrue(testResult.Executed, "Testcase should have executed"); Assert.AreEqual("TestFixtureSetUp failed in ExceptionInConstructor", testResult.Message, "TestSuite Message"); Assert.AreEqual(FailureSite.Parent, testResult.FailureSite); Assert.AreEqual(testResult.StackTrace, testResult.StackTrace, "TestCase stackTrace should match TestSuite stackTrace"); }
public void RerunFixtureAfterTearDownFixed() { MisbehavingFixtureTearDown testFixture = new MisbehavingFixtureTearDown(); TestSuite suite = new TestSuite("ASuite"); suite.Add(testFixture); TestSuiteResult result = (TestSuiteResult)suite.Run(NullListener.NULL); Assert.AreEqual(1, result.Results.Count); // should have one suite and one fixture ResultSummarizer summ = new ResultSummarizer(result); Assert.AreEqual(1, summ.ResultCount); Assert.AreEqual(0, summ.TestsNotRun); Assert.AreEqual(0, summ.SuitesNotRun); testFixture.blowUp = false; result = (TestSuiteResult)suite.Run(NullListener.NULL); summ = new ResultSummarizer(result); Assert.AreEqual(1, summ.ResultCount); Assert.AreEqual(0, summ.TestsNotRun); Assert.AreEqual(0, summ.SuitesNotRun); }
public void HandleErrorInFixtureTearDown() { MisbehavingFixtureTearDown testFixture = new MisbehavingFixtureTearDown(); TestSuite suite = new TestSuite("ASuite"); suite.Add(testFixture); TestSuiteResult result = (TestSuiteResult)suite.Run(NullListener.NULL); Assert.AreEqual(1, result.Results.Count); TestResult failedResult = ((TestResult)result.Results[0]); Assert.IsTrue(failedResult.Executed, "Suite should have executed"); Assert.IsTrue(failedResult.IsFailure, "Suite should have failed"); Assert.AreEqual("This was thrown from fixture teardown", failedResult.Message); Assert.IsNotNull(failedResult.StackTrace, "StackTrace should not be null"); // should have one suite and one fixture ResultSummarizer summ = new ResultSummarizer(result); Assert.AreEqual(1, summ.ResultCount); Assert.AreEqual(0, summ.TestsNotRun); Assert.AreEqual(0, summ.SuitesNotRun); }
private static TestResult ExecuteSuiteCommand(TestSuiteCommand command, TestExecutionContext context) { TestSuiteResult testSuiteResult = context.CurrentResult as TestSuiteResult; Debug.Assert(testSuiteResult != null); bool flag = false; try { ApplyTestSettingsToExecutionContext(command.Test, context); command.DoOneTimeSetUp(context); flag = true; context.Update(); testSuiteResult = RunChildCommands(command, context); } catch (Exception innerException) { if (innerException is NUnitException || innerException is TargetInvocationException) { innerException = innerException.InnerException; } if (flag) { testSuiteResult.RecordException(innerException); } else { testSuiteResult.RecordException(innerException, FailureSite.SetUp); } } finally { command.DoOneTimeTearDown(context); } return(testSuiteResult); }
//private TestCaseResult testCase; private TestSuiteResult MockSuiteResult(bool failure) { TestCaseResult testCaseResult = new TestCaseResult("a test case"); if (failure) { testCaseResult.Failure("case failed", null); } TestSuiteResult level1SuiteA = new TestSuiteResult("level 1 A"); level1SuiteA.AddResult(testCaseResult); TestSuiteResult level1SuiteB = new TestSuiteResult("level 1 B"); level1SuiteB.AddResult(new TestCaseResult("a successful test")); TestSuiteResult result = new TestSuiteResult("base"); result.AddResult(level1SuiteA); result.AddResult(level1SuiteB); return(result); }
public void HandleErrorInFixtureTearDown() { MisbehavingFixture fixture = new MisbehavingFixture(); fixture.blowUpInTearDown = true; TestSuiteResult result = RunTestOnFixture(fixture); Assert.AreEqual(1, result.Results.Count); Assert.IsTrue(result.Executed, "Suite should have executed"); Assert.IsTrue(result.IsFailure, "Suite should have failed"); Assert.AreEqual(1, fixture.setUpCount, "setUpCount"); Assert.AreEqual(1, fixture.tearDownCount, "tearDownCOunt"); Assert.AreEqual("This was thrown from fixture teardown", result.Message); Assert.IsNotNull(result.StackTrace, "StackTrace should not be null"); // should have one suite and one fixture ResultSummarizer summ = new ResultSummarizer(result); Assert.AreEqual(1, summ.ResultCount); Assert.AreEqual(0, summ.TestsNotRun); Assert.AreEqual(0, summ.SuitesNotRun); }
private TestSuiteResult CreateTestSuiteResult(string annotation) { // Create object to hold test run results TestSuiteResult testSuiteResult = new TestSuiteResult(currentUserSvc.GetCurrentUserData().UserId); // Set user-supplied annotation for test run testSuiteResult.Annotation = annotation; // Set system info for this test run SetSystemInfo(testSuiteResult); // Set start time after getting system info so it doesn't affect results testSuiteResult.StartTime = DateTime.Now; return testSuiteResult; }
public void SuiteFinished(TestSuiteResult result) { this.listener.SuiteFinished(result); }
public void SuiteFinished(TestSuiteResult result) { Console.Out.WriteLine(); }
private static void SetSystemInfo(TestSuiteResult testSuiteResult) { const string componentCpu = "CPU"; const string componentRam = "RAM"; IDictionary<string, IDictionary<string, string[]>> systemInfoKeys = new Dictionary<string, IDictionary<string, string[]>>(); systemInfoKeys["Win32_ComputerSystem"] = new Dictionary<string, string[]> { { componentRam, new string[] { "TotalPhysicalMemory" } } }; systemInfoKeys["Win32_Processor"] = new Dictionary<string, string[]> { { componentCpu, new string[] {"Manufacturer","AddressWidth","Description","Name","MaxClockSpeed"} }, }; systemInfoKeys["Win32_PerfFormattedData_PerfOS_Processor"] = new Dictionary<string, string[]> { { componentCpu, new string[] {"PercentIdleTime"} }, }; foreach (string key in systemInfoKeys.Keys) { IDictionary<string, string[]> wmiKeys = systemInfoKeys[key]; ManagementObjectSearcher search = new ManagementObjectSearcher("select * from " + key); foreach (ManagementObject wmiObj in search.Get()) { foreach (string key2 in wmiKeys.Keys) { foreach (string key3 in wmiKeys[key2]) { try { testSuiteResult.SystemInfoList.Add(new SystemInfo(key2, key3, wmiObj[key3].ToString())); } catch { // Ignore exception -- probably means data is not available } } } } } // Get current CPU utilization PerformanceCounter cpuCounter = new PerformanceCounter(); cpuCounter.CategoryName = "Processor"; cpuCounter.CounterName = "% Processor Time"; cpuCounter.InstanceName = "_Total"; testSuiteResult.SystemInfoList.Add(new SystemInfo(componentCpu, "CPU Usage", cpuCounter.NextValue() + "%")); // Get current available RAM PerformanceCounter ramCounter = new PerformanceCounter("Memory", "Available MBytes"); testSuiteResult.SystemInfoList.Add(new SystemInfo("RAM", "Available RAM", ramCounter.NextValue() + "MB")); }
public void SuiteFinished(TestSuiteResult result) { suiteFinished++; }
public override void Run(IList <TestAssemblyInfo> testAssemblies) { if (testAssemblies == null) { throw new ArgumentNullException(nameof(testAssemblies)); } if (AssemblyFilters == null || AssemblyFilters.Count == 0) { runAssemblyByDefault = true; } else { runAssemblyByDefault = AssemblyFilters.Values.Any(v => !v); } var builder = new NUnitLiteTestAssemblyBuilder(); var runner = new NUnitLiteTestAssemblyRunner(builder, new FinallyDelegate()); var testSuite = new TestSuite(NSBundle.MainBundle.BundleIdentifier); results = new TestSuiteResult(testSuite); TotalTests = 0; foreach (TestAssemblyInfo assemblyInfo in testAssemblies) { if (assemblyInfo == null || assemblyInfo.Assembly == null || !ShouldRunAssembly(assemblyInfo)) { continue; } if (!runner.Load(assemblyInfo.Assembly, builderSettings)) { OnWarning($"Failed to load tests from assembly '{assemblyInfo.Assembly}"); continue; } if (runner.LoadedTest is NUnitTest tests) { TotalTests += tests.TestCaseCount; testSuite.Add(tests); } // Messy API. .Run returns ITestResult which is, in reality, an instance of TestResult since that's // what WorkItem returns and we need an instance of TestResult to add it to TestSuiteResult. So, cast // the return to TestResult and hope for the best. ITestResult result = null; try { OnAssemblyStart(assemblyInfo.Assembly); result = runner.Run(this, Filter); } finally { OnAssemblyFinish(assemblyInfo.Assembly); } if (result == null) { continue; } var testResult = result as TestResult; if (testResult == null) { throw new InvalidOperationException($"Unexpected test result type '{result.GetType ()}'"); } results.AddResult(testResult); } // NUnitLite doesn't report filtered tests at all, but we can calculate here FilteredTests = TotalTests - ExecutedTests; LogFailureSummary(); }
public void SuiteFinished(TestSuiteResult result) { foreach( EventListener listener in extensions ) listener.SuiteFinished( result ); }
/// <summary> /// Trigger event when each suite finishes /// </summary> /// <param name="result">Result of the suite that finished</param> void EventListener.SuiteFinished(TestSuiteResult result) { events.FireSuiteFinished(result); }
private void writeTestSuiteResultToFile(TestSuiteResult testSuiteResult) { TestSuiteResult.SerializeToFile(testSuiteResult, string.Format("{0}\\{1} - {2}.xml", _metricsFolder, testSuiteResult.VirtualUser, testSuiteResult.TestVerdict)); }
public void Visit(TestSuiteResult suiteResult) { Console.WriteLine(suiteResult.Name); if(suiteResult.Name.Equals(name)) Assert.AreEqual(description, suiteResult.Description); foreach (TestResult result in suiteResult.Results) { result.Accept(this); } }
public void SuiteFinished(TestSuiteResult result) { wrapped.SuiteFinished(GetTestName(result.Test.TestName), GetLocalTestResult(result)); }
public override void OnTestSuiteExecutionComplete(TestSuite testSuite, TestSuiteResult testSuiteResult) { throw new NotImplementedException(); }
/// <summary> /// Construct a CompositeWorkItem for executing a test suite /// using a filter to select child tests. /// </summary> /// <param name="suite">The TestSuite to be executed</param> /// <param name="childFilter">A filter used to select child tests</param> public CompositeWorkItem(TestSuite suite, ITestFilter childFilter) : base(suite, childFilter) { _suite = suite; _suiteResult = Result as TestSuiteResult; }
private void RunTestsInAssembly(string assemblyName, TestSuiteResult testSuiteResult) { // Load given assembly Assembly assembly = Assembly.Load(assemblyName); // Pass empty object to performance test methods object[] parms = new object[] { }; // Loop through non-abstract types in given assembly foreach (Type type in assembly.GetTypes().Where(type => !type.IsAbstract)) { // Create instance of type object instance; try { instance = Activator.CreateInstance(type); } catch (Exception e) { logger.Error("Caught exception in creating type " + type + " in assembly " + assemblyName, e); // Continue on to next type continue; } // Make sure instance implements required interface IPerfTestApp perfTestApp = instance as IPerfTestApp; if (perfTestApp == null) { logger.Warn("Type does not support required interface: " + type + " in assembly " + assemblyName); // Continue on to next type continue; } // Run setup method try { perfTestApp.Setup(); } catch (Exception e) { logger.Error("Caught exception in running setup for " + type + " in assembly " + assemblyName, e); // Continue on to next type continue; } // Run all performance tests foreach (MethodInfo method in type.GetMethods().Where( method => HasAttribute(method, typeof(PerfTestAttribute)))) { // // Create new test result data and set in thread local storage so it // can be accessed anywhere in stack // DateTime endTime = default(DateTime); TestResult testResult = SetupCurrentTest(testSuiteResult, string.Empty, type.Name, method.Name); try { // Run performance test for this method method.Invoke(instance, parms); // Gather end time before running stats so it doesn't affect perf time endTime = DateTime.Now; // Gather stats try { testResult.Annotation = (string.IsNullOrEmpty(testResult.Annotation)) ? "" : ", "; testResult.Annotation += perfTestApp.GetStats(); } catch (Exception e) { logger.Error("Caught exception in gathering stats for " + type + " in assembly " + assemblyName, e); } } catch (Exception e) { logger.Error("Caught exception in running perf test for " + type + " in assembly " + assemblyName, e); // Test failed testResult.IsSuccess = false; } finally { ClearCurrentTest(testResult, endTime); } } // Run tear down method try { perfTestApp.TearDown(); } catch (Exception e) { logger.Error("Caught exception in running tear down for " + type + " in assembly " + assemblyName, e); } } }
public void AddNewTestSuiteResult(TestSuiteResult testsuiteResult) { _testSuiteResults.Add(testsuiteResult); }
private void SaveTestSuiteResult(TestSuiteResult testSuiteResult) { // // Put mutex on this instance of test suite results in case multiple threads // are trying to persist it // lock (testSuiteResult) { perfTestSvc.SaveTestResults(testSuiteResult); } }
public override void OnTestSuiteExecutionComplete(TestSuite testSuite, TestSuiteResult testSuiteResult) { Debug.WriteLine("SampleTestListener2 method: " + MethodInfo.GetCurrentMethod().Name); }
private TestResult SetupCurrentTest(TestSuiteResult testSuiteResult, string annotation, string typeName, string methodName) { // Add a new test data instance to test run results for this perf test TestResult testResult = new TestResult(typeName, methodName); testResult.Annotation = annotation; // // Put mutex on this instance of test suite results in case multiple threads // are trying to access it // lock (testSuiteResult) { testSuiteResult.TestResultList.Add(testResult); } // // Set current test data results object in thread local storage so it // can be accessed anywhere in stack // perfTestSvc.SetCurrentTestResult(testResult); return testResult; }
public void SuiteFinished(TestSuiteResult result) { suiteFinished.Add(result.Name); }
public Task <TestSuiteResult> RunTestsAsync(string runner, string dllPath, string dotNetPath, TimeSpan maxTime) { return(Task.Run(() => { var allArguments = new List <string> { runner, dllPath, dotNetPath }; try { using (var command = Command.Run( "Unima.TestRunner.Console.exe", allArguments, o => { o.StartInfo(si => { si.CreateNoWindow = true; si.UseShellExecute = false; si.RedirectStandardError = true; si.RedirectStandardInput = true; si.RedirectStandardOutput = true; }); o.Timeout(maxTime); o.DisposeOnExit(); })) { var output = command.StandardOutput.ReadToEnd(); var error = command.StandardError.ReadToEnd(); try { if (!command.Result.Success) { LogTo.Info($"Message from test client - {output}."); LogTo.Info($"Error from test client - {error}."); return new TestSuiteResult { IsSuccess = false, Name = $"ERROR - {error}", ExecutionTime = TimeSpan.Zero, TestResults = new List <TestResult>() }; } } catch (TimeoutException) { LogTo.Info("Test client timed out. Infinit loop?"); return TestSuiteResult.Error("TIMEOUT", maxTime); } return JsonConvert.DeserializeObject <TestSuiteResult>(output); } } catch (Win32Exception ex) { LogTo.ErrorException("Unknown expcetion from test client process", ex); throw; } })); }
public void SuiteFinished(TestSuiteResult suiteResult) { }
void EventListener.SuiteFinished(TestSuiteResult nunitResult)