/// <summary> /// Cancel the ongoing test run. If no test is running, the call is ignored. /// </summary> /// <param name="force">If true, cancel any ongoing test threads, otherwise wait for them to complete.</param> public void StopRun(bool force) { _engineRunner.StopRun(force); if (force) { // Frameworks should handle StopRun(true) by cancelling all tests and notifying // us of the completion of any tests that were running. However, this feature // may be absent in some frameworks or may be broken and we may not pass on the // notifications needed by some runners. In fact, such a bug is present in the // NUnit framework through release 3.12 and motivated the following code. // // We try to make up for the potential problem here by notifying the listeners // of the completion of every pending WorkItem, that is, one that started but // never sent a completion event. if (!_eventDispatcher.WaitForCompletion(WAIT_FOR_CANCEL_TO_COMPLETE)) { _eventDispatcher.IssuePendingNotifications(); // Signal completion of the run _eventDispatcher.OnTestEvent($"<test-run id='{TestPackage.ID}' result='Failed' label='Cancelled' />"); // Since we were not notified of the completion of some items, we can't trust // that they were actually stopped by the framework. To make sure nothing is // left running, we unload the tests. By unloading only the lower-level engine // runner and not the MasterTestRunner itself, we allow the tests to be loaded // for subsequent runs using the same package. _engineRunner.Unload(); } } }
/// <summary> /// Unload any loaded TestPackage. /// </summary> public override void UnloadPackage() { if (_realRunner != null) { _realRunner.Unload(); } }
public void Unload() { if (_runner != null) { _runner.Unload(); } }
/// <summary> /// Unload any loaded TestPackage. /// </summary> private void UnloadPackage() { LoadResult = null; if (_engineRunner != null) { _engineRunner.Unload(); } }
/// <summary> /// Unload any loaded TestPackage and clear /// the reference to the remote runner. /// </summary> public override void UnloadPackage() { if (_remoteRunner != null) { log.Info("Unloading remote runner"); _remoteRunner.Unload(); _remoteRunner = null; } }
private void CommandLoop() { bool keepRunning = true; var socketReader = new SocketReader(_clientSocket, new BinarySerializationProtocol()); while (keepRunning) { var command = socketReader.GetNextMessage <CommandMessage>(); switch (command.CommandName) { case "CreateRunner": var package = (TestPackage)command.Arguments[0]; _runner = CreateRunner(package); break; case "Load": SendResult(_runner.Load()); break; case "Reload": SendResult(_runner.Reload()); break; case "Unload": _runner.Unload(); break; case "Explore": var filter = (TestFilter)command.Arguments[0]; SendResult(_runner.Explore(filter)); break; case "CountTestCases": filter = (TestFilter)command.Arguments[0]; SendResult(_runner.CountTestCases(filter)); break; case "Run": filter = (TestFilter)command.Arguments[0]; SendResult(_runner.Run(this, filter)); break; case "RunAsync": filter = (TestFilter)command.Arguments[0]; _runner.RunAsync(this, filter); break; case "Stop": keepRunning = false; break; } } Stop(); }
/// <summary> /// Unload any loaded TestPackage and clear /// the reference to the remote runner. /// </summary> public override void UnloadPackage() { if (_remoteRunner != null && TestPackage != null) { try { log.Info("Unloading " + TestPackage.Name); _remoteRunner.Unload(); } catch (Exception e) { log.Warning("Failed to unload the remote runner. {0}", ExceptionHelper.BuildMessageAndStackTrace(e)); } }
/// <summary> /// Unload any loaded TestPackage and clear /// the reference to the remote runner. /// </summary> public override void UnloadPackage() { try { if (_remoteRunner != null) { log.Info("Unloading remote runner"); _remoteRunner.Unload(); _remoteRunner = null; } } catch (Exception e) { log.Warning("Failed to unload the remote runner. {0}", e.Message); _remoteRunner = null; } }