test: observe landblock worker joins

tests/AcDream.App.Tests/Streaming/LandblockStreamerPoolTests.cs

@@ -377,7 +377,7 @@ public sealed class LandblockStreamerPoolTests
     }
 
     [Fact]
-    public async Task Dispose_JoinsEveryWorkerInThePool()
+    public void Dispose_JoinsEveryWorkerInThePool()
     {
         const int workerCount = 3;
         using var release = new ManualResetEventSlim();
@@ -408,13 +408,31 @@ public sealed class LandblockStreamerPoolTests
             Assert.True(entered.Wait(TimeSpan.FromSeconds(5)));
             Assert.Equal(workerCount, loaderThreads.Count);
 
-            Task dispose = Task.Run(streamer.Dispose);
-            await Task.Delay(100);
-            // Dispose must be blocked on the still-building workers.
-            Assert.False(dispose.IsCompleted);
+            Exception? disposeError = null;
+            var disposeThread = new Thread(() =>
+            {
+                try
+                {
+                    streamer.Dispose();
+                }
+                catch (Exception error)
+                {
+                    disposeError = error;
+                }
+            })
+            {
+                IsBackground = true,
+                Name = "LandblockStreamer pool dispose contract",
+            };
+            disposeThread.Start();
+            Assert.True(SpinWait.SpinUntil(
+                () => (disposeThread.ThreadState & ThreadState.WaitSleepJoin) != 0,
+                TimeSpan.FromSeconds(5)),
+                "dispose never waited for the still-building workers");
 
             release.Set();
-            await dispose.WaitAsync(TimeSpan.FromSeconds(5));
+            Assert.True(disposeThread.Join(TimeSpan.FromSeconds(5)));
+            Assert.Null(disposeError);
 
             Assert.Throws<ObjectDisposedException>(
                 () => streamer.EnqueueLoad(0x1234FFFFu, LandblockStreamJobKind.LoadFar));

tests/AcDream.Core.Tests/Streaming/LandblockStreamerTests.cs

@@ -342,7 +342,7 @@ public class LandblockStreamerTests
     }
 
     [Fact]
-    public async Task DisposeAndConcurrentDisposeWaitForInFlightLoad()
+    public void DisposeAndConcurrentDisposeWaitForInFlightLoad()
     {
         using var entered = new ManualResetEventSlim();
         using var release = new ManualResetEventSlim();
@@ -359,14 +359,55 @@ public class LandblockStreamerTests
             streamer.EnqueueLoad(0x12340000u);
             Assert.True(entered.Wait(TimeSpan.FromSeconds(2)));
 
-            Task firstDispose = Task.Run(streamer.Dispose);
-            Task secondDispose = Task.Run(streamer.Dispose);
-            await Task.Delay(50);
-            Assert.False(firstDispose.IsCompleted);
-            Assert.False(secondDispose.IsCompleted);
+            Exception? firstError = null;
+            var firstDisposeThread = new Thread(() =>
+            {
+                try
+                {
+                    streamer.Dispose();
+                }
+                catch (Exception error)
+                {
+                    firstError = error;
+                }
+            })
+            {
+                IsBackground = true,
+                Name = "LandblockStreamer primary dispose contract",
+            };
+            firstDisposeThread.Start();
+            Assert.True(SpinWait.SpinUntil(
+                () => (firstDisposeThread.ThreadState & ThreadState.WaitSleepJoin) != 0,
+                TimeSpan.FromSeconds(2)),
+                "the primary dispose never waited for the in-flight load");
+
+            Exception? secondError = null;
+            var secondDisposeThread = new Thread(() =>
+            {
+                try
+                {
+                    streamer.Dispose();
+                }
+                catch (Exception error)
+                {
+                    secondError = error;
+                }
+            })
+            {
+                IsBackground = true,
+                Name = "LandblockStreamer concurrent dispose contract",
+            };
+            secondDisposeThread.Start();
+            Assert.True(SpinWait.SpinUntil(
+                () => (secondDisposeThread.ThreadState & ThreadState.WaitSleepJoin) != 0,
+                TimeSpan.FromSeconds(2)),
+                "the concurrent dispose never waited for primary disposal");
 
             release.Set();
-            await Task.WhenAll(firstDispose, secondDispose).WaitAsync(TimeSpan.FromSeconds(2));
+            Assert.True(firstDisposeThread.Join(TimeSpan.FromSeconds(2)));
+            Assert.True(secondDisposeThread.Join(TimeSpan.FromSeconds(2)));
+            Assert.Null(firstError);
+            Assert.Null(secondError);
         }
         finally
         {