Port changes from version 3.22.0 to V4

CharliePoole · CharliePoole · commit 3552bdbe9a9b · 2026-01-03T05:58:09.000-08:00
diff --git a/src/NUnitCommon/nunit.agent.core/Drivers/NUnitFrameworkApi2018.cs b/src/NUnitCommon/nunit.agent.core/Drivers/NUnitFrameworkApi2018.cs
@@ -4,8 +4,9 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
-
+using NUnit.Common;
 #if NETCOREAPP
+using System.Runtime.Loader;
 using NUnit.Engine.Internal;
 #endif
 
@@ -40,10 +41,12 @@ public class NUnitFrameworkApi2018 : NUnitFrameworkApi
         private Type? _frameworkControllerType;
 
 #if NETCOREAPP
-        private TestAssemblyLoadContext? _assemblyLoadContext;
+        private AssemblyLoadContext? _assemblyLoadContext;
+        private TestAssemblyResolver? _testAssemblyResolver;
+        private Assembly? _testAssembly;
         private Assembly? _frameworkAssembly;
 
-        internal List<ResolutionStrategy>? ResolutionStrategies => _assemblyLoadContext?.ResolutionStrategies;
+        internal List<ResolutionStrategy>? ResolutionStrategies => _testAssemblyResolver?.ResolutionStrategies;
 #endif
 
         private string? _testAssemblyPath;
