Drop the ObjectModel package reference from PlatformServices (Phase 7 capstone)

src/Adapter/MSTest.TestAdapter/MSTest.TestAdapter.csproj

@@ -82,6 +82,12 @@
          that reference is suppressed above, so they are referenced explicitly here. -->
     <PackageReference Include="System.Threading.Tasks.Extensions" Condition=" '$(TargetFramework)' == '$(NetFrameworkMinimum)' OR '$(TargetFramework)' == '$(UwpMinimum)' " />
     <PackageReference Include="System.Memory" Condition=" '$(TargetFramework)' == '$(NetFrameworkMinimum)' OR '$(TargetFramework)' == '$(UwpMinimum)' " />
+
+    <!-- The adapter's VSTest-facing code (VSTestAdapter\*, AdapterTestProperties) uses the VSTest object model
+         directly. On other TFMs it flows in transitively via Microsoft.Testing.Extensions.VSTestBridge, but that
+         reference is not added for UWP (see above), and PlatformServices no longer references the object model,
+         so it is referenced explicitly here for UWP. -->
+    <PackageReference Include="Microsoft.TestPlatform.ObjectModel" Condition=" '$(TargetFramework)' == '$(UwpMinimum)' " />
   </ItemGroup>
 
   <ItemGroup>

src/Adapter/MSTestAdapter.PlatformServices/ApartmentStateSetting.cs

@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter;
+
+/// <summary>
+/// Apartment state parsed from the <c>ExecutionThreadApartmentState</c> run settings and the
+/// <c>mstest:execution:executionApartmentState</c> configuration value. This is the adapter's own neutral
+/// replacement for the former VSTest <c>PlatformAbstractions.PlatformApartmentState</c> enum.
+/// </summary>
+internal enum ApartmentStateSetting
+{
+    // The member order is load-bearing: Enum.TryParse maps numeric-string run settings values ("0"/"1")
+    // by number, so MTA must stay 0 and STA must stay 1 to preserve parse compatibility with the former
+    // VSTest PlatformAbstractions.PlatformApartmentState enum. Do not reorder.
+    MTA,
+    STA,
+}

src/Adapter/MSTestAdapter.PlatformServices/MSTestAdapter.PlatformServices.csproj

@@ -36,14 +36,20 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.TestPlatform.ObjectModel" />
     <PackageReference Include="System.Threading.Tasks.Extensions" Condition=" '$(TargetFramework)' == 'netstandard2.0' OR '$(TargetFramework)' == '$(NetFrameworkMinimum)' OR '$(TargetFramework)' == '$(UwpMinimum)' " />
     <!-- Span/MemoryMarshal used by the linked XxHash code below live in System.Memory on these TFMs.
          Referenced explicitly so the compiled assembly binds the System.Memory assembly version 4.0.5.0
          (see SystemMemoryVersion in Directory.Packages.props) instead of the transitive 4.5.5 (4.0.1.2). -->
     <PackageReference Include="System.Memory" Condition=" '$(TargetFramework)' == 'netstandard2.0' OR '$(TargetFramework)' == '$(NetFrameworkMinimum)' OR '$(TargetFramework)' == '$(UwpMinimum)' " />
   </ItemGroup>
 
+  <!-- System.Configuration (ConfigurationManager / ConfigurationElementCollection used by TestDataSource on .NET
+       Framework) was previously pulled in transitively via Microsoft.TestPlatform.ObjectModel. It is a framework
+       assembly, so it is referenced directly now that the object-model package reference is removed. -->
+  <ItemGroup Condition=" '$(TargetFramework)' == '$(NetFrameworkMinimum)' ">
+    <Reference Include="System.Configuration" />
+  </ItemGroup>
+
   <ItemGroup>
     <Compile Include="$(RepoRoot)src/Polyfills/**/*.cs" Link="Polyfills\%(RecursiveDir)%(Filename)%(Extension)" />
   </ItemGroup>

