Fix intermittient test failures that use Locator, introduced a scope (#4251)

This pull request introduces a new `LocatorScope` helper to safely
isolate and restore the global service locator state (`Locator.Current`)
during tests, and applies it to several test fixtures that modify the
locator. This change ensures better test reliability and prevents state
leakage between tests. Additionally, the documentation is updated to
reflect the new approach.

**Test isolation improvements:**

* Added a new `LocatorScope` class in
`ReactiveUI.Tests.Infrastructure.StaticState` to snapshot and restore
`Locator.Current` during tests, preventing global state leakage and
making tests more reliable.
* Updated test fixtures (`CommandBindingTests`, `MessageBusTest`,
`RoutedViewHostTests`, `ViewModelViewHostTests`) to use `LocatorScope`
in their setup and teardown methods, ensuring the service locator is
properly isolated for each test run.
[[1]](diffhunk://#diff-cb950c3f874cb7e5c5a49fd2bedc2fa3e51511aa6db8462f270eef23f11e0028R13-R48)
[[2]](diffhunk://#diff-f7f03456bd65136087c07d8367d29b062028508f41480f8a69365c4c88bf9f0dR20-R33)
[[3]](diffhunk://#diff-d9dbb1c8d2fee1ef13344fb77470509a36bcb26ae3e9d613b5af99375386f9d0R27-R40)
[[4]](diffhunk://#diff-5580daabcb200c9598e649dfc4cf40d21a8c3600f93763afda29711563b0387cR26-R39)

**Test metadata and documentation:**

* Marked `WhenAnyObservableTests` as `[NotInParallel]` and added XML
documentation explaining the need for test isolation due to reliance on
the service locator.
* Updated using statements to import the new `LocatorScope` where
required.
[[1]](diffhunk://#diff-d9dbb1c8d2fee1ef13344fb77470509a36bcb26ae3e9d613b5af99375386f9d0R8)
[[2]](diffhunk://#diff-5580daabcb200c9598e649dfc4cf40d21a8c3600f93763afda29711563b0387cR8)

**Documentation updates:**

* Removed the outdated `StaticState/README.md` and replaced its guidance
with the new `LocatorScope` approach for managing static state in tests.

Author: glennawatson

src/tests/ReactiveUI.NonParallel.Tests/CommandBinding/CommandBindingTests.cs

@@ -10,21 +10,42 @@
 using System.Threading.Tasks;
 using System.Windows.Input;
 using ReactiveUI;
+using ReactiveUI.Tests.Infrastructure.StaticState;
 using Splat;
 
 namespace ReactiveUI.NonParallel.Tests
 {
+    /// <summary>
+    /// Tests for command binding.
+    /// </summary>
+    /// <remarks>
+    /// This test fixture is marked as NotInParallel because tests call
+    /// Locator.CurrentMutable to register ICreatesCommandBinding implementations,
+    /// which mutate global service locator state.
+    /// </remarks>
+    [NotInParallel]
     public class CommandBindingTests
     {
-        public CommandBindingTests()
+        private LocatorScope? _locatorScope;
+
+        [Before(Test)]
+        public void SetUp()
         {
+            _locatorScope = new LocatorScope();
+
             Locator.CurrentMutable.InitializeSplat();
             Locator.CurrentMutable.RegisterConstant(new CreatesCommandBindingViaEvent(), typeof(ICreatesCommandBinding));
 
             // Register a custom binder to test binder resolution
             Locator.CurrentMutable.RegisterConstant(new FakeCustomBinder(), typeof(ICreatesCommandBinding));
         }
 
+        [After(Test)]
+        public void TearDown()
+        {
+            _locatorScope?.Dispose();
+        }
+
         [Test]
         public async Task CommandBinderImplementation_Should_Bind_Command_To_Event()
         {

src/tests/ReactiveUI.NonParallel.Tests/MessageBusTest.cs

@@ -17,17 +17,20 @@ namespace ReactiveUI.Tests.Core;
 public class MessageBusTest : IDisposable
 {
     private MessageBusScope? _messageBusScope;
+    private LocatorScope? _locatorScope;
 
     [Before(Test)]
     public void SetUp()
     {
+        _locatorScope = new LocatorScope();
         _messageBusScope = new MessageBusScope();
     }
 
     [After(Test)]
     public void TearDown()
     {
         _messageBusScope?.Dispose();
+        _locatorScope?.Dispose();
     }
 
     /// <summary>

src/tests/ReactiveUI.NonParallel.Tests/Platforms/windows-xaml/RoutedViewHostTests.cs

@@ -5,6 +5,7 @@
 
 using System.Windows;
 using DynamicData;
+using ReactiveUI.Tests.Infrastructure.StaticState;
 using ReactiveUI.Tests.Wpf;
 
 using TUnit.Core.Executors;
@@ -23,6 +24,20 @@ namespace ReactiveUI.Tests;
 [NotInParallel]
 public class RoutedViewHostTests
 {
+    private LocatorScope? _locatorScope;
+
+    [Before(Test)]
+    public void SetUp()
+    {
+        _locatorScope = new LocatorScope();
+    }
+
+    [After(Test)]
+    public void TearDown()
+    {
+        _locatorScope?.Dispose();
+    }
+
     [Test]
     [TestExecutor<STAThreadExecutor>]
     public async Task RoutedViewHostDefaultContentNotNull()

src/tests/ReactiveUI.NonParallel.Tests/Platforms/windows-xaml/ViewModelViewHostTests.cs

@@ -5,6 +5,7 @@
 
 using System.Windows;
 using DynamicData;
+using ReactiveUI.Tests.Infrastructure.StaticState;
 using ReactiveUI.Tests.Wpf;
 
 using TUnit.Core.Executors;
@@ -22,6 +23,20 @@ namespace ReactiveUI.Tests;
 [NotInParallel]
 public class ViewModelViewHostTests
 {
+    private LocatorScope? _locatorScope;
+
+    [Before(Test)]
+    public void SetUp()
+    {
+        _locatorScope = new LocatorScope();
+    }
+
+    [After(Test)]
+    public void TearDown()
+    {
+        _locatorScope?.Dispose();
+    }
+
     [Test]
     [TestExecutor<STAThreadExecutor>]
     public async Task ViewModelViewHostDefaultContentNotNull()

…Tests/WhenAny/TestWhenAnyObsViewModel.cs …Tests/WhenAny/TestWhenAnyObsViewModel.cssrc/tests/ReactiveUI.Tests/WhenAny/TestWhenAnyObsViewModel.cs renamed to src/tests/ReactiveUI.NonParallel.Tests/WhenAny/TestWhenAnyObsViewModel.cs src/tests/ReactiveUI.Tests/WhenAny/TestWhenAnyObsViewModel.cs renamed to src/tests/ReactiveUI.NonParallel.Tests/WhenAny/TestWhenAnyObsViewModel.cs

@@ -7,6 +7,14 @@
 
 namespace ReactiveUI.Tests;
 
+/// <summary>
+/// Tests for WhenAnyObservable functionality.
+/// This test class is marked as NotInParallel because WhenAnyObservable relies on
+/// the service locator (Locator.Current) to find ICreatesObservableForProperty implementations.
+/// When tests run in parallel, they can interfere with each other's service locator state,
+/// causing intermittent failures with "Could not find a ICreatesObservableForProperty" errors.
+/// </summary>
+[NotInParallel]
 public class WhenAnyObservableTests
 {
     /// <summary>

….Tests/WhenAny/WhenAnyObservableTests.cs ….Tests/WhenAny/WhenAnyObservableTests.cssrc/tests/ReactiveUI.Tests/WhenAny/WhenAnyObservableTests.cs renamed to src/tests/ReactiveUI.NonParallel.Tests/WhenAny/WhenAnyObservableTests.cs src/tests/ReactiveUI.Tests/WhenAny/WhenAnyObservableTests.cs renamed to src/tests/ReactiveUI.NonParallel.Tests/WhenAny/WhenAnyObservableTests.cs

@@ -0,0 +1,72 @@
+// Copyright (c) 2025 .NET Foundation and Contributors. All rights reserved.
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using Splat;
+
+namespace ReactiveUI.Tests.Infrastructure.StaticState;
+
+/// <summary>
+/// A disposable scope that snapshots and restores Splat's Locator.Current static state.
+/// Use this in test fixtures that read or modify Locator.CurrentMutable to ensure
+/// static state is properly restored after tests complete.
+/// </summary>
+/// <remarks>
+/// This helper is necessary because Splat's Locator maintains a static/global reference
+/// that can leak between test executions, causing intermittent failures.
+/// Tests using this scope should also be marked with [NotInParallel] to prevent
+/// concurrent modifications to the shared state.
+/// </remarks>
+/// <example>
+/// <code>
+/// [NotInParallel]
+/// public class MyTests
+/// {
+///     private LocatorScope? _locatorScope;
+///
+///     [Before(Test)]
+///     public void SetUp()
+///     {
+///         _locatorScope = new LocatorScope();
+///         // Now safe to use Locator.CurrentMutable
+///     }
+///
+///     [After(Test)]
+///     public void TearDown()
+///     {
+///         _locatorScope?.Dispose();
+///     }
+/// }
+/// </code>
+/// </example>
+public sealed class LocatorScope : IDisposable
+{
+    private readonly IReadonlyDependencyResolver _previousLocator;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="LocatorScope"/> class.
+    /// Captures the current Locator state and sets up a fresh locator for testing.
+    /// </summary>
+    public LocatorScope()
+    {
+        // Save the current locator so we can restore it later
+        _previousLocator = Locator.Current;
+
+        // Replace with a new locator that tests can modify
+        var newLocator = new ModernDependencyResolver();
+        newLocator.InitializeSplat();
+        newLocator.InitializeReactiveUI();
+        Locator.SetLocator(newLocator);
+    }
+
+    /// <summary>
+    /// Restores the Locator to its previous state.
+    /// </summary>
+    public void Dispose()
+    {
+        // Restore the previous locator
+        // Cast is safe because we saved it from Locator.Current
+        Locator.SetLocator((IDependencyResolver)_previousLocator);
+    }
+}