refactor: convert synchronous methods to asynchronous and improve tim…

…eout handling

Directory.Packages.props

@@ -11,7 +11,7 @@
     <PackageVersion Include="BenchmarkDotNet.Annotations" Version="0.15.2" />
     <PackageVersion Include="coverlet.collector" Version="6.0.4" />
     <PackageVersion Include="CliWrap" Version="3.9.0" />
-    <PackageVersion Include="EnumerableAsyncProcessor" Version="3.6.0" />
+    <PackageVersion Include="EnumerableAsyncProcessor" Version="3.6.2" />
     <PackageVersion Include="FluentValidation.DependencyInjectionExtensions" Version="12.0.0" />
     <PackageVersion Include="FSharp.Core" Version="9.0.303" />
     <PackageVersion Include="Humanizer" Version="2.14.1" />

TUnit.Core/Attributes/TestData/MethodDataSourceAttribute.cs

@@ -1,5 +1,6 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 using TUnit.Core.Enums;
 using TUnit.Core.Helpers;
 
@@ -176,11 +177,11 @@ private static bool IsAsyncEnumerable([DynamicallyAccessedMembers(DynamicallyAcc
     }
 
     [UnconditionalSuppressMessage("AOT", "IL2075:UnrecognizedReflectionPattern", Justification = "Data source methods may use dynamic patterns")]
-    private static async IAsyncEnumerable<object?> ConvertToAsyncEnumerable(object asyncEnumerable)
+    private static async IAsyncEnumerable<object?> ConvertToAsyncEnumerable(object asyncEnumerable, [EnumeratorCancellation] CancellationToken cancellationToken = default)
     {
         var type = asyncEnumerable.GetType();
         var enumeratorMethod = type.GetMethod("GetAsyncEnumerator");
-        var enumerator = enumeratorMethod!.Invoke(asyncEnumerable, [CancellationToken.None]);
+        var enumerator = enumeratorMethod!.Invoke(asyncEnumerable, [cancellationToken]);
 
         var moveNextMethod = enumerator!.GetType().GetMethod("MoveNextAsync");
         var currentProperty = enumerator.GetType().GetProperty("Current");

TUnit.Core/EngineCancellationToken.cs

@@ -14,6 +14,9 @@ public class EngineCancellationToken : IDisposable
     /// Gets the cancellation token.
     /// </summary>
     public CancellationToken Token { get; private set; }
+
+    private CancellationTokenSource? _forcefulExitCts;
+    private volatile bool _forcefulExitStarted;
 
     /// <summary>
     /// Initializes the cancellation token with a linked token source.
@@ -24,26 +27,50 @@ internal void Initialise(CancellationToken cancellationToken)
         CancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
         Token = CancellationTokenSource.Token;
 
-        Console.CancelKeyPress += (sender, e) =>
+        Console.CancelKeyPress += OnCancelKeyPress;
+    }
+
+    private void OnCancelKeyPress(object? sender, ConsoleCancelEventArgs e)
+    {
+        // Cancel the test execution
+        if (!CancellationTokenSource.IsCancellationRequested)
         {
-            if (!CancellationTokenSource.IsCancellationRequested)
-            {
-                CancellationTokenSource.Cancel();
-            }
+            CancellationTokenSource.Cancel();
+        }
 
-            _ = Task.Delay(TimeSpan.FromSeconds(10)).ContinueWith(_ =>
+        // Only start the forceful exit timer once
+        if (!_forcefulExitStarted)
+        {
+            _forcefulExitStarted = true;
+
+            // Cancel any previous forceful exit timer
+            _forcefulExitCts?.Cancel();
+            _forcefulExitCts?.Dispose();
+            _forcefulExitCts = new CancellationTokenSource();
+
+            // Start a new forceful exit timer
+            _ = Task.Delay(TimeSpan.FromSeconds(10), _forcefulExitCts.Token).ContinueWith(t =>
             {
-                Console.WriteLine("Forcefully terminating the process due to cancellation request.");
-                Environment.Exit(1);
-            });
-        };
+                if (!t.IsCanceled)
+                {
+                    Console.WriteLine("Forcefully terminating the process due to cancellation request.");
+                    Environment.Exit(1);
+                }
+            }, TaskScheduler.Default);
+        }
+
+        // Prevent the default behavior (immediate termination)
+        e.Cancel = true;
     }
 
     /// <summary>
     /// Disposes the cancellation token source.
     /// </summary>
     public void Dispose()
     {
+        Console.CancelKeyPress -= OnCancelKeyPress;
+        _forcefulExitCts?.Cancel();
+        _forcefulExitCts?.Dispose();
         CancellationTokenSource.Dispose();
     }
 }

