Vendor a neutral SuspendCodeCoverage in PlatformServices (Phase 6e-4c3)

src/Adapter/MSTestAdapter.PlatformServices/Services/TestDeployment.cs

@@ -8,12 +8,6 @@
 using Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.Deployment;
 using Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.Interface;
 using Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.Utilities;
-#if NETFRAMEWORK
-// SuspendCodeCoverage (used below to pause dynamic code coverage while deployment copies files) is a VSTest
-// object-model type. Its neutralization is deferred to a later platform-services decoupling step; the rest of
-// the deployment input is already platform-agnostic.
-using Microsoft.VisualStudio.TestPlatform.ObjectModel.Utilities;
-#endif
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices;

src/Adapter/MSTestAdapter.PlatformServices/Services/TestSourceHandler.cs

@@ -5,9 +5,6 @@
 using Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.AppContainer;
 #endif
 using Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.Interface;
-#if NETFRAMEWORK
-using Microsoft.VisualStudio.TestPlatform.ObjectModel.Utilities;
-#endif
 
 namespace Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices;
 
@@ -79,7 +76,7 @@ public bool IsAssemblyReferenced(AssemblyName assemblyName, string source)
     {
 #if NETFRAMEWORK
         // This loads the dll in a different app domain. We can optimize this to load in the current domain since this code could be run in a new app domain anyway.
-        bool? utfReference = AssemblyHelper.DoesReferencesAssembly(source, assemblyName);
+        bool? utfReference = DoesSourceReferenceAssembly(source, assemblyName);
 
         // If no reference to UTF don't run discovery. Take conservative approach. If not able to find proceed with discovery.
         return !utfReference.HasValue || utfReference.Value;
@@ -94,6 +91,73 @@ public bool IsAssemblyReferenced(AssemblyName assemblyName, string source)
 #endif
     }
 
+#if NETFRAMEWORK
+    /// <summary>
+    /// Checks whether the source assembly directly references the given assembly.
+    /// Only the assembly simple name and public key token are matched; version is ignored.
+    /// Returns <see langword="null"/> if the reference could not be determined.
+    /// </summary>
+    /// <param name="source"> The path to the source assembly to inspect. </param>
+    /// <param name="referenceAssembly"> The assembly to look for in the source's references. </param>
+    /// <returns> <see langword="true"/> if referenced, <see langword="false"/> if not, <see langword="null"/> if undeterminable. </returns>
+    private static bool? DoesSourceReferenceAssembly(string source, AssemblyName referenceAssembly)
+    {
+        if (string.IsNullOrEmpty(source) || referenceAssembly is null)
+        {
+            return null;
+        }
+
+        try
+        {
+            string? referenceAssemblyName = referenceAssembly.Name;
+            byte[] referenceAssemblyPublicKeyToken = referenceAssembly.GetPublicKeyToken();
+
+            // ReflectionOnlyLoadFrom loads from the specified path only (no probing) and does not
+            // execute any code from the loaded assembly.
+            var assembly = Assembly.ReflectionOnlyLoadFrom(source);
+
+            foreach (AssemblyName referencedAssembly in assembly.GetReferencedAssemblies())
+            {
+                // Match without version: only the simple name and public key token.
+                if (!string.Equals(referencedAssembly.Name, referenceAssemblyName, StringComparison.OrdinalIgnoreCase))
+                {
+                    continue;
+                }
+
+                if (ArePublicKeyTokensEqual(referencedAssembly.GetPublicKeyToken(), referenceAssemblyPublicKeyToken))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+        catch
+        {
+            // Return null if we are not able to check.
+            return null;
+        }
+    }
+
+    private static bool ArePublicKeyTokensEqual(byte[] left, byte[] right)
+    {
+        if (left.Length != right.Length)
+        {
+            return false;
+        }
+
+        for (int i = 0; i < left.Length; ++i)
+        {
+            if (left[i] != right[i])
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+#endif
+
     /// <summary>
     /// Gets the set of sources (dll's/exe's) that contain tests. If a source is a package (appx), return the file (dll/exe) that contains tests from it.
     /// </summary>

src/Adapter/MSTestAdapter.PlatformServices/Utilities/SuspendCodeCoverage.cs

@@ -0,0 +1,38 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+#if NETFRAMEWORK
+namespace Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.Utilities;
+
+/// <summary>
+/// Suspends dynamic code-coverage instrumentation of the modules that are loaded while this object is alive
+/// (between construction and disposal) by setting the well-known collector environment variable. The previous
+/// value of the environment variable is restored on dispose.
+/// </summary>
+internal sealed class SuspendCodeCoverage : IDisposable
+{
+    private const string SuspendCodeCoverageEnvVarName = "__VANGUARD_SUSPEND_INSTRUMENT__";
+    private const string SuspendCodeCoverageEnvVarTrueValue = "TRUE";
+
+    private readonly string? _previousEnvironmentValue;
+
+    private bool _isDisposed;
+
+    public SuspendCodeCoverage()
+    {
+        _previousEnvironmentValue = Environment.GetEnvironmentVariable(SuspendCodeCoverageEnvVarName, EnvironmentVariableTarget.Process);
+        Environment.SetEnvironmentVariable(SuspendCodeCoverageEnvVarName, SuspendCodeCoverageEnvVarTrueValue, EnvironmentVariableTarget.Process);
+    }
+
+    public void Dispose()
+    {
+        if (_isDisposed)
+        {
+            return;
+        }
+
+        Environment.SetEnvironmentVariable(SuspendCodeCoverageEnvVarName, _previousEnvironmentValue, EnvironmentVariableTarget.Process);
+        _isDisposed = true;
+    }
+}
+#endif