Merge pull request #1799 from nunit/issue-1795

Eliminate use of our custom AssemblyLoadContext

Author: CharliePoole

NetCoreTests.nunit

@@ -1,11 +1,9 @@
 <NUnitProject>
   <Settings processModel="Default" domainUsage="Default" />
   <Config name="Debug" appbase="bin/Debug">
-      <assembly path="testdata/net6.0/mock-assembly.dll" />
       <assembly path="testdata/net8.0/mock-assembly.dll" />
   </Config>
   <Config name="Release" appbase="bin/Release">
-      <assembly path="testdata/net6.0/mock-assembly.dll" />
       <assembly path="testdata/net8.0/mock-assembly.dll" />
   </Config>
 </NUnitProject>

package-tests.cake

@@ -261,14 +261,14 @@ public static class PackageTests
         AllLists.Add(new PackageTest(1, "Net60WPFTest")
         {
             Description = "Run test using WPF targeting .NET 6.0",
-            Arguments = "testdata/net6.0-windows/WpfTest.dll",
+            Arguments = "testdata/net6.0-windows/WpfTest.dll --trace:Debug",
             ExpectedResult = new ExpectedResult("Passed") { Assemblies = new[] { new ExpectedAssemblyResult("WpfTest.dll", "netcore-6.0") } }
         });
 
         AllLists.Add(new PackageTest(1, "Net80WPFTest")
         {
             Description = "Run test using WPF targeting .NET 8.0",
-            Arguments = "testdata/net8.0-windows/WpfTest.dll",
+            Arguments = "testdata/net8.0-windows/WpfTest.dll --trace:Debug",
             ExpectedResult = new ExpectedResult("Passed") { Assemblies = new[] { new ExpectedAssemblyResult("WpfTest.dll", "netcore-8.0") } }
         });
 
@@ -314,9 +314,9 @@ public static class PackageTests
 
         NetCoreRunnerTests.Add(new PackageTest(1, "NUnitProjectTest")
         {
-            Description= "Run NUnit project with mock-assembly.dll targeting .NET 6.0 and 8.0",
+            Description= "Run NUnit project with mock-assembly.dll targeting 8.0",
             Arguments="../../NetCoreTests.nunit --config=Release",
-            ExpectedResult = new MockAssemblyExpectedResult("netcore-6.0", "netcore-8.0"),
+            ExpectedResult = new MockAssemblyExpectedResult("netcore-8.0"),
             ExtensionsNeeded = new [] { Extensions.NUnitProjectLoader }
         });
 

src/NUnitEngine/nunit.engine.core/Drivers/NUnitNetCore31Driver.cs

@@ -8,6 +8,7 @@
 using NUnit.Engine.Internal;
 using System.Reflection;
 using NUnit.Engine.Extensibility;
