test(wpf): stop the TransitioningContentControl tests waiting on WPF's render loop (#4499)

## Summary

**The `TransitioningContentControl` tests no longer wait on WPF's render
loop, so they cannot time out on a busy runner.**

- **`CompletingTransition_Completes_AbortsTransitionAndRaisesCompleted`
signals completion directly.** It calls the control's completion handler
with the storyboard's clock instead of starting the storyboard and
pumping the dispatcher until WPF ticks it.
- **The double-completion regression test does the same.**
`OnTransitionCompleted_RepeatedForSameClock_RaisesTransitionCompletedOnce`
runs a real content change, signals completion twice with the same clock
as WPF does, then runs a second transition, and expects started,
completed, started, completed.

## Why

**The test failed intermittently in CI, blocking unrelated PRs.**

- It waited for WPF's render loop to tick the animation clock. On a busy
runner the loop can stall, and the test failed after its full 10 second
wait with `completed == false` while other runs of the same test passed
in under a second.

## Breaking changes

**None.**

- `TransitioningContentControl.OnTransitionCompleted` becomes `internal`
(was `private`) so the tests can signal completion, matching the other
internal members the tests already use.

## How this was verified

**The test class and the whole WPF test project were run repeatedly on
real Windows across net8, net9 and net10 with no failures; the
regression test still fails with the once-per-transition guard
removed.**

## Notes for the reviewer

**The control's logic is unchanged; the change is in how the tests drive
completion.**

- No test in `ReactiveUI.Wpf.Tests` waits on an animation clock any
more.
- Trade-off: no test now proves that the control subscribes its handler
to the storyboard's `Completed` event, since that needs WPF to tick the
clock.

## Checklist
- [x] I have read the [Contribute
guide](https://www.reactiveui.net/contribute/index.html)
- [x] The PR title follows [Conventional
Commits](https://www.conventionalcommits.org/)
- [x] Tests cover this change, or the summary says why they do not
- [x] New or changed public API has XML documentation

Author: glennawatson

src/ReactiveUI.Wpf.Shared/TransitioningContentControl.cs

@@ -665,6 +665,29 @@ internal void SetTransitionDefaultValues()
         }
     }
 
+    /// Handles the completion of a transition and raises the TransitionCompleted event.
+    /// The source of the event. This is typically the object that initiated the transition.
+    /// An EventArgs object that contains the event data.
+    /// Internal so tests can drive completion without depending on WPF's animation clock ticking.
+    internal void OnTransitionCompleted(object? sender, EventArgs e)
+    {
+        // Returning to Normal from inside this handler makes WPF raise Completed a second time for the same clock.
+        // Only the first one ends the transition.
+        if (sender is Clock clock)
+        {
+            if (ReferenceEquals(clock, _completedClock))
+            {
+                return;
+            }
+
+            _completedClock = clock;
+        }
+
+        AbortTransition();
+
+        TransitionCompleted?.Invoke(this, new());
+    }
+
     /// Called when the value of the  property changes.
     /// The previous content value.
     /// The new content value.
@@ -701,28 +724,6 @@ private void AbortTransition()
         PreviousImageSite.UpdateLayout();
     }
 
-    /// Handles the completion of a transition and raises the TransitionCompleted event.
-    /// The source of the event. This is typically the object that initiated the transition.
-    /// An EventArgs object that contains the event data.
-    private void OnTransitionCompleted(object? sender, EventArgs e)
-    {
-        // Returning to Normal from inside this handler makes WPF raise Completed a second time for the same clock.
-        // Only the first one ends the transition.
-        if (sender is Clock clock)
-        {
-            if (ReferenceEquals(clock, _completedClock))
-            {
-                return;
-            }
-
-            _completedClock = clock;
-        }
-
-        AbortTransition();
-
-        TransitionCompleted?.Invoke(this, new());
-    }
-
     /// Raises the TransitionStarted event to signal that a transition has begun.
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private void RaiseTransitionStarted() => TransitionStarted?.Invoke(this, new());

src/tests/ReactiveUI.Wpf.Tests/Wpf/TransitioningContentControlTest.cs

@@ -66,18 +66,9 @@ public class TransitioningContentControlTest
     /// An out-of-range value used to exercise the default arms of the transition switch expressions.
     private const int InvalidEnumValue = 999;
 
-    /// The longest time, in seconds, to pump the dispatcher while waiting for a storyboard to complete.
-    private const int StoryboardTimeoutSeconds = 10;
-
-    /// The delay, in milliseconds, between dispatcher pump iterations.
-    private const int PumpDelayMs = 10;
-
     /// The duration, in milliseconds, of the transition driven through the visual state manager.
     private const int TransitionDurationMs = 50;
 
-    /// How long, in milliseconds, to keep pumping after a transition completes to catch a repeated event.
-    private const int SettleTimeMs = 300;
-
     /// The label recorded when TransitionStarted fires.
     private const string StartedEvent = "started";
 
@@ -960,10 +951,15 @@ public async Task OnContentChanged_WithoutTemplate_DoesNotThrow()
     }
 
     /// 
-    /// When the completing storyboard runs to completion, the control aborts the transition (returns to Normal, clears
-    /// the previous-image snapshot) and raises TransitionCompleted.
+    /// When the completing storyboard's clock reports completion, the control aborts the transition (returns to Normal,
+    /// clears the previous-image snapshot) and raises TransitionCompleted.
     /// 
     /// A  representing the asynchronous operation.
