Only allow one runner at a time per connection to the agent by the protocol design

src/NUnitEngine/nunit.engine.core/Agents/RemoteTestAgent.cs

@@ -38,12 +38,13 @@ namespace NUnit.Engine.Agents
     /// to it. Rather, it reports back to the sponsoring TestAgency upon
     /// startup so that the agency may in turn provide it to clients for use.
     /// </summary>
-    public class RemoteTestAgent : TestAgent, ITestEngineRunner
+    public class RemoteTestAgent : MarshalByRefObject, ITestAgent, IDisposable
     {
         private static readonly Logger log = InternalTrace.GetLogger(typeof(RemoteTestAgent));
 
         private readonly Guid _agentId;
         private readonly string _agencyUrl;
+        private readonly IServiceLocator _services;
 
         private ITestEngineRunner _runner;
         private TestPackage _package;
@@ -57,22 +58,35 @@ public class RemoteTestAgent : TestAgent, ITestEngineRunner
         /// Construct a RemoteTestAgent
         /// </summary>
         public RemoteTestAgent(Guid agentId, string agencyUrl, IServiceLocator services)
-            : base(services)
         {
             _agentId = agentId;
             _agencyUrl = agencyUrl;
+            _services = services;
+        }
+
+        /// <summary>
+        /// Overridden to cause object to live indefinitely
+        /// </summary>
+        public override object InitializeLifetimeService()
+        {
+            return null;
+        }
+
+        public void Dispose()
+        {
+            ShutDown();
         }
 
         public int ProcessId
         {
             get { return System.Diagnostics.Process.GetCurrentProcess().Id; }
         }
 
-        public override ITestEngineRunner CreateRunner(TestPackage package)
+        public TestEngineResult Load(TestPackage package)
         {
             _package = package;
-            _runner = Services.GetService<ITestRunnerFactory>().MakeTestRunner(_package);
-            return this;
+            _runner = _services.GetService<ITestRunnerFactory>().MakeTestRunner(_package);
+            return _runner.Load();
         }
 
         public bool Start()
@@ -107,7 +121,7 @@ public bool Start()
             return true;
         }
 
-        public override void Stop()
+        public void ShutDown()
         {
             log.Info("Stopping");
 
@@ -187,18 +201,6 @@ public TestEngineResult Run(ITestEventListener listener, TestFilter filter)
             return _runner.Run(listener, filter);
         }
 
-        /// <summary>
-        /// Start a run of the tests in the loaded TestPackage. The tests are run
-        /// asynchronously and the listener interface is notified as it progresses.
-        /// </summary>
-        /// <param name="listener">An ITestEventHandler to receive events</param>
-        /// <param name="filter">A TestFilter used to select tests</param>
-        /// <returns>A <see cref="AsyncTestEngineResult"/> that will provide the result of the test execution</returns>
-        public AsyncTestEngineResult RunAsync(ITestEventListener listener, TestFilter filter)
-        {
-            return _runner.RunAsync(listener, filter);
-        }
-
         /// <summary>
         /// Cancel the ongoing test run. If no  test is running, the call is ignored.
         /// </summary>

src/NUnitEngine/nunit.engine.core/AsyncTestEngineResult.cs

@@ -39,6 +39,15 @@ public class AsyncTestEngineResult : ITestRun
         private volatile TestEngineResult _result;
         private readonly ManualResetEvent _waitHandle = new ManualResetEvent(false);
 
+#if !NETSTANDARD1_6
+        public static AsyncTestEngineResult RunAsync(Func<TestEngineResult> func)
+        {
+            var testRun = new AsyncTestEngineResult();
+            ThreadPool.QueueUserWorkItem(_ => testRun.SetResult(func.Invoke()));
+            return testRun;
+        }
+#endif
+
         /// <summary>
         /// Get the result of this run.
         /// </summary>

src/NUnitEngine/nunit.engine.core/ITestAgent.cs