@@ -67,6 +70,10 @@ public string Load(string testAssemblyPath, IDictionary<string, object> settings
             _testAssemblyPath = Path.GetFullPath(testAssemblyPath);
             var idPrefix = _driverId + "-";
 
+            bool useDefaultAssemblyLoadContext = false;
+            if (settings.TryGetValue(SettingDefinitions.UseDefaultAssemblyLoadContext, out var val))
+                useDefaultAssemblyLoadContext = (bool)val;
+
 #if NETFRAMEWORK
             try
             {
@@ -95,12 +102,46 @@ public string Load(string testAssemblyPath, IDictionary<string, object> settings
             var controllerAssembly = _frameworkControllerType?.Assembly?.GetName();
             log.Debug($"Controller assembly is {controllerAssembly}");
 #else
-            _assemblyLoadContext = new TestAssemblyLoadContext(testAssemblyPath);
+            try
+            {
+                _testAssembly = AssemblyHelper.FindLoadedAssemblyByPath(_testAssemblyPath);
+
+                if (_testAssembly is not null)
+                {
+                    _assemblyLoadContext = AssemblyLoadContext.GetLoadContext(_testAssembly);
+                    log.Debug($"  Already loaded in context {_assemblyLoadContext}");
+                }
+                else
+                {
+                    _assemblyLoadContext = useDefaultAssemblyLoadContext
+                        ? AssemblyLoadContext.Default
+                        : new AssemblyLoadContext(Path.GetFileNameWithoutExtension(testAssemblyPath));
+                    _testAssembly = _assemblyLoadContext.LoadFromAssemblyPath(testAssemblyPath);
+                    log.Debug($"  Loaded into new context {_assemblyLoadContext}");
+                }
+
+                _testAssemblyResolver = new TestAssemblyResolver(_assemblyLoadContext.ShouldNotBeNull(), testAssemblyPath);
+            }
+            catch (Exception e)
+            {
+                var msg = $"Failed to load test assembly {testAssemblyPath}";
+                log.Error(msg);
+                throw new NUnitEngineException(msg, e);
+            }
+            log.Debug($"Loaded {testAssemblyPath}");
 
-            var testAssembly = LoadAssembly(testAssemblyPath);
-            _frameworkAssembly = LoadAssembly(_nunitRef);
+            try
+            {
+                _frameworkAssembly = LoadAssembly(_nunitRef);
+            }
+            catch (Exception e)
+            {
+                log.Error($"{FAILED_TO_LOAD_NUNIT}\r\n{e}");
+                throw new NUnitEngineException(FAILED_TO_LOAD_NUNIT, e);
+            }
+            log.Debug("Loaded nunit.framework");
 
-            _frameworkController = CreateInstance(CONTROLLER_TYPE, testAssembly, idPrefix, settings);
+            _frameworkController = CreateInstance(CONTROLLER_TYPE, _testAssembly, idPrefix, settings);
             if (_frameworkController is null)
             {
                 log.Error(INVALID_FRAMEWORK_MESSAGE);
diff --git a/src/NUnitCommon/nunit.agent.core/TestAssemblyLoadContext.cs b/src/NUnitCommon/nunit.agent.core/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;
diff --git a/src/NUnitCommon/nunit.agent.core/TestAssemblyResolver.cs b/src/NUnitCommon/nunit.agent.core/TestAssemblyResolver.cs
@@ -25,13 +25,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
         internal List<ResolutionStrategy> ResolutionStrategies = new List<ResolutionStrategy>();
 
         public TestAssemblyResolver(AssemblyLoadContext loadContext, string testAssemblyPath)
         {
             _loadContext = loadContext;
+            _basePath = Path.GetDirectoryName(testAssemblyPath).ShouldNotBeNull();
+            _assemblyDependencyResolver = new AssemblyDependencyResolver(testAssemblyPath);
+#if NET8_0_OR_GREATER
+            AppContext.SetData("APP_CONTEXT_BASE_DIRECTORY", _basePath);
+#endif
 
             InitializeResolutionStrategies(loadContext, testAssemblyPath);
 
@@ -76,15 +83,21 @@ public void Dispose()
             _loadContext.Resolving -= OnResolving;
         }
 
-        public Assembly? Resolve(AssemblyLoadContext context, AssemblyName assemblyName)
-        {
-            return OnResolving(context, assemblyName);
-        }
-
         private Assembly? OnResolving(AssemblyLoadContext loadContext, AssemblyName assemblyName)
         {
             Guard.ArgumentNotNull(loadContext);
 
+            var runtimeResolverPath = _assemblyDependencyResolver.ResolveAssemblyToPath(assemblyName);
+            if (!string.IsNullOrEmpty(runtimeResolverPath) && File.Exists(runtimeResolverPath))
+            {
+                var loadedAssembly = _loadContext.LoadFromAssemblyPath(runtimeResolverPath);
+                if (loadedAssembly is not null)
+                {
+                    log.Info($"Assembly {assemblyName} ({loadedAssembly}) is loaded using the deps.json info");
+                    return loadedAssembly;
+                }
+            }
+
             foreach (var strategy in ResolutionStrategies)
             {
                 strategy.Calls++;
diff --git a/src/NUnitCommon/nunit.agent.core/nunit.agent.core.csproj b/src/NUnitCommon/nunit.agent.core/nunit.agent.core.csproj
@@ -27,12 +27,10 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)'=='netcoreapp3.1' OR '$(TargetFramework)'=='net6.0'">
-    <PackageReference Include="Microsoft.Win32.Registry" Version="4.3.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyModel" Version="3.1.0" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)'=='net8.0'">
-    <PackageReference Include="Microsoft.Win32.Registry" Version="4.3.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyModel" Version="8.0.2" />
   </ItemGroup>
 
diff --git a/src/NUnitCommon/nunit.common/AssemblyHelper.cs b/src/NUnitCommon/nunit.common/AssemblyHelper.cs
@@ -2,6 +2,7 @@
 
 using System;
 using System.IO;
+using System.Linq;
 using System.Reflection;
 namespace NUnit
 {
@@ -76,5 +77,17 @@ internal static string GetAssemblyPathFromCodeBase(string codeBase)
             return codeBase.Substring(start);
         }
 #endif
+
+        // For assemblies already loaded by MTP or by some other means
+        public static Assembly? FindLoadedAssemblyByPath(string assemblyPath)
+        {
+            var full = Path.GetFullPath(assemblyPath);
+
+            return AppDomain.CurrentDomain.GetAssemblies()
+                .FirstOrDefault(a =>
+                    !a.IsDynamic &&
+                    !string.IsNullOrEmpty(a.Location) &&
+                    StringComparer.OrdinalIgnoreCase.Equals(Path.GetFullPath(a.Location), full));
+        }
     }
 }
diff --git a/src/NUnitCommon/nunit.common/DotNet.cs b/src/NUnitCommon/nunit.common/DotNet.cs
@@ -152,7 +152,8 @@ internal static bool FindBestRuntime(Version targetVersion, IEnumerable<RuntimeI
 
             foreach (var candidate in availableRuntimes)
             {
-                if (candidate.Version >= targetVersion)
+                if (candidate.Version.Major > targetVersion.Major ||
+                    candidate.Version.Major == targetVersion.Major && candidate.Version.Minor >= candidate.Version.Minor)
                     if (bestRuntime is null || candidate.Version.Major == bestRuntime.Version.Major)
                         bestRuntime = candidate;
             }
diff --git a/src/NUnitConsole/nunit4-console.tests/nunit4-console.tests.csproj b/src/NUnitConsole/nunit4-console.tests/nunit4-console.tests.csproj
@@ -16,7 +16,6 @@
   <ItemGroup>
     <PackageReference Include="NUnit" Version="4.3.2" />
     <PackageReference Include="NUnitLite" Version="4.3.2" />
-    <PackageReference Include="System.ComponentModel.TypeConverter" Version="4.3.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.3.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.15.1" />
     <PackageReference Include="NSubstitute" Version="4.3.0" />
diff --git a/src/NUnitEngine/nunit.engine.api/SettingDefinitions.cs b/src/NUnitEngine/nunit.engine.api/SettingDefinitions.cs
@@ -256,6 +256,18 @@ static SettingDefinitions()
         /// </summary>
         public static SettingDefinition<string> ImageTargetFrameworkName { get; } = new(nameof(ImageTargetFrameworkName), string.Empty);
 
+        /// <summary>
+        /// Set this to true to force use of the default assembly load context for the
+        /// test assembly and in resolving all dependencies rather than creating and
+        /// using a separate instance of AssemblyLoadContext.
+        /// </summary>
+        /// <remarks>
+        /// This is provided for use by the NUnit3 VS Adapter and may not work if used
+        /// outside of  that context. It must be set in the top-level package via the
+        /// AddSetting method so that the same value is passed to all subpackages.
+        /// </remarks>
+        public const string UseDefaultAssemblyLoadContext = "UseDefaultAssemblyLoadContext";
+
         #endregion
 
         #region Settings Used by the NUnit Framework

Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`
`3`	`3`	`using System;`
`4`	`4`	`using System.IO;`
	`5`	`+using System.Linq;`
`5`	`6`	`using System.Reflection;`
`6`	`7`	`namespace NUnit`
`7`	`8`	`{`
`@@ -76,5 +77,17 @@ internal static string GetAssemblyPathFromCodeBase(string codeBase)`
`76`	`77`	`return codeBase.Substring(start);`
`77`	`78`	`}`
`78`	`79`	`#endif`
	`80`	`+`
	`81`	`+ // For assemblies already loaded by MTP or by some other means`
	`82`	`+ public static Assembly? FindLoadedAssemblyByPath(string assemblyPath)`
	`83`	`+ {`
	`84`	`+ var full = Path.GetFullPath(assemblyPath);`
	`85`	`+`
	`86`	`+ return AppDomain.CurrentDomain.GetAssemblies()`
	`87`	`+ .FirstOrDefault(a =>`
	`88`	`+ !a.IsDynamic &&`
	`89`	`+ !string.IsNullOrEmpty(a.Location) &&`
	`90`	`+ StringComparer.OrdinalIgnoreCase.Equals(Path.GetFullPath(a.Location), full));`
	`91`	`+ }`
`79`	`92`	`}`
`80`	`93`	`}`
Original file line number	Diff line number	Diff line change
`@@ -152,7 +152,8 @@ internal static bool FindBestRuntime(Version targetVersion, IEnumerable<RuntimeI`
`152`	`152`
`153`	`153`	`foreach (var candidate in availableRuntimes)`
`154`	`154`	`{`
`155`		`- if (candidate.Version >= targetVersion)`
	`155`	`+ if (candidate.Version.Major > targetVersion.Major \|\|`
	`156`	`+ candidate.Version.Major == targetVersion.Major && candidate.Version.Minor >= candidate.Version.Minor)`
`156`	`157`	`if (bestRuntime is null \|\| candidate.Version.Major == bestRuntime.Version.Major)`
`157`	`158`	`bestRuntime = candidate;`
`158`	`159`	`}`