+    /// 
+    /// The test raises the completion itself rather than running the storyboard. A running storyboard only completes
+    /// when WPF's per-thread render loop ticks its clock, and that loop depends on the composition engine answering;
+    /// on CI runners it sometimes never ticks, which made a pumped wait fail after its full deadline.
+    /// 
     [Test]
     public async Task CompletingTransition_Completes_AbortsTransitionAndRaisesCompleted()
     {
@@ -973,48 +969,33 @@ public async Task CompletingTransition_Completes_AbortsTransitionAndRaisesComple
         // Seed a previous-image snapshot so AbortTransition exercises its render-target clearing branch.
         control.PrepareTransitionImages(new TextBlock { Text = "snapshot" });
 
-        // A real, zero-duration storyboard targeting an existing element so it actually completes and fires Completed.
         // Two children are required because the Fade defaults read Children[0] and Children[1].
         var storyboard = new Storyboard();
-        var opacityAnimation = new DoubleAnimation(1.0, 1.0, new Duration(TimeSpan.Zero));
-        Storyboard.SetTarget(opacityAnimation, control);
-        Storyboard.SetTargetProperty(opacityAnimation, new(UIElement.OpacityProperty));
-        storyboard.Children.Add(opacityAnimation);
-
-        var secondAnimation = new DoubleAnimation(1.0, 1.0, new Duration(TimeSpan.Zero));
-        Storyboard.SetTarget(secondAnimation, control);
-        Storyboard.SetTargetProperty(secondAnimation, new(UIElement.OpacityProperty));
-        storyboard.Children.Add(secondAnimation);
+        storyboard.Children.Add(CreateOpacityAnimation(control));
+        storyboard.Children.Add(CreateOpacityAnimation(control));
 
         var completed = false;
         control.TransitionCompleted += (_, _) => completed = true;
 
-        // Assigning CompletingTransition hooks OnTransitionCompleted onto the storyboard's Completed event.
         control.CompletingTransition = storyboard;
 
-        storyboard.Begin(control, true);
-
-        // Pump the dispatcher so the zero-length animation completes and fires its Completed callback. A slow runner can
-        // need more than a fixed number of pumps, so keep pumping until it completes or the deadline passes.
-        var started = System.Diagnostics.Stopwatch.GetTimestamp();
-        while (!completed && System.Diagnostics.Stopwatch.GetElapsedTime(started) < TimeSpan.FromSeconds(StoryboardTimeoutSeconds))
-        {
-            Tests.Xaml.Utilities.DispatcherUtilities.DoEvents();
-            await Task.Delay(PumpDelayMs);
-        }
+        control.OnTransitionCompleted(storyboard.CreateClock(), EventArgs.Empty);
 
         await Assert.That(completed).IsTrue();
     }
 
     /// 
-    /// A content change that runs a real visual-state transition raises TransitionStarted once and
-    /// TransitionCompleted once. WPF raises the storyboard's Completed event a second time for the same
-    /// clock when the handler moves the control back to the Normal state, and that repeat must not surface as a
-    /// second TransitionCompleted.
+    /// A transition raises TransitionStarted once and TransitionCompleted once, even though WPF raises the
+    /// storyboard's Completed event a second time for the same clock when the handler moves the control back to
+    /// the Normal state. The next transition runs on a new clock and completes again.
     /// 
     /// A  representing the asynchronous operation.
+    /// 
+    /// The test raises the clock's completion itself, twice for the same clock as WPF does, rather than waiting for
+    /// WPF's render loop to tick the storyboard; see .
+    /// 
     [Test]
-    public async Task OnContentChanged_RealTransition_RaisesTransitionCompletedOnce()
+    public async Task OnTransitionCompleted_RepeatedForSameClock_RaisesTransitionCompletedOnce()
     {
         var control = CreateRealizedControl();
         control.Transition = TransitioningContentControl.TransitionType.Fade;
@@ -1026,23 +1007,14 @@ public async Task OnContentChanged_RealTransition_RaisesTransitionCompletedOnce(
         control.TransitionCompleted += (_, _) => events.Add(CompletedEvent);
 
         control.Content = new TextBlock { Text = NewContentText };
+        var firstClock = control.CompletingTransition!.CreateClock();
+        control.OnTransitionCompleted(firstClock, EventArgs.Empty);
+        control.OnTransitionCompleted(firstClock, EventArgs.Empty);
 
-        // Pump until the transition completes, then keep pumping so a repeated Completed has time to arrive.
-        var started = System.Diagnostics.Stopwatch.GetTimestamp();
-        while (!events.Contains(CompletedEvent) && System.Diagnostics.Stopwatch.GetElapsedTime(started) < TimeSpan.FromSeconds(StoryboardTimeoutSeconds))
-        {
-            Tests.Xaml.Utilities.DispatcherUtilities.DoEvents();
-            await Task.Delay(PumpDelayMs);
-        }
-
-        var settled = System.Diagnostics.Stopwatch.GetTimestamp();
-        while (System.Diagnostics.Stopwatch.GetElapsedTime(settled) < TimeSpan.FromMilliseconds(SettleTimeMs))
-        {
-            Tests.Xaml.Utilities.DispatcherUtilities.DoEvents();
-            await Task.Delay(PumpDelayMs);
-        }
+        control.Content = new TextBlock { Text = "second" };
+        control.OnTransitionCompleted(control.CompletingTransition!.CreateClock(), EventArgs.Empty);
 
-        await Assert.That(events).IsEquivalentTo([StartedEvent, CompletedEvent]);
+        await Assert.That(events).IsEquivalentTo([StartedEvent, CompletedEvent, StartedEvent, CompletedEvent]);
     }
 
     ///