Fix assembly resolution error (#2948)

Evangelink · web-flow · commit efc614f02eab · 2024-05-27T15:06:17.000+02:00
diff --git a/src/Adapter/MSTestAdapter.PlatformServices/AssemblyResolver.cs b/src/Adapter/MSTestAdapter.PlatformServices/AssemblyResolver.cs
@@ -86,6 +86,7 @@ class AssemblyResolver :
     /// </summary>
     private readonly object _syncLock = new();
 
+    private static List<string>? s_currentlyLoading;
     private bool _disposed;
 
     /// <summary>
@@ -335,7 +336,7 @@ protected virtual
                     if (EqtTrace.IsInfoEnabled)
                     {
                         EqtTrace.Info(
-                            "AssemblyResolver: {0}: Failed to create assemblyName. Reason:{1} ",
+                            "MSTest.AssemblyResolver.OnResolve: Failed to create assemblyName '{0}'. Reason: {1} ",
                             name,
                             ex);
                     }
@@ -344,7 +345,7 @@ protected virtual
             return null;
         }
 
-        DebugEx.Assert(requestedName != null && !StringEx.IsNullOrEmpty(requestedName.Name), "AssemblyResolver.OnResolve: requested is null or name is empty!");
+        DebugEx.Assert(requestedName != null && !StringEx.IsNullOrEmpty(requestedName.Name), "MSTest.AssemblyResolver.OnResolve: requested is null or name is empty!");
 
         foreach (string dir in searchDirectorypaths)
         {
@@ -359,15 +360,39 @@ protected virtual
                 {
                     if (EqtTrace.IsVerboseEnabled)
                     {
-                        EqtTrace.Verbose("AssemblyResolver: Searching assembly: {0} in the directory: {1}", requestedName.Name, dir);
+                        EqtTrace.Verbose("MSTest.AssemblyResolver.OnResolve: Searching assembly '{0}' in the directory '{1}'", requestedName.Name, dir);
                     }
                 });
 
             foreach (string extension in new string[] { ".dll", ".exe" })
             {
                 string assemblyPath = Path.Combine(dir, requestedName.Name + extension);
 
+                bool isPushed = false;
+                bool isResource = requestedName.Name.EndsWith(".resources", StringComparison.InvariantCulture);
+                if (isResource)
+                {
+                    // Are we recursively looking up the same resource?  Note - our backout code will set
+                    // the ResourceHelper's currentlyLoading stack to null if an exception occurs.
+                    if (s_currentlyLoading != null && s_currentlyLoading.Count > 0 && s_currentlyLoading.LastIndexOf(assemblyPath) != -1)
+                    {
+                        EqtTrace.Info("MSTest.AssemblyResolver.OnResolve: Assembly '{0}' is searching for itself recursively '{1}', returning as not found.", name, assemblyPath);
+                        _resolvedAssemblies[name] = null;
+                        return null;
+                    }
+
+                    s_currentlyLoading ??= new List<string>();
+                    s_currentlyLoading.Add(assemblyPath); // Push
+                    isPushed = true;
+                }
+
                 Assembly? assembly = SearchAndLoadAssembly(assemblyPath, name, requestedName, isReflectionOnly);
+                if (isResource && isPushed)
+                {
+                    DebugEx.Assert(s_currentlyLoading is not null, "_currentlyLoading should not be null");
+                    s_currentlyLoading.RemoveAt(s_currentlyLoading.Count - 1); // Pop
+                }
+
                 if (assembly != null)
                 {
                     return assembly;
@@ -447,7 +472,7 @@ private void WindowsRuntimeMetadataReflectionOnlyNamespaceResolve(object sender,
     {
         if (StringEx.IsNullOrEmpty(args.Name))
         {
-            Debug.Fail("AssemblyResolver.OnResolve: args.Name is null or empty.");
+            Debug.Fail("MSTest.AssemblyResolver.OnResolve: args.Name is null or empty.");
             return null;
         }
 
@@ -457,7 +482,7 @@ private void WindowsRuntimeMetadataReflectionOnlyNamespaceResolve(object sender,
             {
                 if (EqtTrace.IsInfoEnabled)
                 {
-                    EqtTrace.Info("AssemblyResolver: Resolving assembly: {0}.", args.Name);
+                    EqtTrace.Info("MSTest.AssemblyResolver.OnResolve: Resolving assembly '{0}'", args.Name);
                 }
             });
 
@@ -469,7 +494,7 @@ private void WindowsRuntimeMetadataReflectionOnlyNamespaceResolve(object sender,
             {
                 if (EqtTrace.IsInfoEnabled)
                 {
-                    EqtTrace.Info("AssemblyResolver: Resolving assembly after applying policy: {0}.", assemblyNameToLoad);
+                    EqtTrace.Info("MSTest.AssemblyResolver.OnResolve: Resolving assembly after applying policy '{0}'", assemblyNameToLoad);
                 }
             });
 
@@ -482,62 +507,58 @@ private void WindowsRuntimeMetadataReflectionOnlyNamespaceResolve(object sender,
             }
 
             assembly = SearchAssembly(_searchDirectories, assemblyNameToLoad, isReflectionOnly);
-
             if (assembly != null)
             {
                 return assembly;
             }
 
-            if (_directoryList != null && _directoryList.Count != 0)
+            // required assembly is not present in searchDirectories??
+            // see, if we can find it in user specified search directories.
+            while (assembly == null && _directoryList?.Count > 0)
             {
-                // required assembly is not present in searchDirectories??
-                // see, if we can find it in user specified search directories.
-                while (assembly == null && _directoryList.Count > 0)
-                {
-                    // instead of loading whole search directory in one time, we are adding directory on the basis of need
-                    RecursiveDirectoryPath currentNode = _directoryList.Dequeue();
-
-                    List<string> incrementalSearchDirectory = [];
+                // instead of loading whole search directory in one time, we are adding directory on the basis of need
+                RecursiveDirectoryPath currentNode = _directoryList.Dequeue();
 
-                    if (DoesDirectoryExist(currentNode.DirectoryPath))
-                    {
-                        incrementalSearchDirectory.Add(currentNode.DirectoryPath);
-
-                        if (currentNode.IncludeSubDirectories)
-                        {
-                            // Add all its sub-directory in depth first search order.
-                            AddSubdirectories(currentNode.DirectoryPath, incrementalSearchDirectory);
-                        }
+                List<string> incrementalSearchDirectory = [];
 
-                        // Add this directory list in this.searchDirectories so that when we will try to resolve some other
-                        // assembly, then it will look in this whole directory first.
-                        _searchDirectories.AddRange(incrementalSearchDirectory);
+                if (DoesDirectoryExist(currentNode.DirectoryPath))
+                {
+                    incrementalSearchDirectory.Add(currentNode.DirectoryPath);
 
-                        assembly = SearchAssembly(incrementalSearchDirectory, assemblyNameToLoad, isReflectionOnly);
-                    }
-                    else
+                    if (currentNode.IncludeSubDirectories)
                     {
-                        // generate warning that path does not exist.
-                        SafeLog(
-                            assemblyNameToLoad,
-                            () =>
-                            {
-                                if (EqtTrace.IsWarningEnabled)
-                                {
-                                    EqtTrace.Warning(
-                                    "The Directory: {0}, does not exist",
-                                    currentNode.DirectoryPath);
-                                }
-                            });
+                        // Add all its sub-directory in depth first search order.
+                        AddSubdirectories(currentNode.DirectoryPath, incrementalSearchDirectory);
                     }
-                }
 
-                if (assembly != null)
+                    // Add this directory list in this.searchDirectories so that when we will try to resolve some other
+                    // assembly, then it will look in this whole directory first.
+                    _searchDirectories.AddRange(incrementalSearchDirectory);
+
+                    assembly = SearchAssembly(incrementalSearchDirectory, assemblyNameToLoad, isReflectionOnly);
+                }
+                else
                 {
-                    return assembly;
+                    // generate warning that path does not exist.
+                    SafeLog(
+                        assemblyNameToLoad,
+                        () =>
+                        {
+                            if (EqtTrace.IsWarningEnabled)
+                            {
+                                EqtTrace.Warning(
+                                "MSTest.AssemblyResolver.OnResolve: the directory '{0}', does not exist",
+                                currentNode.DirectoryPath);
+                            }
+                        });
                 }
             }
 
+            if (assembly != null)
+            {
+                return assembly;
+            }
+
             // Try for default load for System dlls that can't be found in search paths. Needs to loaded just by name.
             try
             {
@@ -580,7 +601,7 @@ private void WindowsRuntimeMetadataReflectionOnlyNamespaceResolve(object sender,
                     {
                         if (EqtTrace.IsInfoEnabled)
                         {
-                            EqtTrace.Info("AssemblyResolver: {0}: Failed to load assembly. Reason: {1}", assemblyNameToLoad, ex);
+                            EqtTrace.Info("MSTest.AssemblyResolver.OnResolve: Failed to load assembly '{0}'. Reason: {1}", assemblyNameToLoad, ex);
                         }
                     });
             }
@@ -609,7 +630,7 @@ private bool TryLoadFromCache(string assemblyName, bool isReflectionOnly, out As
                 {
                     if (EqtTrace.IsInfoEnabled)
                     {
-                        EqtTrace.Info("AssemblyResolver: Resolved: {0}.", assemblyName);
+                        EqtTrace.Info("MSTest.AssemblyResolver.OnResolve: Resolved '{0}'", assemblyName);
                     }
                 });
             return true;
@@ -685,7 +706,7 @@ private static void SafeLog(string? assemblyName, Action loggerAction)
                     {
                         if (EqtTrace.IsInfoEnabled)
                         {
-                            EqtTrace.Info("AssemblyResolver: Resolved assembly: {0}. ", assemblyName);
+                            EqtTrace.Info("MSTest.AssemblyResolver.OnResolve: Resolved assembly '{0}'", assemblyName);
                         }
                     });
 
@@ -699,7 +720,7 @@ private static void SafeLog(string? assemblyName, Action loggerAction)
                     {
                         if (EqtTrace.IsInfoEnabled)
                         {
-                            EqtTrace.Info("AssemblyResolver: Failed to load assembly: {0}. Reason:{1} ", assemblyName, ex);
+                            EqtTrace.Info("MSTest.AssemblyResolver.OnResolve: Failed to load assembly '{0}'. Reason:{1} ", assemblyName, ex);
                         }
                     });
 
@@ -717,7 +738,7 @@ private static void SafeLog(string? assemblyName, Action loggerAction)
                     {
                         if (EqtTrace.IsInfoEnabled)
                         {
-                            EqtTrace.Info("AssemblyResolver: Failed to load assembly: {0}. Reason:{1} ", assemblyName, ex);
+                            EqtTrace.Info("MSTest.AssemblyResolver.OnResolve: Failed to load assembly '{0}'. Reason:{1} ", assemblyName, ex);
                         }
                     });
         }