TUnit.Core/Executors/DedicatedThreadExecutor.cs

@@ -285,8 +285,8 @@ public override void Send(SendOrPostCallback d, object? state)
             else
             {
                 // For Send, we need to block until completion
-                // This is less ideal but necessary for the Send semantics
-                var tcs = new TaskCompletionSource<object?>();
+                // Use Task.Run to avoid potential deadlocks by ensuring we don't capture any synchronization context
+                var tcs = new TaskCompletionSource<object?>(TaskCreationOptions.RunContinuationsAsynchronously);
 
                 Post(_ =>
                 {
@@ -301,7 +301,13 @@ public override void Send(SendOrPostCallback d, object? state)
                     }
                 }, null);
 
-                // Wait for completion (this will block)
+                // Wait with a timeout to prevent infinite hangs
+                if (!tcs.Task.Wait(TimeSpan.FromMinutes(30)))
+                {
+                    throw new TimeoutException("Synchronous operation on dedicated thread timed out after 30 minutes");
+                }
+
+                // Re-throw any exception that occurred
                 tcs.Task.GetAwaiter().GetResult();
             }
         }

TUnit.Core/Helpers/DataSourceHelpers.cs

@@ -411,20 +411,32 @@ public static bool IsTuple(object? obj)
     /// Tries to create an instance using a generated creation method that handles init-only properties.
     /// Returns true if successful, false if no creator is available.
     /// </summary>
-    public static bool TryCreateWithInitializer(Type type, MethodMetadata testInformation, string testSessionId, out object createdInstance)
+    public static async Task<(bool success, object? createdInstance)> TryCreateWithInitializerAsync(Type type, MethodMetadata testInformation, string testSessionId)
     {
-        createdInstance = null!;
-
         // Check if we have a registered creator for this type
         if (!TypeCreators.TryGetValue(type, out var creator))
         {
-            return false;
+            return (false, null);
         }
 
         // Use the creator to create and initialize the instance
-        var task = creator(testInformation, testSessionId);
-        createdInstance = task.ConfigureAwait(false).GetAwaiter().GetResult();
-        return true;
+        var createdInstance = await creator(testInformation, testSessionId).ConfigureAwait(false);
+        return (true, createdInstance);
+    }
+
+    /// <summary>
+    /// Tries to create an instance using a generated creation method that handles init-only properties.
+    /// Returns true if successful, false if no creator is available.
+    /// This method is kept for backward compatibility but should be avoided in favor of TryCreateWithInitializerAsync.
+    /// </summary>
+    [Obsolete("Use TryCreateWithInitializerAsync instead to avoid potential deadlocks")]
+    public static bool TryCreateWithInitializer(Type type, MethodMetadata testInformation, string testSessionId, out object createdInstance)
+    {
+        // Use Task.Run to avoid potential deadlocks by running on thread pool
+        var task = Task.Run(async () => await TryCreateWithInitializerAsync(type, testInformation, testSessionId).ConfigureAwait(false));
+        var result = task.GetAwaiter().GetResult();
+        createdInstance = result.createdInstance!;
+        return result.success;
     }
 
     private static readonly Dictionary<Type, Func<MethodMetadata, string, Task<object>>> TypeCreators = new();

TUnit.Engine/Building/TestBuilder.cs

