Merge pull request #1781 from nunit/issue-1779

Enhanced assembly resolution for windows and aspnetcore

Author: CharliePoole

src/Directory.Build.props

@@ -12,6 +12,7 @@
         <!-- Informational Settings -->
         <Company>NUnit Software</Company>
         <Copyright>Copyright (c) 2022 Charlie Poole, Rob Prouse</Copyright>
+        <NoWarn>$(NoWarn);NU1603</NoWarn>
     </PropertyGroup>
 
-</Project>
+</Project>

src/NUnitEngine/nunit.engine.core.tests/nunit.engine.core.tests.csproj

@@ -35,10 +35,6 @@
     <Reference Include="System.Web" />
   </ItemGroup>
 
-  <ItemGroup Condition="'$(TargetFramework)'=='netcoreapp3.1' OR '$(TargetFramework)'=='net6.0' OR '$(TargetFramework)'=='net8.0'">
-    <PackageReference Include="System.ComponentModel.TypeConverter" Version="4.3.0" />
-  </ItemGroup>
-
   <ItemGroup>
     <ProjectReference Include="..\..\TestData\mock-assembly\mock-assembly.csproj" />
     <ProjectReference Include="..\..\TestData\notest-assembly\notest-assembly.csproj" />

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

@@ -2,65 +2,118 @@
 
 using Microsoft.Win32;
 using System;
+using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
-using System.Runtime.InteropServices;
+using System.Linq;
 
 namespace NUnit.Engine
 {
     public static class DotNet
     {
-        public static string GetInstallDirectory() => Environment.Is64BitProcess
-            ? GetX64InstallDirectory() : GetX86InstallDirectory();
+        private const string X64_SUBKEY1 = @"SOFTWARE\dotnet\SetUp\InstalledVersions\x64\sharedHost\";
+        private const string X64_SUBKEY2 = @"SOFTWARE\WOW6432Node\dotnet\SetUp\InstalledVersions\x64\";
+        private const string X86_SUBKEY1 = @"SOFTWARE\dotnet\SetUp\InstalledVersions\x86\InstallLocation\";
+        private const string X86_SUBKEY2 = @"SOFTWARE\WOW6432Node\dotnet\SetUp\InstalledVersions\x86\";
 
-        public static string GetInstallDirectory(bool x86) => x86
-            ? GetX86InstallDirectory() : GetX64InstallDirectory();
+#pragma warning disable CA1416
+        private static readonly Lazy<string> _x64InstallDirectory = new Lazy<string>(() =>
+                Environment.GetEnvironmentVariable("DOTNET_ROOT") ?? (
+                    OS.IsWindows
+                        ? (string) Registry.LocalMachine.OpenSubKey(X64_SUBKEY1)?.GetValue("Path") ??
+                          (string) Registry.LocalMachine.OpenSubKey(X64_SUBKEY2)?.GetValue("Path") ?? @"C:\Program Files\dotnet"
+                        : "/usr/shared/dotnet/"));
+        private static readonly Lazy<string> _x86InstallDirectory = new Lazy<string>(() =>
+                Environment.GetEnvironmentVariable("DOTNET_ROOT_X86") ?? (
+                    OS.IsWindows
+                        ? (string) Registry.LocalMachine.OpenSubKey(X86_SUBKEY1)?.GetValue("InstallLocation") ??
+                          (string) Registry.LocalMachine.OpenSubKey(X86_SUBKEY2)?.GetValue("InstallLocation") ?? @"C:\Program Files (x86)\dotnet"
+                        : "/usr/shared/dotnet/"));
+#pragma warning restore CA1416
+
+        private static Lazy<List<RuntimeInfo>> _x64Runtimes = new Lazy<List<RuntimeInfo>>(() => [.. GetAllRuntimes(x86: false)]);
+        private static Lazy<List<RuntimeInfo>> _x86Runtimes = new Lazy<List<RuntimeInfo>>(() => [.. GetAllRuntimes(x86: true)]);
+
+        public enum Architecture
+        {
+            Unspecified,
+            X64,
+            X86
+        }
 
-        private static string _x64InstallDirectory;
-        public static string GetX64InstallDirectory()
+        public class RuntimeInfo
         {
-            if (_x64InstallDirectory == null)
-                _x64InstallDirectory = Environment.GetEnvironmentVariable("DOTNET_ROOT");
+            public string Name;
+            public Version Version;
+            public string Path;
+
+            public RuntimeInfo(string name, string version, string path)
+                : this(name, new Version(version), path) { }
 
-            if (_x64InstallDirectory == null)
+            public RuntimeInfo(string name, Version version, string path)
             {
-#if NETFRAMEWORK
-                if (Path.DirectorySeparatorChar == '\\')
-#else
-                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-#endif
-                {
-                    RegistryKey key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\dotnet\SetUp\InstalledVersions\x64\sharedHost\");
-                    _x64InstallDirectory = (string)key?.GetValue("Path");
-                }
-                else
-                    _x64InstallDirectory = "/usr/shared/dotnet/";
+                Name = name;
+                Version = version;
+                Path = path;
             }
+        }
+
+        /// <summary>
+        /// Get the correct install directory, depending on whether we need X86 or X64 architecture.
+        /// </summary>
+        /// <param name="x86">Flag indicating whether the X86 architecture is needed</param>
+        /// <returns></returns>
+        public static string GetInstallDirectory(bool x86) => x86
+            ? _x86InstallDirectory.Value : _x64InstallDirectory.Value;
 
-            return _x64InstallDirectory;
+        /// <summary>
+        /// Get the correct dotnet.exe, depending on whether we need X86 or X64 architecture.
+        /// </summary>
+        /// <param name="x86">Flag indicating whether the X86 architecture is needed</param>
+        /// <returns></returns>
+        public static string GetDotnetExecutable(bool x86) => Path.Combine(GetInstallDirectory(x86), OS.IsWindows ? "dotnet.exe" : "dotnet");
+
+        public static IEnumerable<RuntimeInfo> GetRuntimes(string name, bool x86)
+        {
+            var runtimes = x86 ? _x86Runtimes.Value : _x64Runtimes.Value;
+            return runtimes.Where(r => r.Name == name);
         }
 
-        private static string _x86InstallDirectory;
-        public static string GetX86InstallDirectory()
+        private static IEnumerable<RuntimeInfo> GetAllRuntimes(bool x86)
         {
-            if (_x86InstallDirectory == null)
-                _x86InstallDirectory = Environment.GetEnvironmentVariable("DOTNET_ROOT_X86");
+            foreach (string line in DotnetCommand("--list-runtimes", x86: x86))
+            {
+                string[] parts = line.Trim().Split([' '], 3);
+                yield return new RuntimeInfo(parts[0], parts[1], parts[2].Trim(['[', ']']));
+            }
+        }
 
-            if (_x86InstallDirectory == null)
+        private static IEnumerable<string> DotnetCommand(string arguments, bool x86 = false)
+        {
+            var process = new Process
             {
-#if NETFRAMEWORK
-                if (Path.DirectorySeparatorChar == '\\')
-#else
-                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-#endif
+                StartInfo = new ProcessStartInfo
                 {
-                    RegistryKey key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\WOW6432Node\dotnet\SetUp\InstalledVersions\x86\");
-                    _x86InstallDirectory = (string)key?.GetValue("InstallLocation");
+                    FileName = GetDotnetExecutable(x86),
+                    Arguments = arguments,
+                    UseShellExecute = false,
+                    RedirectStandardOutput = true,
+                    CreateNoWindow = true
                 }
-                else
-                    _x86InstallDirectory = "/usr/shared/dotnet/";
+            };
+
+            try
+            {
+                process.Start();
+            }
+            catch (Exception)
+            {
+                // Failed to start dotnet command. Assume no versions are installed and just return
+                yield break;
             }
 
-            return _x86InstallDirectory;
+            while (!process.StandardOutput.EndOfStream)
+                yield  return process.StandardOutput.ReadLine();
         }
     }
 }

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

