Make the tests more stable

Author: sakno

src/DotNext.Tests/Runtime/CompilerServices/SpawningAsyncTaskMethodBuilderTests.cs

@@ -8,16 +8,13 @@ public sealed class SpawningAsyncTaskMethodBuilderTests : Test
     [Fact]
     public static async Task ForkAsyncMethodWithResult()
     {
-        using var resetEvent = new ManualResetEventSlim(initialState: false);
-        var task = Sum(40, 2, Thread.CurrentThread.ManagedThreadId);
-        True(resetEvent.Wait(DefaultTimeout));
+        var task = Fork(static () => Sum(40, 2, Thread.CurrentThread.ManagedThreadId));
 
         Equal(42, await task);
 
         [AsyncMethodBuilder(typeof(SpawningAsyncTaskMethodBuilder<>))]
-        async Task<int> Sum(int x, int y, int callerThreadId)
+        static async Task<int> Sum(int x, int y, int callerThreadId)
         {
-            resetEvent.Set();
             NotEqual(callerThreadId, Thread.CurrentThread.ManagedThreadId);
 
             await Task.CompletedTask;
@@ -26,18 +23,13 @@ async Task<int> Sum(int x, int y, int callerThreadId)
     }
 
     [Fact]
-    public static async Task ForkAsyncMethodWithoutResult()
+    public static Task ForkAsyncMethodWithoutResult()
     {
-        using var resetEvent = new ManualResetEventSlim(initialState: false);
-        var task = CheckThreadId(Thread.CurrentThread.ManagedThreadId);
-        True(resetEvent.Wait(DefaultTimeout));
-
-        await task;
+        return Fork(static () => CheckThreadId(Thread.CurrentThread.ManagedThreadId));
 
         [AsyncMethodBuilder(typeof(SpawningAsyncTaskMethodBuilder))]
-        async Task CheckThreadId(int callerThreadId)
+        static async Task CheckThreadId(int callerThreadId)
         {
-            resetEvent.Set();
             NotEqual(callerThreadId, Thread.CurrentThread.ManagedThreadId);
 
             await Task.CompletedTask;
@@ -47,17 +39,14 @@ async Task CheckThreadId(int callerThreadId)
     [Fact]
     public static async Task CancellationOfSpawnedMethod()
     {
-        using var resetEvent = new ManualResetEventSlim(initialState: false);
-        var task = CheckThreadId(Thread.CurrentThread.ManagedThreadId, new(true));
-        True(resetEvent.Wait(DefaultTimeout));
+        var task = Fork(static () => CheckThreadId(Thread.CurrentThread.ManagedThreadId, new(true)));
 
         await task.ConfigureAwait(ConfigureAwaitOptions.ContinueOnCapturedContext | ConfigureAwaitOptions.SuppressThrowing);
         True(task.IsCanceled);
 
         [AsyncMethodBuilder(typeof(SpawningAsyncTaskMethodBuilder))]
-        async Task CheckThreadId(int callerThreadId, CancellationToken token)
+        static async Task CheckThreadId(int callerThreadId, CancellationToken token)
         {
-            resetEvent.Set();
             NotEqual(callerThreadId, Thread.CurrentThread.ManagedThreadId);
 
             await Task.Delay(DefaultTimeout, token);

src/DotNext.Tests/Test.cs

@@ -1,5 +1,6 @@
 using System.Buffers;
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 
 [assembly: DotNext.ReportLongRunningTests(30_000)]
 
@@ -46,17 +47,31 @@ private protected static Action<T> Same<T>(T expected)
         where T : class
         => actual => Same(expected, actual);
 
-    protected static TResult SuspendContext<TResult>(Func<TResult> func)
+    protected static TResult Fork<TResult>(Func<TResult> func, [CallerMemberName] string threadName = "")
     {
-        var currentContext = SynchronizationContext.Current;
-        SynchronizationContext.SetSynchronizationContext(null);
-        try
+        var state = new State<TResult>(func);
+
+        var thread = new Thread(Start)
         {
-            return func();
-        }
-        finally
+            IsBackground = true,
+            Name = threadName,
+        };
+        
+        thread.UnsafeStart(state);
+        True(thread.Join(DefaultTimeout));
+        return state.Result;
+
+        static void Start(object state)
         {
-            SynchronizationContext.SetSynchronizationContext(currentContext);
+            var tuple = (State<TResult>)state;
+            tuple.Invoke();
         }
     }
+    
+    private sealed class State<T>(Func<T> func)
+    {
+        internal T Result;
+
+        internal void Invoke() => Result = func();
+    }
 }

src/DotNext.Tests/Threading/Leases/LeaseTests.cs

@@ -125,20 +125,15 @@ public static async Task AcquireUsingConsumer()
     }
 
     [Fact]
-    public static Task WorkerProtectedWithLease()
+    public static async Task WorkerProtectedWithLease()
     {
-        return SuspendContext(TestBody);
-
-        static async Task TestBody()
-        {
-            var pause = TimeSpan.FromMilliseconds(500);
-            using var provider = new TestLeaseProvider(pause);
-            await using var consumer = new TestLeaseConsumer(provider);
-            True(await consumer.TryAcquireAsync());
+        var pause = TimeSpan.FromMilliseconds(500);
+        using var provider = new TestLeaseProvider(pause);
+        await using var consumer = new TestLeaseConsumer(provider);
+        True(await consumer.TryAcquireAsync());
 
-            var result = await consumer.ExecuteAsync(Worker);
-            Equal(42, result);
-        }
+        var result = await Fork(() => consumer.ExecuteAsync(Worker));
+        Equal(42, result);
 
         static async Task<int> Worker(CancellationToken token)
         {