+using System.Runtime.Loader;
 
 namespace NUnit.Engine.Drivers
 {
@@ -38,7 +39,8 @@ public class NUnitNetCore31Driver : IFrameworkDriver
         Assembly _frameworkAssembly;
         object _frameworkController;
         Type _frameworkControllerType;
-        TestAssemblyLoadContext _assemblyLoadContext;
+        AssemblyLoadContext _assemblyLoadContext;
+        TestAssemblyResolver _testAssemblyResolver;
 
         /// <summary>
         /// An id prefix that will be passed to the test framework and used as part of the
@@ -54,11 +56,17 @@ public class NUnitNetCore31Driver : IFrameworkDriver
         /// <returns>An XML string representing the loaded test</returns>
         public string Load(string assemblyPath, IDictionary<string, object> settings)
         {
+            //if (assemblyPath.EndsWith("WpfTest.dll"))
+            //    System.Diagnostics.Debugger.Launch();
+
             log.Debug($"Loading {assemblyPath}");
             var idPrefix = string.IsNullOrEmpty(ID) ? "" : ID + "-";
 
             assemblyPath = Path.GetFullPath(assemblyPath);  //AssemblyLoadContext requires an absolute path
-            _assemblyLoadContext = new TestAssemblyLoadContext(assemblyPath);
+            //_assemblyLoadContext = new TestAssemblyLoadContext(assemblyPath);
+            //_assemblyLoadContext = AssemblyLoadContext.Default;
+            _assemblyLoadContext = new AssemblyLoadContext(assemblyPath);
+            _testAssemblyResolver = new TestAssemblyResolver(_assemblyLoadContext, assemblyPath);
 
             try
             {
@@ -104,6 +112,11 @@ public string Load(string assemblyPath, IDictionary<string, object> settings)
             return ExecuteMethod(LOAD_METHOD) as string;
         }
 
+        private Assembly _assemblyLoadContext_Resolving(AssemblyLoadContext arg1, AssemblyName arg2)
+        {
+            throw new NotImplementedException();
+        }
+
         /// <summary>
         /// Counts the number of test cases for the loaded test assembly
         /// </summary>

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

@@ -1,6 +1,6 @@
 // Copyright (c) Charlie Poole, Rob Prouse and Contributors. MIT License - see LICENSE.txt
 
-#if NETCOREAPP3_1_OR_GREATER
+#if NETCOREAPP3_1_OR_GREATER && false
 
 using System.Reflection;
 using System.Runtime.InteropServices;

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

@@ -11,6 +11,7 @@
 using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Runtime.Loader;
+using System.Xml.Linq;
 using TestCentric.Metadata;
 
 namespace NUnit.Engine.Internal
@@ -20,13 +21,20 @@ internal sealed class TestAssemblyResolver : IDisposable
         private static readonly Logger log = InternalTrace.GetLogger(typeof(TestAssemblyResolver));
 
         private readonly AssemblyLoadContext _loadContext;
+        private readonly string _basePath;
+        private readonly AssemblyDependencyResolver _assemblyDependencyResolver;
 
         // Our Strategies for resolving references
         List<ResolutionStrategy> ResolutionStrategies;
 
         public TestAssemblyResolver(AssemblyLoadContext loadContext, string testAssemblyPath)
         {
             _loadContext = loadContext;
+            _basePath = Path.GetDirectoryName(testAssemblyPath);
+            _assemblyDependencyResolver = new AssemblyDependencyResolver(testAssemblyPath);
+#if NET8_0_OR_GREATER
+            AppContext.SetData("APP_CONTEXT_BASE_DIRECTORY", _basePath);
+#endif
 
             InitializeResolutionStrategies(loadContext, testAssemblyPath);
 
@@ -73,19 +81,48 @@ public void Dispose()
             _loadContext.Resolving -= OnResolving;
         }
 
-        public Assembly Resolve(AssemblyLoadContext context, AssemblyName assemblyName)
-        {
-            return OnResolving(context, assemblyName);
-        }
+        //public Assembly Resolve(AssemblyLoadContext context, AssemblyName assemblyName)
+        //{
+        //    return OnResolving(context, assemblyName);
+        //}
 
         private Assembly OnResolving(AssemblyLoadContext loadContext, AssemblyName assemblyName)
         {
             if (loadContext == null) throw new ArgumentNullException("context");
 
+            //var runtimeResolverPath = _assemblyDependencyResolver.ResolveAssemblyToPath(assemblyName);
+            //if (!string.IsNullOrEmpty(runtimeResolverPath) && File.Exists(runtimeResolverPath))
+            //{
+            //    var loadedAssembly = _loadContext.LoadFromAssemblyPath(runtimeResolverPath);
+            //    if (loadedAssembly != null)
+            //    {
+            //        log.Info($"Assembly {assemblyName} ({loadedAssembly}) is loaded using the deps.json info");
+            //        return loadedAssembly;
+            //    }
+            //}
+
             foreach (var strategy in ResolutionStrategies)
                 if (strategy.TryToResolve(loadContext, assemblyName, out Assembly loadedAssembly))
                     return loadedAssembly;
 
+            // Load assemblies that are dependencies, and in the same folder as the test assembly,
+            // but are not fully specified in test assembly deps.json file. This happens when the
+            // dependencies reference in the csproj file has CopyLocal=false, and for example, the
+            // reference is a projectReference and has the same output directory as the parent.
+            foreach (var extension in new string[] { ".dll", ".exe" })
+            {
+                string assemblyPath = Path.Combine(_basePath, assemblyName.Name + extension);
+                if (File.Exists(assemblyPath))
+                {
+                    var loadedAssembly = _loadContext.LoadFromAssemblyPath(assemblyPath);
+                    if (loadedAssembly != null)
+                    {
+                        log.Info($"Assembly {assemblyName.Name} ({assemblyPath}) is loaded using base path");
+                        return loadedAssembly;
+                    }
+                }
+            }
+
             log.Info("Cannot resolve assembly '{0}'", assemblyName);
             return null;
         }

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

@@ -2,6 +2,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using NUnit.Engine.Extensibility;
 using NUnit.Engine.Internal;