src/Adapter/MSTestAdapter.PlatformServices/RunConfigurationSettings.cs

@@ -5,7 +5,6 @@
 using Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.Interface;
 #endif
 
-using Microsoft.VisualStudio.TestPlatform.PlatformAbstractions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter;
@@ -96,13 +95,13 @@ private static RunConfigurationSettings ToSettings(XmlReader reader)
                 {
                     case "EXECUTIONTHREADAPARTMENTSTATE":
                         {
-                            if (Enum.TryParse(reader.ReadInnerXml(), out PlatformApartmentState platformApartmentState))
+                            if (Enum.TryParse(reader.ReadInnerXml(), out ApartmentStateSetting apartmentStateSetting))
                             {
-                                settings.ExecutionApartmentState = platformApartmentState switch
+                                settings.ExecutionApartmentState = apartmentStateSetting switch
                                 {
-                                    PlatformApartmentState.STA => ApartmentState.STA,
-                                    PlatformApartmentState.MTA => ApartmentState.MTA,
-                                    _ => throw new NotSupportedException($"Platform apartment state '{platformApartmentState}' is not supported."),
+                                    ApartmentStateSetting.STA => ApartmentState.STA,
+                                    ApartmentStateSetting.MTA => ApartmentState.MTA,
+                                    _ => throw new NotSupportedException($"Platform apartment state '{apartmentStateSetting}' is not supported."),
                                 };
                             }
 
@@ -131,13 +130,13 @@ internal static RunConfigurationSettings SetRunConfigurationSettingsFromConfig(I
         //  }
         // }
         string? apartmentStateValue = configuration["mstest:execution:executionApartmentState"];
-        if (Enum.TryParse(apartmentStateValue, out PlatformApartmentState platformApartmentState))
+        if (Enum.TryParse(apartmentStateValue, out ApartmentStateSetting apartmentStateSetting))
         {
-            settings.ExecutionApartmentState = platformApartmentState switch
+            settings.ExecutionApartmentState = apartmentStateSetting switch
             {
-                PlatformApartmentState.STA => ApartmentState.STA,
-                PlatformApartmentState.MTA => ApartmentState.MTA,
-                _ => throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, Resource.InvalidValue, platformApartmentState, "execution:executionApartmentState")),
+                ApartmentStateSetting.STA => ApartmentState.STA,
+                ApartmentStateSetting.MTA => ApartmentState.MTA,
+                _ => throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, Resource.InvalidValue, apartmentStateSetting, "execution:executionApartmentState")),
             };
         }
 

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

@@ -110,7 +110,7 @@ public bool IsAssemblyReferenced(AssemblyName assemblyName, string source)
         try
         {
             string? referenceAssemblyName = referenceAssembly.Name;
-            byte[] referenceAssemblyPublicKeyToken = referenceAssembly.GetPublicKeyToken();
+            byte[]? referenceAssemblyPublicKeyToken = referenceAssembly.GetPublicKeyToken();
 
             // ReflectionOnlyLoadFrom loads from the specified path only (no probing) and does not
             // execute any code from the loaded assembly.
@@ -139,8 +139,20 @@ public bool IsAssemblyReferenced(AssemblyName assemblyName, string source)
         }
     }
 
