Port issue 1779 to V4

Author: CharliePoole

src/NUnitCommon/nunit.agent.core/Agents/LocalProcessAgentLauncher.cs

@@ -83,7 +83,7 @@ public Process CreateAgent(Guid agentId, string agencyUrl, TestPackage package)
 
             if (AgentRuntime.Identifier == FrameworkIdentifiers.NetCoreApp)
             {
-                startInfo.FileName = DotNet.GetDotNetExe(runAsX86);
+                startInfo.FileName = DotNet.GetDotnetExecutable(runAsX86);
                 startInfo.Arguments = $"\"{AgentPath}\" {arguments}";
             }
 

src/NUnitCommon/nunit.agent.core/TestAssemblyResolver.cs

@@ -13,6 +13,7 @@
 using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Runtime.Loader;
+using NUnit.Common;
 using TestCentric.Metadata;
 
 namespace NUnit.Engine.Internal
@@ -23,20 +24,9 @@ internal sealed class TestAssemblyResolver : IDisposable
 
         private readonly AssemblyLoadContext _loadContext;
 
-        private static readonly string INSTALL_DIR;
-        private static readonly string WINDOWS_DESKTOP_DIR;
-        private static readonly string ASP_NET_CORE_DIR;
-
         // Our Strategies for resolving references
         private List<ResolutionStrategy> ResolutionStrategies;
 
