Merge pull request #913 from nunit/issue-860

Remove DomainUsage options

Author: ChrisMaddock

src/NUnitConsole/nunit3-console.tests/BadFileTests.cs

@@ -24,11 +24,11 @@ public void MissingFileTest(string filename, string message)
             services.Add(new DriverService());
 #if NET35
             services.Add(new RuntimeFrameworkService());
+            services.Add(new DomainManager());
 #endif
 
             var package = new TestPackage(fullname);
             package.AddSetting("ProcessModel", "InProcess");
-            package.AddSetting("DomainUsage", "None");
 
             var runner = new MasterTestRunner(services, package);
 

src/NUnitConsole/nunit3-console.tests/CommandLineTests.cs

@@ -197,7 +197,6 @@ public void CanRecognizeBooleanOptions(string propertyName, string pattern)
         [TestCase("ConsoleEncoding", "encoding", new string[] { "utf-8", "ascii", "unicode" }, new string[0])]
 #if NET35
         [TestCase("ProcessModel", "process", new string[] { "InProcess", "Separate", "Multiple" }, new string[] { "JUNK" })]
-        [TestCase("DomainUsage", "domain", new string[] { "None", "Single", "Multiple" }, new string[] { "JUNK" })]
         [TestCase("Framework", "framework", new string[] { "net-4.0" }, new string[0])]
         [TestCase("ConfigurationFile", "configfile", new string[] { "mytest.config" }, new string[0] )]
         [TestCase("PrincipalPolicy", "set-principal-policy", new string[] { "UnauthenticatedPrincipal", "NoPrincipal", "WindowsPrincipal" }, new string[] { "JUNK" })]
@@ -240,7 +239,6 @@ public void CanRecognizeInProcessOption()
 
 #if NET35
         [TestCase("ProcessModel", "process", new string[] { "InProcess", "Separate", "Multiple" })]
-        [TestCase("DomainUsage", "domain", new string[] { "None", "Single", "Multiple" })]
 #endif
         [TestCase("DisplayTestLabels", "labels", new string[] { "Off", "OnOutputOnly", "Before", "After", "BeforeAndAfter" })]
         [TestCase("InternalTraceLevel", "trace", new string[] { "Off", "Error", "Warning", "Info", "Debug", "Verbose" })]
@@ -290,7 +288,6 @@ public void CanRecognizeIntOptions(string propertyName, string pattern)
         [TestCase("--encoding")]
 #if NET35
         [TestCase("--process")]
-        [TestCase("--domain")]
         [TestCase("--framework")]
 #endif
         public void MissingValuesAreReported(string option)

src/NUnitConsole/nunit3-console.tests/MakeTestPackageTests.cs

@@ -48,8 +48,6 @@ public void MultipleAssemblies()
         [TestCase("--process=Single", "ProcessModel", "InProcess")]
         [TestCase("--process=InProcess", "ProcessModel", "InProcess")]
         [TestCase("--inprocess", "ProcessModel", "InProcess")]
-        [TestCase("--domain=Multiple", "DomainUsage", "Multiple")]
-        [TestCase("--domain=multiple", "DomainUsage", "Multiple")]
         [TestCase("--framework=net-4.0", "RequestedRuntimeFramework", "net-4.0")]
         [TestCase("--configfile=mytest.config", "ConfigurationFile", "mytest.config")]
         [TestCase("--agents=5", "MaxAgents", 5)]

src/NUnitConsole/nunit3-console.tests/NetCoreConsoleOptionsTest.cs

@@ -65,7 +65,6 @@ private static IEnumerable<TestCaseData> TestCases
             "-configfile=app.config",
             "-process=Single",
             "-inprocess",
-            "-domain=Single",
             "-framework=net-3.5",
             "-x86",
             "-shadowcopy",

src/NUnitConsole/nunit3-console/ConsoleOptions.cs

@@ -124,9 +124,6 @@ public IList<OutputSpecification> ResultOutputSpecifications
         public string ProcessModel { get; private set; }
         public bool ProcessModelSpecified { get { return ProcessModel != null; } }
 