diff --git a/src/Adapter/MSTestAdapter.PlatformServices/Services/TestSourceHost.cs b/src/Adapter/MSTestAdapter.PlatformServices/Services/TestSourceHost.cs
@@ -102,14 +102,8 @@ internal TestSourceHost(string sourceFileName, IRunSettings? runSettings, IFrame
     /// </summary>
     public void SetupHost()
     {
-#if NETFRAMEWORK || NET
-        List<string> resolutionPaths = GetResolutionPaths(
-            _sourceFileName,
-#if NETFRAMEWORK
-            VSInstallationUtilities.IsCurrentProcessRunningInPortableMode());
-#else
-            false);
-#endif
+#if NET
+        List<string> resolutionPaths = GetResolutionPaths(_sourceFileName, false);
 
         if (EqtTrace.IsInfoEnabled)
         {
@@ -125,10 +119,20 @@ public void SetupHost()
         {
             assemblyResolver.Dispose();
         }
+#elif NETFRAMEWORK
+        List<string> resolutionPaths = GetResolutionPaths(_sourceFileName, VSInstallationUtilities.IsCurrentProcessRunningInPortableMode());
 
-#endif
+        if (EqtTrace.IsInfoEnabled)
+        {
+            EqtTrace.Info("DesktopTestSourceHost.SetupHost(): Creating assembly resolver with resolution paths {0}.", string.Join(",", resolutionPaths));
+        }
+
+        // NOTE: These 2 lines are super important, see https://github.com/microsoft/testfx/issues/2922
+        // It's not entirely clear why but not assigning directly the resolver to the field (or/and) disposing the resolver in
+        // case of an error in TryAddSearchDirectoriesSpecifiedInRunSettingsToAssemblyResolver causes the issue.
+        _parentDomainAssemblyResolver = new AssemblyResolver(resolutionPaths);
+        _ = TryAddSearchDirectoriesSpecifiedInRunSettingsToAssemblyResolver(_parentDomainAssemblyResolver, Path.GetDirectoryName(_sourceFileName)!);
 
-#if NETFRAMEWORK
         // Case when DisableAppDomain setting is present in runsettings and no child-appdomain needs to be created
         if (!_isAppDomainCreationDisabled)
         {
diff --git a/test/IntegrationTests/MSTest.Acceptance.IntegrationTests/AssemblyResolverTests.cs b/test/IntegrationTests/MSTest.Acceptance.IntegrationTests/AssemblyResolverTests.cs
@@ -10,8 +10,8 @@ namespace MSTest.Acceptance.IntegrationTests;
 [TestGroup]
 public class AssemblyResolverTests : AcceptanceTestBase
 {
-    private readonly TestAssetFixture _testAssetFixture;
     private const string AssetName = "AssemblyResolverCrash";
+    private readonly TestAssetFixture _testAssetFixture;
 
     // There's a bug in TAFX where we need to use it at least one time somewhere to use it inside the fixture self (AcceptanceFixture).
     public AssemblyResolverTests(ITestExecutionContext testExecutionContext, TestAssetFixture testAssetFixture,
@@ -31,7 +31,7 @@ public async Task RunningTests_DoesNotHitResourceRecursionIssueAndDoesNotCrashTh
 
         var testHost = TestHost.LocateFrom(_testAssetFixture.TargetAssetPath, AssetName, TargetFrameworks.NetFramework[0].Arguments);
 
-        var testHostResult = await testHost.ExecuteAsync();
+        TestHostResult testHostResult = await testHost.ExecuteAsync();
 
         testHostResult.AssertExitCodeIs(ExitCodes.Success);
     }

Original file line number	Diff line number	Diff line change
`@@ -86,6 +86,7 @@ class AssemblyResolver :`
`86`	`86`	`/// </summary>`
`87`	`87`	`private readonly object _syncLock = new();`
`88`	`88`
	`89`	`+ private static List<string>? s_currentlyLoading;`
`89`	`90`	`private bool _disposed;`
`90`	`91`
`91`	`92`	`/// <summary>`
`@@ -335,7 +336,7 @@ protected virtual`
`335`	`336`	`if (EqtTrace.IsInfoEnabled)`
`336`	`337`	`{`
`337`	`338`	`EqtTrace.Info(`
`338`		`- "AssemblyResolver: {0}: Failed to create assemblyName. Reason:{1} ",`
	`339`	`+ "MSTest.AssemblyResolver.OnResolve: Failed to create assemblyName '{0}'. Reason: {1} ",`
`339`	`340`	`name,`
`340`	`341`	`ex);`
`341`	`342`	`}`
`@@ -344,7 +345,7 @@ protected virtual`
`344`	`345`	`return null;`
`345`	`346`	`}`
`346`	`347`
`347`		`- DebugEx.Assert(requestedName != null && !StringEx.IsNullOrEmpty(requestedName.Name), "AssemblyResolver.OnResolve: requested is null or name is empty!");`
	`348`	`+ DebugEx.Assert(requestedName != null && !StringEx.IsNullOrEmpty(requestedName.Name), "MSTest.AssemblyResolver.OnResolve: requested is null or name is empty!");`
`348`	`349`
`349`	`350`	`foreach (string dir in searchDirectorypaths)`
`350`	`351`	`{`
`@@ -359,15 +360,39 @@ protected virtual`
`359`	`360`	`{`
`360`	`361`	`if (EqtTrace.IsVerboseEnabled)`
`361`	`362`	`{`
`362`		`- EqtTrace.Verbose("AssemblyResolver: Searching assembly: {0} in the directory: {1}", requestedName.Name, dir);`
	`363`	`+ EqtTrace.Verbose("MSTest.AssemblyResolver.OnResolve: Searching assembly '{0}' in the directory '{1}'", requestedName.Name, dir);`
`363`	`364`	`}`
`364`	`365`	`});`
`365`	`366`
`366`	`367`	`foreach (string extension in new string[] { ".dll", ".exe" })`
`367`	`368`	`{`
`368`	`369`	`string assemblyPath = Path.Combine(dir, requestedName.Name + extension);`
`369`	`370`
	`371`	`+ bool isPushed = false;`
	`372`	`+ bool isResource = requestedName.Name.EndsWith(".resources", StringComparison.InvariantCulture);`
	`373`	`+ if (isResource)`
	`374`	`+ {`
	`375`	`+ // Are we recursively looking up the same resource? Note - our backout code will set`
	`376`	`+ // the ResourceHelper's currentlyLoading stack to null if an exception occurs.`
	`377`	`+ if (s_currentlyLoading != null && s_currentlyLoading.Count > 0 && s_currentlyLoading.LastIndexOf(assemblyPath) != -1)`
	`378`	`+ {`
	`379`	`+ EqtTrace.Info("MSTest.AssemblyResolver.OnResolve: Assembly '{0}' is searching for itself recursively '{1}', returning as not found.", name, assemblyPath);`
	`380`	`+ _resolvedAssemblies[name] = null;`
	`381`	`+ return null;`
	`382`	`+ }`
	`383`	`+`
	`384`	`+ s_currentlyLoading ??= new List<string>();`
	`385`	`+ s_currentlyLoading.Add(assemblyPath); // Push`
	`386`	`+ isPushed = true;`
	`387`	`+ }`
	`388`	`+`
`370`	`389`	`Assembly? assembly = SearchAndLoadAssembly(assemblyPath, name, requestedName, isReflectionOnly);`
	`390`	`+ if (isResource && isPushed)`
	`391`	`+ {`
	`392`	`+ DebugEx.Assert(s_currentlyLoading is not null, "_currentlyLoading should not be null");`
	`393`	`+ s_currentlyLoading.RemoveAt(s_currentlyLoading.Count - 1); // Pop`
	`394`	`+ }`
	`395`	`+`
`371`	`396`	`if (assembly != null)`
`372`	`397`	`{`
`373`	`398`	`return assembly;`
`@@ -447,7 +472,7 @@ private void WindowsRuntimeMetadataReflectionOnlyNamespaceResolve(object sender,`
`447`	`472`	`{`
`448`	`473`	`if (StringEx.IsNullOrEmpty(args.Name))`
`449`	`474`	`{`
`450`		`- Debug.Fail("AssemblyResolver.OnResolve: args.Name is null or empty.");`
	`475`	`+ Debug.Fail("MSTest.AssemblyResolver.OnResolve: args.Name is null or empty.");`
`451`	`476`	`return null;`
`452`	`477`	`}`
`453`	`478`
`@@ -457,7 +482,7 @@ private void WindowsRuntimeMetadataReflectionOnlyNamespaceResolve(object sender,`
`457`	`482`	`{`
`458`	`483`	`if (EqtTrace.IsInfoEnabled)`
`459`	`484`	`{`
`460`		`- EqtTrace.Info("AssemblyResolver: Resolving assembly: {0}.", args.Name);`
	`485`	`+ EqtTrace.Info("MSTest.AssemblyResolver.OnResolve: Resolving assembly '{0}'", args.Name);`
`461`	`486`	`}`
`462`	`487`	`});`
`463`	`488`
`@@ -469,7 +494,7 @@ private void WindowsRuntimeMetadataReflectionOnlyNamespaceResolve(object sender,`
`469`	`494`	`{`
`470`	`495`	`if (EqtTrace.IsInfoEnabled)`
`471`	`496`	`{`
`472`		`- EqtTrace.Info("AssemblyResolver: Resolving assembly after applying policy: {0}.", assemblyNameToLoad);`
	`497`	`+ EqtTrace.Info("MSTest.AssemblyResolver.OnResolve: Resolving assembly after applying policy '{0}'", assemblyNameToLoad);`
`473`	`498`	`}`
`474`	`499`	`});`
`475`	`500`
`@@ -482,62 +507,58 @@ private void WindowsRuntimeMetadataReflectionOnlyNamespaceResolve(object sender,`
`482`	`507`	`}`
`483`	`508`
`484`	`509`	`assembly = SearchAssembly(_searchDirectories, assemblyNameToLoad, isReflectionOnly);`
`485`		`-`
`486`	`510`	`if (assembly != null)`
`487`	`511`	`{`
`488`	`512`	`return assembly;`
`489`	`513`	`}`
`490`	`514`
`491`		`- if (_directoryList != null && _directoryList.Count != 0)`
	`515`	`+ // required assembly is not present in searchDirectories??`
	`516`	`+ // see, if we can find it in user specified search directories.`
	`517`	`+ while (assembly == null && _directoryList?.Count > 0)`
`492`	`518`	`{`
`493`		`- // required assembly is not present in searchDirectories??`
`494`		`- // see, if we can find it in user specified search directories.`
`495`		`- while (assembly == null && _directoryList.Count > 0)`
`496`		`- {`
`497`		`- // instead of loading whole search directory in one time, we are adding directory on the basis of need`
`498`		`- RecursiveDirectoryPath currentNode = _directoryList.Dequeue();`
`499`		`-`
`500`		`- List<string> incrementalSearchDirectory = [];`
	`519`	`+ // instead of loading whole search directory in one time, we are adding directory on the basis of need`
	`520`	`+ RecursiveDirectoryPath currentNode = _directoryList.Dequeue();`
`501`	`521`
`502`		`- if (DoesDirectoryExist(currentNode.DirectoryPath))`
`503`		`- {`
`504`		`- incrementalSearchDirectory.Add(currentNode.DirectoryPath);`
`505`		`-`
`506`		`- if (currentNode.IncludeSubDirectories)`
`507`		`- {`
`508`		`- // Add all its sub-directory in depth first search order.`
`509`		`- AddSubdirectories(currentNode.DirectoryPath, incrementalSearchDirectory);`
`510`		`- }`
	`522`	`+ List<string> incrementalSearchDirectory = [];`
`511`	`523`
`512`		`- // Add this directory list in this.searchDirectories so that when we will try to resolve some other`
`513`		`- // assembly, then it will look in this whole directory first.`
`514`		`- _searchDirectories.AddRange(incrementalSearchDirectory);`
	`524`	`+ if (DoesDirectoryExist(currentNode.DirectoryPath))`
	`525`	`+ {`
	`526`	`+ incrementalSearchDirectory.Add(currentNode.DirectoryPath);`
`515`	`527`
`516`		`- assembly = SearchAssembly(incrementalSearchDirectory, assemblyNameToLoad, isReflectionOnly);`
`517`		`- }`
`518`		`- else`
	`528`	`+ if (currentNode.IncludeSubDirectories)`
`519`	`529`	`{`
`520`		`- // generate warning that path does not exist.`
`521`		`- SafeLog(`
`522`		`- assemblyNameToLoad,`
`523`		`- () =>`
`524`		`- {`
`525`		`- if (EqtTrace.IsWarningEnabled)`
`526`		`- {`
`527`		`- EqtTrace.Warning(`
`528`		`- "The Directory: {0}, does not exist",`
`529`		`- currentNode.DirectoryPath);`
`530`		`- }`
`531`		`- });`
	`530`	`+ // Add all its sub-directory in depth first search order.`
	`531`	`+ AddSubdirectories(currentNode.DirectoryPath, incrementalSearchDirectory);`
`532`	`532`	`}`
`533`		`- }`
`534`	`533`
`535`		`- if (assembly != null)`
	`534`	`+ // Add this directory list in this.searchDirectories so that when we will try to resolve some other`
	`535`	`+ // assembly, then it will look in this whole directory first.`
	`536`	`+ _searchDirectories.AddRange(incrementalSearchDirectory);`
	`537`	`+`
	`538`	`+ assembly = SearchAssembly(incrementalSearchDirectory, assemblyNameToLoad, isReflectionOnly);`
	`539`	`+ }`
	`540`	`+ else`
`536`	`541`	`{`
`537`		`- return assembly;`
	`542`	`+ // generate warning that path does not exist.`
	`543`	`+ SafeLog(`
	`544`	`+ assemblyNameToLoad,`
	`545`	`+ () =>`
	`546`	`+ {`
	`547`	`+ if (EqtTrace.IsWarningEnabled)`
	`548`	`+ {`
	`549`	`+ EqtTrace.Warning(`
	`550`	`+ "MSTest.AssemblyResolver.OnResolve: the directory '{0}', does not exist",`
	`551`	`+ currentNode.DirectoryPath);`
	`552`	`+ }`
	`553`	`+ });`
`538`	`554`	`}`
`539`	`555`	`}`
`540`	`556`
	`557`	`+ if (assembly != null)`
	`558`	`+ {`
	`559`	`+ return assembly;`
	`560`	`+ }`
	`561`	`+`
`541`	`562`	`// Try for default load for System dlls that can't be found in search paths. Needs to loaded just by name.`
`542`	`563`	`try`
`543`	`564`	`{`
`@@ -580,7 +601,7 @@ private void WindowsRuntimeMetadataReflectionOnlyNamespaceResolve(object sender,`
`580`	`601`	`{`
`581`	`602`	`if (EqtTrace.IsInfoEnabled)`
`582`	`603`	`{`
`583`		`- EqtTrace.Info("AssemblyResolver: {0}: Failed to load assembly. Reason: {1}", assemblyNameToLoad, ex);`
	`604`	`+ EqtTrace.Info("MSTest.AssemblyResolver.OnResolve: Failed to load assembly '{0}'. Reason: {1}", assemblyNameToLoad, ex);`
`584`	`605`	`}`
`585`	`606`	`});`
`586`	`607`	`}`
`@@ -609,7 +630,7 @@ private bool TryLoadFromCache(string assemblyName, bool isReflectionOnly, out As`
`609`	`630`	`{`
`610`	`631`	`if (EqtTrace.IsInfoEnabled)`
`611`	`632`	`{`
`612`		`- EqtTrace.Info("AssemblyResolver: Resolved: {0}.", assemblyName);`
	`633`	`+ EqtTrace.Info("MSTest.AssemblyResolver.OnResolve: Resolved '{0}'", assemblyName);`
`613`	`634`	`}`
`614`	`635`	`});`
`615`	`636`	`return true;`
`@@ -685,7 +706,7 @@ private static void SafeLog(string? assemblyName, Action loggerAction)`
`685`	`706`	`{`
`686`	`707`	`if (EqtTrace.IsInfoEnabled)`
`687`	`708`	`{`
`688`		`- EqtTrace.Info("AssemblyResolver: Resolved assembly: {0}. ", assemblyName);`
	`709`	`+ EqtTrace.Info("MSTest.AssemblyResolver.OnResolve: Resolved assembly '{0}'", assemblyName);`
`689`	`710`	`}`
`690`	`711`	`});`
`691`	`712`
`@@ -699,7 +720,7 @@ private static void SafeLog(string? assemblyName, Action loggerAction)`
`699`	`720`	`{`
`700`	`721`	`if (EqtTrace.IsInfoEnabled)`
`701`	`722`	`{`
`702`		`- EqtTrace.Info("AssemblyResolver: Failed to load assembly: {0}. Reason:{1} ", assemblyName, ex);`
	`723`	`+ EqtTrace.Info("MSTest.AssemblyResolver.OnResolve: Failed to load assembly '{0}'. Reason:{1} ", assemblyName, ex);`
`703`	`724`	`}`
`704`	`725`	`});`
`705`	`726`
`@@ -717,7 +738,7 @@ private static void SafeLog(string? assemblyName, Action loggerAction)`
`717`	`738`	`{`
`718`	`739`	`if (EqtTrace.IsInfoEnabled)`
`719`	`740`	`{`
`720`		`- EqtTrace.Info("AssemblyResolver: Failed to load assembly: {0}. Reason:{1} ", assemblyName, ex);`
	`741`	`+ EqtTrace.Info("MSTest.AssemblyResolver.OnResolve: Failed to load assembly '{0}'. Reason:{1} ", assemblyName, ex);`
`721`	`742`	`}`
`722`	`743`	`});`
`723`	`744`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,8 +10,8 @@ namespace MSTest.Acceptance.IntegrationTests;`
`10`	`10`	`[TestGroup]`
`11`	`11`	`public class AssemblyResolverTests : AcceptanceTestBase`
`12`	`12`	`{`
`13`		`- private readonly TestAssetFixture _testAssetFixture;`
`14`	`13`	`private const string AssetName = "AssemblyResolverCrash";`
	`14`	`+ private readonly TestAssetFixture _testAssetFixture;`
`15`	`15`
`16`	`16`	`// There's a bug in TAFX where we need to use it at least one time somewhere to use it inside the fixture self (AcceptanceFixture).`
`17`	`17`	`public AssemblyResolverTests(ITestExecutionContext testExecutionContext, TestAssetFixture testAssetFixture,`
`@@ -31,7 +31,7 @@ public async Task RunningTests_DoesNotHitResourceRecursionIssueAndDoesNotCrashTh`
`31`	`31`
`32`	`32`	`var testHost = TestHost.LocateFrom(_testAssetFixture.TargetAssetPath, AssetName, TargetFrameworks.NetFramework[0].Arguments);`
`33`	`33`
`34`		`- var testHostResult = await testHost.ExecuteAsync();`
	`34`	`+ TestHostResult testHostResult = await testHost.ExecuteAsync();`
`35`	`35`
`36`	`36`	`testHostResult.AssertExitCodeIs(ExitCodes.Success);`
`37`	`37`	`}`