Merge pull request #1256 from nunit/issue-1130

Run .NET 4.6.1 and higher tests using Mono on Linux

azure-pipelines.yml

@@ -103,8 +103,8 @@ jobs:
       version: 2.1.x
 
   - bash: |
-     ./build.sh --target=Build --configuration=Release
-    displayName: Build
+     ./build.sh --target=Test --configuration=Release
+    displayName: Build and Test
 
   # Workaround for https://github.com/nunit/nunit/issues/3012#issuecomment-441517922
   - task: PublishTestResults@2

build.cake

@@ -194,7 +194,7 @@ Task("TestNetStandard20Engine")
     .OnError(exception => { UnreportedErrors.Add(exception.Message); })
     .Does(() =>
     {
-        RunDotnetNUnitLiteTests(ENGINE_TESTS_PROJECT, "netcoreapp2.1", "--labels:Before");
+        RunDotnetNUnitLiteTests(ENGINE_TESTS_PROJECT, "netcoreapp2.1");
     });
 
 //////////////////////////////////////////////////////////////////////
@@ -207,7 +207,7 @@ Task("TestNetCore31Engine")
     .OnError(exception => { UnreportedErrors.Add(exception.Message); })
     .Does(() =>
     {
-        RunDotnetNUnitLiteTests(ENGINE_TESTS_PROJECT, "netcoreapp3.1", "--labels:Before");
+        RunDotnetNUnitLiteTests(ENGINE_TESTS_PROJECT, "netcoreapp3.1");
     });
 
 //////////////////////////////////////////////////////////////////////

cake/utilities.cake

@@ -246,7 +246,7 @@ void RunDotnetNUnitLiteTests(string projectPath, string targetRuntime, string ad
         UnreportedErrors.Add($"{testAssembly}({targetRuntime}) returned rc = {rc}");
 }
 
-void RunNetFxConsole(string projectPath, string targetRuntime)
+void RunNetFxConsole(string projectPath, string targetRuntime, string additionalArgs="")
 {
     var testAssembly = System.IO.Path.GetFileNameWithoutExtension(projectPath) + ".dll";
     var workingDir = GetProjectBinDir(projectPath, targetRuntime);
@@ -257,7 +257,7 @@ void RunNetFxConsole(string projectPath, string targetRuntime)
         NETFX_CONSOLE,
         new ProcessSettings()
         {
-            Arguments = $"\"{assemblyPath}\" --result:{resultPath}",
+            Arguments = $"\"{assemblyPath}\" --result:{resultPath} {additionalArgs}",
             WorkingDirectory = workingDir
         });
 

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

@@ -198,7 +198,9 @@ public void CanRecognizeBooleanOptions(string propertyName, string pattern)
 #if NETFRAMEWORK
         [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])]
+        // We can't predict which runtimes are available on the test machine, so we don't
+        // test for any good or bad values. TODO: Create a fake list of availble runtimes.
+        [TestCase("Framework", "framework", new string[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" })]
 #endif
@@ -215,7 +217,7 @@ public void CanRecognizeStringOptions(string propertyName, string pattern, strin
                 {
                     string optionPlusValue = string.Format("--{0}:{1}", option, value);
                     ConsoleOptions options = ConsoleMocks.Options(optionPlusValue);
-                    Assert.That(options.Validate(), Is.True, "Should be valid: " + optionPlusValue);
+                    Assert.That(options.Validate(), Is.True, $"The option {optionPlusValue} should be valid.");
                     Assert.That((string)property.GetValue(options, null), Is.EqualTo(value), "Didn't recognize " + optionPlusValue);
                 }
 

src/NUnitConsole/nunit3-console/ConsoleOptions.cs

@@ -436,7 +436,7 @@ private void ValidateFrameworkOption()
                 ErrorMessages.Add("Invalid or unknown framework requested: " + Framework);
 
             foreach (var framework in RuntimeFramework.AvailableFrameworks)
-                if (framework.ToString() == Framework)
+                if (framework.Id == Framework)
                     return;
 
             ErrorMessages.Add("Unavailable framework requested: " + Framework);

src/NUnitEngine/nunit.engine.core.tests/RuntimeFrameworkTests.cs

@@ -3,6 +3,7 @@
 #if NETFRAMEWORK
 using System;
 using System.Collections.Generic;
+using NSubstitute;
 using NUnit.Framework;
 
 namespace NUnit.Engine.Tests
@@ -163,6 +164,10 @@ public bool CanLoad(RuntimeFramework f1, RuntimeFramework f2)
                 new RuntimeFramework(RuntimeType.Mono, new Version(4,0)),
                 new RuntimeFramework(RuntimeType.Net, new Version(4,0)))
                 .Returns(true),
+            new TestCaseData(
+                new RuntimeFramework(RuntimeType.Mono, new Version(4,0)),
+                new RuntimeFramework(RuntimeType.Net, new Version(4,6,2)))
+                .Returns(true),
             new TestCaseData(
                 new RuntimeFramework(RuntimeType.Net, new Version(2,0)),
                 new RuntimeFramework(RuntimeType.Net, new Version(1,1)))

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

@@ -455,9 +455,13 @@ public bool Supports(RuntimeFramework target)
             if (FrameworkVersion == DefaultVersion || target.FrameworkVersion == DefaultVersion)
                 return true;
 
-            return VersionsMatch(this.ClrVersion, target.ClrVersion)
-                && this.FrameworkVersion.Major >= target.FrameworkVersion.Major
-                && this.FrameworkVersion.Minor >= target.FrameworkVersion.Minor;
+            if (!VersionsMatch(this.ClrVersion, target.ClrVersion))
+                return false;
+
+            return this.Runtime == RuntimeType.Mono
+                ? this.FrameworkVersion.Major >= target.FrameworkVersion.Major
+                : this.FrameworkVersion.Major >= target.FrameworkVersion.Major &&
+                  this.FrameworkVersion.Minor >= target.FrameworkVersion.Minor;
         }
 
         private bool Supports(RuntimeType targetRuntime)

src/NUnitEngine/nunit.engine/Services/RuntimeFrameworkService.cs

@@ -41,11 +41,7 @@ public bool IsAvailable(string name)
             if (!RuntimeFramework.TryParse(name, out RuntimeFramework requestedFramework))
                 throw new NUnitEngineException("Invalid or unknown framework requested: " + name);
 
-            foreach (var framework in RuntimeFramework.AvailableFrameworks)
-                if (FrameworksMatch(requestedFramework, framework))
-                    return true;
-
-            return false;
+            return requestedFramework.IsAvailable;
         }
 
         private static readonly Version AnyVersion = new Version(0, 0);