@@ -624,8 +624,9 @@ private ValueTask<TestContext> CreateTestContextAsync(string testId, TestMetadat
             MethodMetadata = metadata.MethodMetadata,
             Attributes = attributes,
             MethodGenericArguments = testData.ResolvedMethodGenericArguments,
-            ClassGenericArguments = testData.ResolvedClassGenericArguments
-            // Don't set Timeout and RetryLimit here - let discovery event receivers set them
+            ClassGenericArguments = testData.ResolvedClassGenericArguments,
+            Timeout = TimeSpan.FromMinutes(30) // Default 30-minute timeout (can be overridden by TimeoutAttribute)
+            // Don't set RetryLimit here - let discovery event receivers set it
         };
 
         var context = _contextProvider.CreateTestContext(
@@ -691,6 +692,7 @@ private static TestDetails CreateFailedTestDetails(TestMetadata metadata, string
             ReturnType = typeof(Task),
             MethodMetadata = metadata.MethodMetadata,
             Attributes = metadata.AttributeFactory.Invoke(),
+            Timeout = TimeSpan.FromMinutes(30) // Default 30-minute timeout (can be overridden by TimeoutAttribute)
         };
     }
 

TUnit.Engine/Building/TestBuilderPipeline.cs

@@ -149,8 +149,9 @@ private async Task<AbstractExecutableTest[]> GenerateDynamicTests(TestMetadata m
                 TestLineNumber = metadata.LineNumber ?? 0,
                 ReturnType = typeof(Task),
                 MethodMetadata = metadata.MethodMetadata,
-                Attributes = attributes
-                // Don't set Timeout and RetryLimit here - let discovery event receivers set them
+                Attributes = attributes,
+                Timeout = TimeSpan.FromMinutes(30) // Default 30-minute timeout (can be overridden by TimeoutAttribute)
+                // Don't set RetryLimit here - let discovery event receivers set it
             };
 
             var context = _contextProvider.CreateTestContext(
@@ -265,7 +266,8 @@ private async IAsyncEnumerable<AbstractExecutableTest> BuildTestsFromSingleMetad
                         TestLineNumber = resolvedMetadata.LineNumber ?? 0,
                         ReturnType = typeof(Task),
                         MethodMetadata = resolvedMetadata.MethodMetadata,
-                        Attributes = attributes
+                        Attributes = attributes,
+                        Timeout = TimeSpan.FromMinutes(30) // Default 30-minute timeout (can be overridden by TimeoutAttribute)
                         // Don't set Timeout and RetryLimit here - let discovery event receivers set them
                     };
 