-        static TestAssemblyResolver()
-        {
-            INSTALL_DIR = GetDotNetInstallDirectory().ShouldNotBeNull();
-            WINDOWS_DESKTOP_DIR = Path.Combine(INSTALL_DIR, "shared", "Microsoft.WindowsDesktop.App");
-            ASP_NET_CORE_DIR = Path.Combine(INSTALL_DIR, "shared", "Microsoft.AspNetCore.App");
-        }
-
         public TestAssemblyResolver(AssemblyLoadContext loadContext, string testAssemblyPath)
         {
             _loadContext = loadContext;
@@ -49,34 +39,37 @@ public TestAssemblyResolver(AssemblyLoadContext loadContext, string testAssembly
         [MemberNotNull(nameof(ResolutionStrategies))]
         private void InitializeResolutionStrategies(AssemblyLoadContext loadContext, string testAssemblyPath)
         {
-            // First, looking only at direct references by the test assembly, try to determine if
-            // this assembly is using WindowsDesktop (either SWF or WPF) and/or AspNetCore.
+            // Decide whether to try WindowsDeskTop and/or AspNetCore runtimes before any others.
+            // We base this on direct references only, so we will eventually try each of them
+            // later in case there are any indirect references.
             AssemblyDefinition assemblyDef = AssemblyDefinition.ReadAssembly(testAssemblyPath);
-            bool isWindowsDesktop = false;
-            bool isAspNetCore = false;
+            bool tryWindowsDesktopFirst = false;
+            bool tryAspNetCoreFirst = false;
             foreach (var reference in assemblyDef.MainModule.GetTypeReferences())
             {
                 string fn = reference.FullName;
                 if (fn.StartsWith("System.Windows.") || fn.StartsWith("PresentationFramework"))
-                    isWindowsDesktop = true;
+                    tryWindowsDesktopFirst = true;
                 if (fn.StartsWith("Microsoft.AspNetCore."))
-                    isAspNetCore = true;
+                    tryAspNetCoreFirst = true;
             }
 
             // Initialize the list of ResolutionStrategies in the best order depending on
             // what we learned.
             ResolutionStrategies = new List<ResolutionStrategy>();
 
-            if (isWindowsDesktop && Directory.Exists(WINDOWS_DESKTOP_DIR))
-                ResolutionStrategies.Add(new AdditionalDirectoryStrategy(WINDOWS_DESKTOP_DIR));
-            if (isAspNetCore && Directory.Exists(ASP_NET_CORE_DIR))
-                ResolutionStrategies.Add(new AdditionalDirectoryStrategy(ASP_NET_CORE_DIR));
+            if (tryWindowsDesktopFirst)
+                ResolutionStrategies.Add(new WindowsDesktopStrategy());
+            if (tryAspNetCoreFirst)
+                ResolutionStrategies.Add(new AspNetCoreStrategy());
+
             ResolutionStrategies.Add(new TrustedPlatformAssembliesStrategy());
             ResolutionStrategies.Add(new RuntimeLibrariesStrategy(loadContext, testAssemblyPath));
-            if (!isWindowsDesktop && Directory.Exists(WINDOWS_DESKTOP_DIR))
-                ResolutionStrategies.Add(new AdditionalDirectoryStrategy(WINDOWS_DESKTOP_DIR));
-            if (!isAspNetCore && Directory.Exists(ASP_NET_CORE_DIR))
-                ResolutionStrategies.Add(new AdditionalDirectoryStrategy(ASP_NET_CORE_DIR));
+
+            if (!tryWindowsDesktopFirst)
+                ResolutionStrategies.Add(new WindowsDesktopStrategy());
+            if (!tryAspNetCoreFirst)
+                ResolutionStrategies.Add(new AspNetCoreStrategy());
         }
 
         public void Dispose()
@@ -93,9 +86,8 @@ public void Dispose()
         {
             Guard.ArgumentNotNull(loadContext);
 
-            Assembly? loadedAssembly;
             foreach (var strategy in ResolutionStrategies)
-                if (strategy.TryToResolve(loadContext, assemblyName, out loadedAssembly))
+                if (strategy.TryToResolve(loadContext, assemblyName, out Assembly? loadedAssembly))
                     return loadedAssembly;
 
             log.Info("Cannot resolve assembly '{0}'", assemblyName);
@@ -210,115 +202,60 @@ public override bool TryToResolve(
             }
         }
 
-        public class AdditionalDirectoryStrategy : ResolutionStrategy
+        public class AdditionalRuntimesStrategy : ResolutionStrategy
         {
-            private string _frameworkDirectory;
+            private readonly IEnumerable<DotNet.RuntimeInfo> _additionalRuntimes;
 
-            public AdditionalDirectoryStrategy(string frameworkDirectory)
+            public AdditionalRuntimesStrategy(string runtimeName)
             {
-                _frameworkDirectory = frameworkDirectory;
+                _additionalRuntimes = DotNet.GetRuntimes(runtimeName, !Environment.Is64BitProcess);
             }
 
-            public override bool TryToResolve(
-                AssemblyLoadContext loadContext, AssemblyName assemblyName, [NotNullWhen(true)] out Assembly? loadedAssembly)
+            public override bool TryToResolve(AssemblyLoadContext loadContext, AssemblyName assemblyName, [NotNullWhen(true)] out Assembly? loadedAssembly)
             {
                 loadedAssembly = null;
-                if (assemblyName.Version is null)
-                    return false;
 
-                var versionDir = FindBestVersionDir(_frameworkDirectory, assemblyName.Version);
-
-                if (versionDir is not null)
-                {
-                    string candidate = Path.Combine(_frameworkDirectory, versionDir, assemblyName.Name + ".dll");
-                    if (File.Exists(candidate))
-                    {
-                        loadedAssembly = loadContext.LoadFromAssemblyPath(candidate);
-                        log.Info("'{0}' ({1}) assembly is loaded from AdditionalFrameworkDirectory {2} dependencies with best candidate version {3}",
-                            assemblyName,
-                            loadedAssembly.Location,
-                            _frameworkDirectory,
-                            versionDir);
+                if (!FindBestRuntime(assemblyName, out DotNet.RuntimeInfo? runtime))
+                    return false;
 
-                        return true;
-                    }
-                    else
-                    {
-                        log.Debug("Best version dir for {0} is {1}, but there is no {2} file", _frameworkDirectory, versionDir, candidate);
-                        return false;
-                    }
-                }
+                string candidate = Path.Combine(runtime.Path, runtime.Version.ToString(), assemblyName.Name + ".dll");
+                if (!File.Exists(candidate))
+                    return false;
 
-                return false;
+                loadedAssembly = loadContext.LoadFromAssemblyPath(candidate);
+                return true;
             }
-        }
 
-        #endregion
+            private bool FindBestRuntime(AssemblyName assemblyName, [NotNullWhen(true)] out DotNet.RuntimeInfo? bestRuntime)
+            {
+                bestRuntime = null;
+                var targetVersion = assemblyName.Version;
 
-        #region HelperMethods
+                if (targetVersion is null)
+                    return false;
 
-        private static string? GetDotNetInstallDirectory()
-        {
-            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-            {
-                // Running on Windows so use registry
-                if (Environment.Is64BitProcess)
-                {
-                    using (RegistryKey? key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\dotnet\SetUp\InstalledVersions\x64\sharedHost\"))
-                        return (string?)key?.GetValue("Path");
-                }
-                else
+                foreach (var candidate in _additionalRuntimes)
                 {
-                    using (RegistryKey? key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\WOW6432Node\dotnet\SetUp\InstalledVersions\x86\"))
-                        return (string?)key?.GetValue("InstallLocation");
+                    if (candidate.Version >= targetVersion)
+                        if (bestRuntime is null || bestRuntime.Version > candidate.Version)
+                            bestRuntime = candidate;
                 }
+
+                return bestRuntime is not null;
             }
-            else
-                return "/usr/shared/dotnet/";
         }
 
-        private static string? FindBestVersionDir(string libraryDir, Version targetVersion)
+        public class WindowsDesktopStrategy : AdditionalRuntimesStrategy
         {
-            string target = targetVersion.ToString();
-            Version bestVersion = new Version(0, 0);
-            foreach (var subdir in Directory.GetDirectories(libraryDir))
+            public WindowsDesktopStrategy() : base("Microsoft.WindowsDesktop.App")
             {
-                Version version;
-                if (TryGetVersionFromString(Path.GetFileName(subdir), out version))
-                {
-                    if (version >= targetVersion)
-                        if (bestVersion.Major == 0 || bestVersion > version)
-                            bestVersion = version;
-                }
             }
-
-            return bestVersion.Major > 0
-                ? bestVersion.ToString()
-                : null;
         }
 
-        private static bool TryGetVersionFromString(string text, out Version newVersion)
+        public class AspNetCoreStrategy : AdditionalRuntimesStrategy
         {
-            const string VERSION_CHARS = ".0123456789";
-
-            int len = 0;
-            foreach (char c in text)
-            {
-                if (VERSION_CHARS.Contains(c))
-                    len++;
-                else
-                    break;
-            }
-
-            try
+            public AspNetCoreStrategy() : base("Microsoft.AspNetCore.App")
             {
-                newVersion = new Version(text.Substring(0, len));
-                return true;
-            }
-            catch
-            {
-                newVersion = new Version();
-                return false;
             }
         }