-        public string DomainUsage { get; private set; }
-        public bool DomainUsageSpecified { get { return DomainUsage != null; } }
-
         // How to Run Tests
 
         public string Framework { get; private set; }
@@ -348,9 +345,6 @@ private void ConfigureOptions()
             this.AddNetFxOnlyOption("inprocess", "Synonym for --process:InProcess",
                 NetFxOnlyOption("inprocess", v => ProcessModel = "InProcess"));
 
-            this.AddNetFxOnlyOption("domain=", "{DOMAIN} isolation for test assemblies.\nValues: None, Single, Multiple. If not specified, defaults to Single for a single assembly or Multiple for more than one.",
-                NetFxOnlyOption("domain=", v => DomainUsage = parser.RequiredValue(v, "--domain", "None", "Single", "Multiple")));
-
             // How to Run Tests
             this.AddNetFxOnlyOption("framework=", "{FRAMEWORK} type/version to use for tests.\nExamples: mono, net-3.5, v4.0, 2.0, mono-4.0. If not specified, tests will run under the framework they are compiled with.",
                 NetFxOnlyOption("framework=", v => Framework = parser.RequiredValue(v, "--framework")));

src/NUnitConsole/nunit3-console/ConsoleRunner.cs

@@ -371,9 +371,6 @@ public static TestPackage MakeTestPackage(ConsoleOptions options)
             if (options.ProcessModelSpecified)
                 package.AddSetting(EnginePackageSettings.ProcessModel, options.ProcessModel);
 
-            if (options.DomainUsageSpecified)
-                package.AddSetting(EnginePackageSettings.DomainUsage, options.DomainUsage);
-
             if (options.FrameworkSpecified)
                 package.AddSetting(EnginePackageSettings.RequestedRuntimeFramework, options.Framework);
 

src/NUnitConsole/nunit3-console/EnginePackageSettings.cs

@@ -49,14 +49,6 @@ public static class EnginePackageSettings
         /// </summary>
         public const string DebugAgent = "DebugAgent";
 
-        /// <summary>
-        /// Indicates how to load tests across application domains. Values are:
-        /// "Default", "None", "Single", "Multiple". Default is "Multiple"
-        /// if more than one assembly is loaded in a process. Otherwise,
-        /// it is "Single".
-        /// </summary>
-        public const string DomainUsage = "DomainUsage";
-
         /// <summary>
         /// The private binpath used to locate assemblies. Directory paths
         /// is separated by a semicolon. It's an error to specify this and

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

@@ -54,14 +54,6 @@ public static class EnginePackageSettings
         /// </summary>
         public const string DebugAgent = "DebugAgent";
 
-        /// <summary>
-        /// Indicates how to load tests across application domains. Values are:
-        /// "Default", "None", "Single", "Multiple". Default is "Multiple"
-        /// if more than one assembly is loaded in a process. Otherwise,
-        /// it is "Single".
-        /// </summary>
-        public const string DomainUsage = "DomainUsage";
-
         /// <summary>
         /// The private binpath used to locate assemblies. Directory paths
         /// is separated by a semicolon. It's an error to specify this and

src/NUnitEngine/nunit.engine.core/Internal/DomainUsage.cs

@@ -1,4 +1,5 @@
 // Copyright (c) Charlie Poole, Rob Prouse and Contributors. MIT License - see LICENSE.txt
+
 using NUnit.Engine.Internal;
 using NUnit.Engine.Runners;
 
@@ -24,26 +25,13 @@ public virtual ITestEngineRunner MakeTestRunner(TestPackage package)
 #if !NETFRAMEWORK
             return new LocalTestRunner(ServiceContext, package);
 #else
