test: stabilize four flakes surfaced by the CI Stress workflow (#193)

Run https://github.com/microsoft/microsoft-ui-reactor/actions/runs/25504721012
turned up 17 iteration failures across 200 iterations, concentrated
in six tests. This commit addresses all six.

Unit tests (timing budgets that were tight for a starved CI runner):
- UseResourceTests.Retry_Invokes_Fetcher_Multiple_Times_And_Settles_On_Success
  and Retry_Exhausted_Surfaces_Final_Error: bump the poll budget from
  5s to 30s. Retry uses a 100ms/200ms backoff and threadpool/timer
  callbacks for re-attempts; on a contended CI runner the third
  attempt routinely landed past the 5s ceiling, surfacing as either
  Expected:3 Actual:2 (third call hadn't fired) or
  Expected:Data Actual:Loading (state hadn't transitioned).
- LogCaptureBufferTests.WaitForNewAsync_RespectsTimeout: relax the
  upper bound on a 150ms wait from 2s to 30s. The lower bound is the
  meaningful check (timeout was honored); the upper bound is just a
  "didn't get stuck forever" sanity guard, and 2s was tight enough
  that a thread-pool stall could blow it (observed 3070ms on CI).
- AutoSuggestTests.WaitForState helper: bump WaitAsync from 5s to 30s.
  Same shape — debounce + worker continuation can land past 5s when
  the threadpool is starved; both Empty_State_On_No_Results and
  Error_State_On_Exception failed with TimeoutException at 10–12s.

Selftests (one real race, one too-strict bound, both with weak diagnostics):
- ThreadSafe_RapidBackgroundSetState: real bug. The 2-second
  CancellationTokenSource started ticking before Task.Run actually
  scheduled the four worker threads, so on a starved threadpool the
  budget could elapse before any worker hit the loop, leaving
  writeCount at 0 and the rendered counter never updating. Switch to
  Barrier(5) (4 workers + main) so the main thread waits for all
  workers to be inside the loop before calling cts.CancelAfter(2s).
  Also include writeCount and rendered in the Check messages so
  future regressions are diagnosable from the log.
- ThreadSafe_RenderCoalescing: relax the bound from renders<100 to
  renders<200, and include the actual count in the Check message.
  100 was too aggressive — under threadpool starvation the UI thread
  can sneak in renders between the background-thread setState calls,
  and the production coalescing logic is what we're probing, not the
  CI scheduler. 200 still detects "no coalescing at all" while
  tolerating realistic interleaving (full coalescing on a quiet
  machine produces ~2 renders).

All five formerly-flaky unit tests pass locally after the change.

Author: codemonkeychris

tests/Reactor.AppTests.Host/SelfTest/Fixtures/ThreadSafeHookFixtures.cs

@@ -46,10 +46,13 @@ public override async Task RunAsync()
             await Harness.Render();
             H.Check("RapidBG_InitialRender", H.FindText("Counter: 0") is not null);
 
-            // Hammer from 4 threads for 2 seconds
-            var cts = new CancellationTokenSource(TimeSpan.FromSeconds(2));
+            // Hammer from 4 threads for 2 seconds. Use Barrier(5) so the main
+            // thread waits for all workers to be inside the loop before starting
+            // the 2-second budget — otherwise a starved CI threadpool can let
+            // CancelAfter elapse before Task.Run actually schedules the workers.
             int writeCount = 0;
-            var barrier = new Barrier(4);
+            var barrier = new Barrier(5);
+            var cts = new CancellationTokenSource();
             var tasks = Enumerable.Range(0, 4).Select(t =>
                 Task.Run(() =>
                 {
@@ -63,6 +66,8 @@ public override async Task RunAsync()
                 })
             ).ToArray();
 
+            barrier.SignalAndWait();
+            cts.CancelAfter(TimeSpan.FromSeconds(2));
             await Task.WhenAll(tasks);
 
             // Let the render loop settle — low-priority enqueue means a few frames
@@ -71,14 +76,14 @@ public override async Task RunAsync()
             var final = lastWritten;
             var text = H.FindControl<TextBlock>(tb => tb.Text?.StartsWith("Counter:") == true);
             H.Check("RapidBG_TextPresent", text is not null);
-            H.Check("RapidBG_WritesHappened", writeCount > 100);
+            H.Check($"RapidBG_WritesHappened (writes={writeCount})", writeCount > 100);
 
             // The rendered value should be the last value set (or very close to it,
             // since a render might have been in flight when the last write landed)
             if (text is not null)
             {
                 var rendered = int.Parse(text.Text.Replace("Counter: ", ""));
-                H.Check("RapidBG_FinalValueReasonable",
+                H.Check($"RapidBG_FinalValueReasonable (rendered={rendered}, writes={writeCount})",
                     rendered > 0 && rendered <= writeCount);
             }
         }
@@ -292,13 +297,17 @@ await Task.Run(() =>
 
             H.Check("Coalesce_FinalValue", H.FindText("Value: 1000") is not null);
 
-            // Render count should be far less than 1000 due to coalescing
+            // Render count should be far less than 1000 due to coalescing.
+            // Threshold is loose (1/5 of writes) to tolerate scheduler interleaving
+            // on CI runners where the UI thread can sneak in renders between
+            // background-thread setState calls; full coalescing on a quiet machine
+            // produces ~2 renders.
             var renderText = H.FindControl<TextBlock>(tb =>
                 tb.Text?.StartsWith("Renders:") == true);
             if (renderText is not null)
             {
                 var renders = int.Parse(renderText.Text.Replace("Renders: ", ""));
-                H.Check("Coalesce_FarFewerRenders", renders < 100);
+                H.Check($"Coalesce_FarFewerRenders (renders={renders})", renders < 200);
             }
         }
     }

tests/Reactor.Tests/AutoSuggestTests.cs

@@ -21,7 +21,10 @@ private static Task WaitForState<T>(SearchManager<T> manager, SearchState target
         // Check after subscribing to avoid TOCTOU race
         if (manager.State == target)
             tcs.TrySetResult();
-        return tcs.Task.WaitAsync(TimeSpan.FromSeconds(5));
+        // Generous budget: under thread-pool starvation on a contended CI runner
+        // a 5s ceiling races debounce+continuation scheduling. 30s still surfaces
+        // a genuine "state never reached" bug with a clear TimeoutException.
+        return tcs.Task.WaitAsync(TimeSpan.FromSeconds(30));
     }
     // ════════════════════════════════════════════════════════════════
     //  Element creation

tests/Reactor.Tests/Core/UseResourceTests.cs

@@ -291,7 +291,9 @@ public async Task Retry_Invokes_Fetcher_Multiple_Times_And_Settles_On_Success()
         // current hook state and does not re-invoke the fetcher.
         AsyncValue<int>? probe = null;
         var sw = global::System.Diagnostics.Stopwatch.StartNew();
-        while (sw.Elapsed < TimeSpan.FromSeconds(5))
+        // Budget covers retry backoff (100ms + 200ms = 300ms minimum) plus
+        // threadpool/timer scheduling slack on a loaded CI runner.
+        while (sw.Elapsed < TimeSpan.FromSeconds(30))
         {
             ctx.BeginRender(() => { });
             probe = ctx.UseResource(fetcher, cache, Array.Empty<object>(),
@@ -324,10 +326,11 @@ public async Task Retry_Exhausted_Surfaces_Final_Error()
             new ResourceOptions(RetryCount: 2), dispatcher);
         ctx.FlushEffects();
 
-        // Poll the rendered state, not the call counter.
+        // Poll the rendered state, not the call counter. Budget covers retry
+        // backoff plus threadpool/timer scheduling slack on a loaded CI runner.
         AsyncValue<int>? probe = null;
         var sw = global::System.Diagnostics.Stopwatch.StartNew();
-        while (sw.Elapsed < TimeSpan.FromSeconds(5))
+        while (sw.Elapsed < TimeSpan.FromSeconds(30))
         {
             ctx.BeginRender(() => { });
             probe = ctx.UseResource(fetcher, cache, Array.Empty<object>(),

tests/Reactor.Tests/Devtools/LogCaptureBufferTests.cs

@@ -132,7 +132,9 @@ public async Task WaitForNewAsync_RespectsTimeout()
         await buf.WaitForNewAsync(1, 150);
         sw.Stop();
         Assert.True(sw.ElapsedMilliseconds >= 100, $"WaitForNewAsync returned after only {sw.ElapsedMilliseconds}ms (expected ≥ ~150ms)");
-        Assert.True(sw.ElapsedMilliseconds < 2_000, $"WaitForNewAsync blocked for {sw.ElapsedMilliseconds}ms");
+        // Upper bound is a "didn't get stuck forever" sanity check — generous so
+        // thread-pool starvation on a contended CI runner doesn't fail it.
+        Assert.True(sw.ElapsedMilliseconds < 30_000, $"WaitForNewAsync blocked for {sw.ElapsedMilliseconds}ms");
     }
 
     [Fact]