@@ -31,7 +31,7 @@ public IEnumerable<IDirectory> GetDirectories(IDirectory startDirectory, string
             Guard.ArgumentNotNull(startDirectory, nameof(startDirectory));
             Guard.ArgumentNotNull(pattern, nameof(pattern));
 
-            if (Path.DirectorySeparatorChar == '\\')
+            if (OS.IsWindows)
                 pattern = pattern.Replace(Path.DirectorySeparatorChar, '/');
 
             var dirList = new List<IDirectory> { startDirectory };

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

@@ -147,7 +147,7 @@ public static bool SamePathOrUnder( string path1, string path2 )
                 return string.Compare( path1, path2, RunningOnWindows ) == 0;
 
             // path 2 is longer than path 1: see if initial parts match
-            if ( string.Compare( path1, path2.Substring( 0, length1 ), RunningOnWindows ) != 0 )
+            if ( string.Compare( path1, path2.Substring( 0, length1 ), RunningOnWindows) != 0 )
                 return false;
 
             // must match through or up to a directory separator boundary
@@ -179,6 +179,8 @@ public static bool IsFullyQualifiedPath(string path )
                 : IsFullyQualifiedUnixPath(path);
         }
 
+        private static bool RunningOnWindows => DirectorySeparatorChar == '\\';
+
         /// <summary>
         /// Returns a value that indicates whether the specified file path is fully qualified or not on Windows operating systems.
         /// </summary>
@@ -250,8 +252,6 @@ private static bool IsValidDriveSpecifier(char c)
             return ('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z');
         }
 
-        private static bool RunningOnWindows => DirectorySeparatorChar == '\\';
-
         private static string[] SplitPath(string path)
         {
             char[] separators = new char[] { DirectorySeparatorChar, AltDirectorySeparatorChar };