-            DomainUsage domainUsage = (DomainUsage)System.Enum.Parse(
-                typeof(DomainUsage),
-                package.GetSetting(EnginePackageSettings.DomainUsage, "Default"));
-
-            switch (domainUsage)
-            {
-                default:
-                case DomainUsage.Default:
-                case DomainUsage.Multiple:
-                    if (package.SubPackages.Count > 1)
-                        return new MultipleTestDomainRunner(this.ServiceContext, package);
-                    else
-                        return new TestDomainRunner(this.ServiceContext, package);
-
-                case DomainUsage.None:
-                    return new LocalTestRunner(ServiceContext, package);
-
-                case DomainUsage.Single:
-                    return new TestDomainRunner(ServiceContext, package);
-            }
+            // TODO: Fix handling of unknown extensions and missing files
+            // so we can use...
+            //   if (package.Select(p => p.IsAssemblyPackage()).Count > 1)
+            if (package.SubPackages.Count > 1)
+                return new MultipleTestDomainRunner(ServiceContext, package);
+            else
+                return new TestDomainRunner(ServiceContext, package);
 #endif
         }
 

src/NUnitEngine/nunit.engine.core/Services/InProcessTestRunnerFactory.cs

@@ -30,28 +30,17 @@ public void ServiceIsStarted()
         }
 
 #if NETCOREAPP
-        [TestCase("x.dll", null, typeof(LocalTestRunner))]
-        [TestCase("x.dll y.dll", null, typeof(LocalTestRunner))]
-        [TestCase("x.dll y.dll z.dll", null, typeof(LocalTestRunner))]
+        [TestCase("x.dll", typeof(LocalTestRunner))]
+        [TestCase("x.dll y.dll", typeof(LocalTestRunner))]
+        [TestCase("x.dll y.dll z.dll", typeof(LocalTestRunner))]
 #else
-        // Single file
-        [TestCase("x.dll",  null,      typeof(TestDomainRunner))]
-        [TestCase("x.dll", "Single",   typeof(TestDomainRunner))]
-        [TestCase("x.dll", "Multiple", typeof(TestDomainRunner))]
-        // Two files
-        [TestCase("x.dll y.dll",  null,     typeof(MultipleTestDomainRunner))]
-        [TestCase("x.dll y.dll", "Single",   typeof(TestDomainRunner))]
-        [TestCase("x.dll y.dll", "Multiple", typeof(MultipleTestDomainRunner))]
-        // Three files
-        [TestCase("x.dll y.dll z.dll", null,       typeof(MultipleTestDomainRunner))]
-        [TestCase("x.dll y.dll z.dll", "Single",   typeof(TestDomainRunner))]
-        [TestCase("x.dll y.dll z.dll", "Multiple", typeof(MultipleTestDomainRunner))]
+        [TestCase("x.dll",  typeof(TestDomainRunner))]
+        [TestCase("x.dll y.dll",  typeof(MultipleTestDomainRunner))]
+        [TestCase("x.dll y.dll z.dll", typeof(MultipleTestDomainRunner))]
 #endif
-        public void CorrectRunnerIsUsed(string files, string domainUsage, Type expectedType)
+        public void CorrectRunnerIsUsed(string files, Type expectedType)
         {
             var package = new TestPackage(files.Split(new char[] { ' ' }));
-            if (domainUsage != null)
-                package.Settings["DomainUsage"] = domainUsage;
             Assert.That(_factory.MakeTestRunner(package), Is.TypeOf(expectedType));
         }
     }

src/NUnitEngine/nunit.engine.tests/Services/InProcessTestRunnerFactoryTests.cs

