perf: convert synchronous TestStateManager methods to void

TUnit.Engine/Scheduling/TestRunner.cs

@@ -77,7 +77,7 @@ private async ValueTask ExecuteTestInternalAsync(AbstractExecutableTest test, Ca
 
                 if (dependency.Test.State == TestState.Failed && !dependency.ProceedOnFailure)
                 {
-                    await _testStateManager.MarkSkippedAsync(test, "Skipped due to failed dependencies").ConfigureAwait(false);
+                    _testStateManager.MarkSkipped(test, "Skipped due to failed dependencies");
                     await _tunitMessageBus.Skipped(test.Context, "Skipped due to failed dependencies").ConfigureAwait(false);
                     return;
                 }

TUnit.Engine/Scheduling/TestScheduler.cs

@@ -102,7 +102,7 @@ public async Task<bool> ScheduleAndExecuteAsync(
             {
                 if (testsInCircularDependencies.Add(chainTest))
                 {
-                    await _testStateManager.MarkCircularDependencyFailedAsync(chainTest, exception).ConfigureAwait(false);
+                    _testStateManager.MarkCircularDependencyFailed(chainTest, exception);
                     await _messageBus.Failed(chainTest.Context, exception, DateTimeOffset.UtcNow).ConfigureAwait(false);
                 }
             }

TUnit.Engine/Services/TestExecution/TestCoordinator.cs

@@ -60,8 +60,9 @@ private async ValueTask ExecuteTestInternalAsync(AbstractExecutableTest test, Ca
     {
         try
         {
-            await _stateManager.MarkRunningAsync(test).ConfigureAwait(false);
-            await _messageBus.InProgress(test.Context).ConfigureAwait(false);
+            _stateManager.MarkRunning(test);
+            // Fire-and-forget InProgress - it's informational and doesn't need to block test execution
+            _ = _messageBus.InProgress(test.Context);
 
             _contextRestorer.RestoreContext(test);
 
@@ -71,7 +72,7 @@ private async ValueTask ExecuteTestInternalAsync(AbstractExecutableTest test, Ca
             if (existingResult?.State == TestState.Failed)
             {
                 var exception = existingResult.Exception ?? new InvalidOperationException("Test failed during registration");
-                await _stateManager.MarkFailedAsync(test, exception).ConfigureAwait(false);
+                _stateManager.MarkFailed(test, exception);
                 await _eventReceiverOrchestrator.InvokeTestEndEventReceiversAsync(test.Context, cancellationToken).ConfigureAwait(false);
                 return;
             }
@@ -131,19 +132,19 @@ await TimeoutHelper.ExecuteWithTimeoutAsync(
                 }).ConfigureAwait(false);
             }
 
-            await _stateManager.MarkCompletedAsync(test).ConfigureAwait(false);
+            _stateManager.MarkCompleted(test);
 
         }
         catch (SkipTestException ex)
         {
             test.Context.SkipReason = ex.Message;
-            await _stateManager.MarkSkippedAsync(test, ex.Message).ConfigureAwait(false);
+            _stateManager.MarkSkipped(test, ex.Message);
 
             await _eventReceiverOrchestrator.InvokeTestSkippedEventReceiversAsync(test.Context, cancellationToken).ConfigureAwait(false);
         }
         catch (Exception ex)
         {
-            await _stateManager.MarkFailedAsync(test, ex).ConfigureAwait(false);
+            _stateManager.MarkFailed(test, ex);
         }
         finally
         {
@@ -211,7 +212,7 @@ await _eventReceiverOrchestrator.InvokeLastTestInSessionEventReceiversAsync(
                     ? cleanupExceptions[0]
                     : new AggregateException("One or more errors occurred during test cleanup", cleanupExceptions);
 
-                await _stateManager.MarkFailedAsync(test, aggregatedException).ConfigureAwait(false);
+                _stateManager.MarkFailed(test, aggregatedException);
             }
 
             switch (test.State)
@@ -277,7 +278,7 @@ private async Task ExecuteTestLifecycleAsync(AbstractExecutableTest test, Cancel
         if (test.Context.Metadata.TestDetails.ClassInstance is SkippedTestInstance ||
             !string.IsNullOrEmpty(test.Context.SkipReason))
         {
-            await _stateManager.MarkSkippedAsync(test, test.Context.SkipReason ?? "Test was skipped").ConfigureAwait(false);
+            _stateManager.MarkSkipped(test, test.Context.SkipReason ?? "Test was skipped");
 
             await _eventReceiverOrchestrator.InvokeTestSkippedEventReceiversAsync(test.Context, cancellationToken).ConfigureAwait(false);
 

TUnit.Engine/Services/TestExecution/TestStateManager.cs

@@ -10,14 +10,13 @@ namespace TUnit.Engine.Services.TestExecution;
 /// </summary>
 internal sealed class TestStateManager
 {
-    public Task MarkRunningAsync(AbstractExecutableTest test)
+    public void MarkRunning(AbstractExecutableTest test)
     {
         test.State = TestState.Running;
         test.StartTime = DateTimeOffset.UtcNow;
-        return Task.CompletedTask;
     }
 
-    public Task MarkCompletedAsync(AbstractExecutableTest test)
+    public void MarkCompleted(AbstractExecutableTest test)
     {
         var now = DateTimeOffset.UtcNow;
 
@@ -33,11 +32,9 @@ public Task MarkCompletedAsync(AbstractExecutableTest test)
 
         test.State = test.Result.State;
         test.EndTime = now;
-
-        return Task.CompletedTask;
     }
 
-    public Task MarkFailedAsync(AbstractExecutableTest test, Exception exception)
+    public void MarkFailed(AbstractExecutableTest test, Exception exception)
     {
         // Check if result has been overridden - if so, respect the override
         if (test.Context.Execution.Result?.IsOverridden == true)
@@ -59,11 +56,9 @@ public Task MarkFailedAsync(AbstractExecutableTest test, Exception exception)
                 ComputerName = EnvironmentHelper.MachineName
             };
         }
-
-        return Task.CompletedTask;
     }
 
-    public Task MarkSkippedAsync(AbstractExecutableTest test, string reason)
+    public void MarkSkipped(AbstractExecutableTest test, string reason)
     {
         test.State = TestState.Skipped;
         var now = DateTimeOffset.UtcNow;
@@ -84,11 +79,9 @@ public Task MarkSkippedAsync(AbstractExecutableTest test, string reason)
             Duration = test.EndTime - test.StartTime.GetValueOrDefault(),
             ComputerName = EnvironmentHelper.MachineName
         };
-
-        return Task.CompletedTask;
     }
 
-    public Task MarkCircularDependencyFailedAsync(AbstractExecutableTest test, Exception exception)
+    public void MarkCircularDependencyFailed(AbstractExecutableTest test, Exception exception)
     {
         test.State = TestState.Failed;
         var now = DateTimeOffset.UtcNow;
@@ -101,11 +94,9 @@ public Task MarkCircularDependencyFailedAsync(AbstractExecutableTest test, Excep
             Duration = TimeSpan.Zero,
             ComputerName = EnvironmentHelper.MachineName
         };
-
-        return Task.CompletedTask;
     }
 
-    public Task MarkDependencyResolutionFailedAsync(AbstractExecutableTest test, Exception exception)
+    public void MarkDependencyResolutionFailed(AbstractExecutableTest test, Exception exception)
     {
         test.State = TestState.Failed;
 
@@ -120,7 +111,5 @@ public Task MarkDependencyResolutionFailedAsync(AbstractExecutableTest test, Exc
             Duration = TimeSpan.Zero,
             ComputerName = EnvironmentHelper.MachineName
         };
-
-        return Task.CompletedTask;
     }
 }