@@ -24,18 +24,53 @@
 namespace NUnit.Engine
 {
     /// <summary>
-    /// The ITestAgent interface is implemented by remote test agents.
+    /// Defines the current communication protocol between the engine and the agent. This is an implementation detail
+    /// which is in the process of changing as the dependency on .NET Framework's remoting is removed.
     /// </summary>
     public interface ITestAgent
     {
         /// <summary>
         /// Stops the agent, releasing any resources
         /// </summary>
-        void Stop();
+        void ShutDown();
 
         /// <summary>
-        ///  Creates a test runner
+        /// Loads a package which will be used for all subsequent calls to the other methods (except
+        /// <see cref="ShutDown"/>). This method must be called at least once before calling methods that operate on a
+        /// test package. It may be called any number of times after those methods.
         /// </summary>
-        ITestEngineRunner CreateRunner(TestPackage package);
+        TestEngineResult Load(TestPackage package);
+
+        /// <summary>
+        /// Unloads any loaded package. If none is loaded, the call is ignored.
+        /// </summary>
+        void Unload();
+
+        /// <summary>
+        /// Reloads the loaded package.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">Thrown if no package is loaded.</exception>
+        TestEngineResult Reload();
+
+        /// <summary>
+        /// Counts the test cases in the loaded package that would be run under the specified filter.
+        /// </summary>
+        int CountTestCases(TestFilter filter);
+
+        /// <summary>
+        /// Runs the tests in the loaded package. The listener interface is notified as the run progresses.
+        /// </summary>
+        TestEngineResult Run(ITestEventListener listener, TestFilter filter);
+
+        /// <summary>
+        /// Cancel the current test run. If no test is running, the call is ignored.
+        /// </summary>
+        /// <param name="force">Indicates whether tests that have not completed should be killed.</param>
+        void StopRun(bool force);
+
+        /// <summary>
+        /// Returns information about the test cases in the loaded package that would be run under the specified filter.
+        /// </summary>
+        TestEngineResult Explore(TestFilter filter);
     }
 }

src/NUnitEngine/nunit.engine.core/Polyfills.cs

@@ -0,0 +1,11 @@
+#if NET20
+
+namespace System
+{
+    // This would cause conflicts if it was public in the API assembly. This is an engine implementation detail since
+    // even though it's public because this assembly should not be compiled against by anyone that references the
+    // engine.
+    public delegate TResult Func<TResult>();
+}
+
+#endif

src/NUnitEngine/nunit.engine.core/Runners/AbstractTestRunner.cs

@@ -22,8 +22,6 @@
 // ***********************************************************************
 
 using System;
-using System.ComponentModel;
-using NUnit.Engine.Services;
 
 namespace NUnit.Engine.Runners
 {
@@ -110,19 +108,7 @@ public virtual void UnloadPackage()
         /// <returns>An <see cref="AsyncTestEngineResult"/> that will provide the result of the test execution</returns>
         protected virtual AsyncTestEngineResult RunTestsAsync(ITestEventListener listener, TestFilter filter)
         {
-            var testRun = new AsyncTestEngineResult();
-
-            using (var worker = new BackgroundWorker())
-            {
-                worker.DoWork += (s, ea) =>
-                {
-                    var result = RunTests(listener, filter);
-                    testRun.SetResult(result);
-                };
-                worker.RunWorkerAsync();
-            }
-
-            return testRun;
+            return AsyncTestEngineResult.RunAsync(() => RunTests(listener, filter));
         }
 #endif
 

src/NUnitEngine/nunit.engine.tests/Services/AgentStoreTests.DummyTestAgent.cs

@@ -30,17 +30,42 @@ public partial class AgentStoreTests
     {
         private sealed class DummyTestAgent : ITestAgent
         {
-            public ITestEngineRunner CreateRunner(TestPackage package)
+            public int CountTestCases(TestFilter filter)
             {
                 throw new NotImplementedException();
             }
 
-            public bool Start()
+            public TestEngineResult Explore(TestFilter filter)
             {
                 throw new NotImplementedException();
             }
 
-            public void Stop()
+            public TestEngineResult Load(TestPackage package)
+            {
+                throw new NotImplementedException();
+            }
+
+            public TestEngineResult Reload()
+            {
+                throw new NotImplementedException();
+            }
+
+            public TestEngineResult Run(ITestEventListener listener, TestFilter filter)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void ShutDown()
+            {
+                throw new NotImplementedException();
+            }
+
+            public void StopRun(bool force)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Unload()
             {
                 throw new NotImplementedException();
             }