@@ -10,66 +10,17 @@ namespace NUnit.Engine.Tests.Services.TestRunnerFactoryTests.Results
     internal static class Net20OneAssemblyOneProjectExpectedRunnerResults
     {
         private static readonly string ExceptionMessage =
-            $"No expected Test result provided for this {nameof(ProcessModel)}/{nameof(DomainUsage)} combination.";
+            $"No expected Test result provided for this {nameof(ProcessModel)}.";
 
-        public static RunnerResult ResultFor(ProcessModel processModel, DomainUsage domainUsage)
+        public static RunnerResult ResultFor(ProcessModel processModel)
         {
             switch (processModel)
             {
                 case ProcessModel.Default:
-                    return GetProcessModelDefaultResult(domainUsage);
+                    return new RunnerResult(typeof(AggregatingTestRunner),
+                        RunnerResult.MultipleProcessRunner(2),
+                        RunnerResult.ProcessRunner);
                 case ProcessModel.InProcess:
-                    return GetProcessModelInProcessResult(domainUsage);
-                case ProcessModel.Separate:
-                    return GetProcessModelSeparateResult(domainUsage);
-                case ProcessModel.Multiple:
-                    return GetProcessModelMultipleResult(domainUsage);
-                default:
-                    throw new ArgumentOutOfRangeException(nameof(processModel), processModel, ExceptionMessage);
-            }
-        }
-
-        private static RunnerResult GetProcessModelMultipleResult(DomainUsage domainUsage)
-        {
-            switch (domainUsage)
-            {
-                case DomainUsage.Default:
-                case DomainUsage.None:
-                case DomainUsage.Single:
-                case DomainUsage.Multiple:
-                    return new RunnerResult
-                    {
-                        TestRunner = typeof(MultipleTestProcessRunner),
-                        SubRunners = new[]
-                        {
-                            RunnerResult.ProcessRunner,
-                            RunnerResult.ProcessRunner
-                        }
-                    };
-                default:
-                    throw new ArgumentOutOfRangeException(nameof(domainUsage), domainUsage, ExceptionMessage);
-            }
-        }
-
-        private static RunnerResult GetProcessModelSeparateResult(DomainUsage domainUsage)
-        {
-            switch (domainUsage)
-            {
-                case DomainUsage.Default:
-                case DomainUsage.None:
-                case DomainUsage.Single:
-                case DomainUsage.Multiple:
-                    return RunnerResult.ProcessRunner;
-                default:
-                    throw new ArgumentOutOfRangeException(nameof(domainUsage), domainUsage, ExceptionMessage);
-            }
-        }
-
-        private static RunnerResult GetProcessModelInProcessResult(DomainUsage domainUsage)
-        {
-            switch (domainUsage)
-            {
-                case DomainUsage.Default:
                     return new RunnerResult
                     {
                         TestRunner = typeof(MultipleTestDomainRunner),
@@ -79,38 +30,20 @@ private static RunnerResult GetProcessModelInProcessResult(DomainUsage domainUsa
                             RunnerResult.TestDomainRunner
                         }
                     };
-                case DomainUsage.None:
-                    return RunnerResult.LocalTestRunner;
-                case DomainUsage.Single:
-                    return RunnerResult.TestDomainRunner;
-                case DomainUsage.Multiple:
+                case ProcessModel.Separate:
+                    return RunnerResult.ProcessRunner;
+                case ProcessModel.Multiple:
                     return new RunnerResult
                     {
-                        TestRunner = typeof(MultipleTestDomainRunner),
+                        TestRunner = typeof(MultipleTestProcessRunner),
                         SubRunners = new[]
                         {
-                            RunnerResult.TestDomainRunner,
-                            RunnerResult.TestDomainRunner
+                            RunnerResult.ProcessRunner,
+                            RunnerResult.ProcessRunner
                         }
                     };
                 default:
-                    throw new ArgumentOutOfRangeException(nameof(domainUsage), domainUsage, ExceptionMessage);
-            }
-        }
-
-        private static RunnerResult GetProcessModelDefaultResult(DomainUsage domainUsage)
-        {
-            switch (domainUsage)
-            {
-                case DomainUsage.Default:
-                case DomainUsage.None:
-                case DomainUsage.Single:
-                case DomainUsage.Multiple:
-                    return new RunnerResult(typeof(AggregatingTestRunner),
-                        RunnerResult.MultiRunnerWithTwoSubRunners,
-                        RunnerResult.ProcessRunner);
-                default:
-                    throw new ArgumentOutOfRangeException(nameof(domainUsage), domainUsage, ExceptionMessage);
+                    throw new ArgumentOutOfRangeException(nameof(processModel), processModel, ExceptionMessage);
             }
         }
     }