-    private static bool ArePublicKeyTokensEqual(byte[] left, byte[] right)
+    private static bool ArePublicKeyTokensEqual(byte[]? left, byte[]? right)
     {
+        // GetPublicKeyToken() returns null (or an empty array) for unsigned assemblies.
+        // Treat two unsigned tokens as equal, and a signed vs. unsigned pair as unequal.
+        if (left is null || left.Length == 0)
+        {
+            return right is null || right.Length == 0;
+        }
+
+        if (right is null || right.Length == 0)
+        {
+            return false;
+        }
+
         if (left.Length != right.Length)
         {
             return false;

test/IntegrationTests/PlatformServices.Desktop.IntegrationTests/PlatformServices.Desktop.IntegrationTests.csproj

@@ -15,6 +15,9 @@
     <PackageReference Include="Moq" />
     <PackageReference Include="AwesomeAssertions" />
     <PackageReference Include="StrongNamer" />
+    <!-- This test uses ObjectModel's XmlRunSettingsUtilities directly; it was previously provided transitively
+         through the MSTestAdapter.PlatformServices project reference, which no longer depends on the object model. -->
+    <PackageReference Include="Microsoft.TestPlatform.ObjectModel" />
   </ItemGroup>
 
 </Project>

test/UnitTests/MSTestAdapter.PlatformServices.UnitTests/ObjectModelDecouplingTests.cs

@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using AwesomeAssertions;
+
+using Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices;
+
+using TestFramework.ForTestingMSTest;
+
+namespace MSTestAdapter.PlatformServices.UnitTests;
+
+public class ObjectModelDecouplingTests : TestContainer
+{
+    // Guards the platform-agnostic contract: the compiled MSTestAdapter.PlatformServices assembly must not
+    // reference the VSTest object model (Microsoft.VisualStudio.TestPlatform.ObjectModel) or any other
+    // Microsoft.*.TestPlatform.* assembly. All VSTest coupling lives in the MSTest.TestAdapter layer above it.
+    public void PlatformServicesAssemblyShouldNotReferenceAnyTestPlatformAssembly()
+    {
+        Assembly platformServices = typeof(TestSourceHandler).Assembly;
+
+        IEnumerable<string> testPlatformReferences = platformServices
+            .GetReferencedAssemblies()
+            .Select(reference => reference.Name!)
+            .Where(name => name.IndexOf("TestPlatform", StringComparison.OrdinalIgnoreCase) >= 0);
+
+        testPlatformReferences.Should().BeEmpty(
+            "PlatformServices must stay platform-agnostic and must not reference the VSTest object model or any Microsoft.*.TestPlatform.* assembly");
+    }
+}

test/UnitTests/MSTestAdapter.PlatformServices.UnitTests/Services/DesktopTestSourceTests.cs

@@ -29,5 +29,20 @@ public class DesktopTestSourceTests : TestContainer
     public void IsAssemblyReferencedShouldReturnTrueIfAnAssemblyIsReferencedInSource() => _testSource.IsAssemblyReferenced(typeof(Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute).Assembly.GetName(), Assembly.GetExecutingAssembly().Location).Should().BeTrue();
 
     public void IsAssemblyReferencedShouldReturnFalseIfAnAssemblyIsNotReferencedInSource() => _testSource.IsAssemblyReferenced(new AssemblyName("foobar"), Assembly.GetExecutingAssembly().Location).Should().BeFalse();
+
+    // The source references the strong-named MSTest.TestFramework assembly. Passing an assembly name with the
+    // same simple name but no public key token (as an unsigned build would have) must not be considered a match:
+    // the public key tokens differ (signed vs. unsigned), so IsAssemblyReferenced returns false. This guards the
+    // signed-vs-unsigned branch of the public-key-token comparison.
+    public void IsAssemblyReferencedShouldReturnFalseIfPublicKeyTokenIsMissing() => _testSource.IsAssemblyReferenced(new AssemblyName("MSTest.TestFramework"), Assembly.GetExecutingAssembly().Location).Should().BeFalse();
+
+    // Same simple name but a different (non-null) public key token must also not match: the tokens are compared
+    // byte-by-byte and differ. This guards the differing-token branch of the public-key-token comparison.
+    public void IsAssemblyReferencedShouldReturnFalseIfPublicKeyTokenDiffers()
+    {
+        var assemblyName = new AssemblyName("MSTest.TestFramework");
+        assemblyName.SetPublicKeyToken([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]);
+        _testSource.IsAssemblyReferenced(assemblyName, Assembly.GetExecutingAssembly().Location).Should().BeFalse();
+    }
 }
 #endif