@@ -339,6 +341,7 @@ private AbstractExecutableTest CreateFailedTestForDataGenerationError(TestMetada
             ReturnType = typeof(Task),
             MethodMetadata = metadata.MethodMetadata,
             Attributes = [],
+            Timeout = TimeSpan.FromMinutes(30) // Default 30-minute timeout
         };
 
         var context = _contextProvider.CreateTestContext(
@@ -393,6 +396,7 @@ private AbstractExecutableTest CreateFailedTestForGenericResolutionError(TestMet
             ReturnType = typeof(Task),
             MethodMetadata = metadata.MethodMetadata,
             Attributes = [],
+            Timeout = TimeSpan.FromMinutes(30) // Default 30-minute timeout
         };
 
         var context = _contextProvider.CreateTestContext(

TUnit.Engine/Discovery/ReflectionTestDataCollector.cs

@@ -46,60 +46,48 @@ public async Task<IEnumerable<TestMetadata>> CollectTestsAsync(string testSessio
 
         Console.WriteLine($"Scanning {assemblies.Count} assemblies for tests...");
 
-        // Use indexed collection to maintain order
-        var resultsByIndex = new ConcurrentDictionary<int, List<TestMetadata>>();
-
-        // Use true parallel processing with thread pool threads
-        var parallelOptions = new ParallelOptions
-        {
-            MaxDegreeOfParallelism = Environment.ProcessorCount
-        };
-
-        Parallel.ForEach(assemblies.Select((assembly, index) => new
-        {
-            assembly, index
-        }), parallelOptions, item =>
+        // Use async parallel processing with proper task-based approach
+        var tasks = new Task<List<TestMetadata>>[assemblies.Count];
+
+        for (var i = 0; i < assemblies.Count; i++)
         {
-            var assembly = item.assembly;
-            var index = item.index;
-
-            lock (_lock)
+            var assembly = assemblies[i];
+            var index = i;
+            
+            tasks[index] = Task.Run(async () =>
             {
-                if (!_scannedAssemblies.Add(assembly))
+                lock (_lock)
                 {
-                    resultsByIndex[index] =
-                    [
-                    ];
-                    return;
+                    if (!_scannedAssemblies.Add(assembly))
+                    {
+                        return new List<TestMetadata>();
+                    }
                 }
-            }
 
-            try
-            {
-                Console.WriteLine($"Scanning assembly: {assembly.GetName().Name}");
-                // Run async method synchronously since we're in parallel processing context
-                var testsInAssembly = DiscoverTestsInAssembly(assembly).ConfigureAwait(false).GetAwaiter().GetResult();
-                resultsByIndex[index] = testsInAssembly;
-            }
-            catch (Exception ex)
-            {
-                // Create a failed test metadata for the assembly that couldn't be scanned
-                var failedTest = CreateFailedTestMetadataForAssembly(assembly, ex);
-                resultsByIndex[index] =
-                [
-                    failedTest
-                ];
-            }
-        });
+                try
+                {
+                    Console.WriteLine($"Scanning assembly: {assembly.GetName().Name}");
+                    // Now we can properly await the async method
+                    var testsInAssembly = await DiscoverTestsInAssembly(assembly).ConfigureAwait(false);
+                    return testsInAssembly;
+                }
+                catch (Exception ex)
+                {
+                    // Create a failed test metadata for the assembly that couldn't be scanned
+                    var failedTest = CreateFailedTestMetadataForAssembly(assembly, ex);
+                    return new List<TestMetadata> { failedTest };
+                }
+            });
+        }
+
+        // Wait for all tasks to complete
+        var results = await Task.WhenAll(tasks).ConfigureAwait(false);
 
         // Reassemble results in original order
         var newTests = new List<TestMetadata>();
-        for (var i = 0; i < assemblies.Count; i++)
+        foreach (var tests in results)
         {
-            if (resultsByIndex.TryGetValue(i, out var tests))
-            {
-                newTests.AddRange(tests);
-            }
+            newTests.AddRange(tests);
         }
 
         // Discover dynamic tests from DynamicTestBuilderAttribute methods

TUnit.Engine/Events/EventBatcher.cs

@@ -162,12 +162,18 @@ public async ValueTask DisposeAsync()
 
         try
         {
-            // Properly await the task instead of blocking
+            // Properly await the task with timeout
 #if NET6_0_OR_GREATER
             await _processingTask.WaitAsync(TimeSpan.FromSeconds(5), CancellationToken.None);
 #else
+            // For .NET Framework, use Task.WhenAny to implement timeout
             using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
-            await _processingTask.ConfigureAwait(false);
+            var completedTask = await Task.WhenAny(_processingTask, Task.Delay(Timeout.Infinite, cts.Token)).ConfigureAwait(false);
+            if (completedTask == _processingTask)
+            {
+                await _processingTask.ConfigureAwait(false);
+            }
+            // If timeout occurred, we just continue without waiting
 #endif
         }
         catch

TUnit.Engine/Services/SingleTestExecutor.cs

@@ -446,19 +446,18 @@ private Func<ValueTask> CreateTimeoutTestAction(AbstractExecutableTest test, obj
         return async () =>
         {
             using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-            cts.CancelAfter((int)test.Context.TestDetails.Timeout!.Value.TotalMilliseconds);
+            var timeoutMs = (int)test.Context.TestDetails.Timeout!.Value.TotalMilliseconds;
+            cts.CancelAfter(timeoutMs);
 
-            var testTask = test.InvokeTestAsync(instance, cts.Token);
-            var timeoutTask = Task.Delay((int)test.Context.TestDetails.Timeout!.Value.TotalMilliseconds, cancellationToken);
-            var completedTask = await Task.WhenAny(testTask, timeoutTask);
-
-            if (completedTask == timeoutTask)
+            try
             {
-                cts.Cancel();
-                throw new OperationCanceledException($"Test '{test.Context.GetDisplayName()}' exceeded timeout of {(int)test.Context.TestDetails.Timeout!.Value.TotalMilliseconds}ms");
+                await test.InvokeTestAsync(instance, cts.Token);
+            }
+            catch (OperationCanceledException) when (cts.IsCancellationRequested && !cancellationToken.IsCancellationRequested)
+            {
+                // This was our timeout, not an external cancellation
+                throw new System.TimeoutException($"Test '{test.Context.GetDisplayName()}' exceeded timeout of {timeoutMs}ms");
             }
-
-            await testTask;
         };
     }