chore: remove obsolete test result files and reflection log

TUnit.Engine/Models/GroupedTests.cs

@@ -1,15 +1,21 @@
 using TUnit.Core;
-using TUnit.Engine.Scheduling;
 
 namespace TUnit.Engine.Models;
 
 internal record GroupedTests
 {
-    public required IList<AbstractExecutableTest> Parallel { get; init; }
+    // Use arrays for blazingly fast iteration and zero allocation enumeration
+    public required AbstractExecutableTest[] Parallel { get; init; }
 
-    public required PriorityQueue<AbstractExecutableTest, TestPriority> NotInParallel { get; init; }
+    // Pre-sorted array by priority for ultra-fast iteration
+    // Tests are already sorted, no need to store priority
+    public required AbstractExecutableTest[] NotInParallel { get; init; }
 
-    public required IDictionary<string, PriorityQueue<AbstractExecutableTest, TestPriority>> KeyedNotInParallel { get; init; }
+    // Array of key-value pairs since we only iterate, never lookup by key
+    // Tests within each key are pre-sorted by priority
+    public required (string Key, AbstractExecutableTest[] Tests)[] KeyedNotInParallel { get; init; }
 
-    public required IDictionary<string, SortedDictionary<int, List<AbstractExecutableTest>>> ParallelGroups { get; init; }
+    // Array of groups with nested arrays for maximum iteration performance
+    // Tests are grouped by order, ready for parallel execution
+    public required (string Group, (int Order, AbstractExecutableTest[] Tests)[] OrderedTests)[] ParallelGroups { get; init; }
 }

TUnit.Engine/Scheduling/TestScheduler.cs

@@ -38,24 +38,21 @@ public async Task ScheduleAndExecuteAsync(
         if (tests == null) throw new ArgumentNullException(nameof(tests));
         if (executor == null) throw new ArgumentNullException(nameof(executor));
 
-        // Create execution plan upfront
-        var plan = ExecutionPlan.Create(tests);
-
-        if (plan.ExecutableTests.Count == 0)
+        var testList = tests as IList<AbstractExecutableTest> ?? tests.ToList();
+        if (testList.Count == 0)
         {
             await _logger.LogDebugAsync("No executable tests found");
             return;
         }
 
         // Group tests by constraints
-        var groupedTests = await _groupingService.GroupTestsByConstraintsAsync(plan.ExecutableTests);
+        var groupedTests = await _groupingService.GroupTestsByConstraintsAsync(testList);
 
         // Execute tests
-        await ExecuteGroupedTestsAsync(plan, groupedTests, executor, cancellationToken);
+        await ExecuteGroupedTestsAsync(groupedTests, executor, cancellationToken);
     }
 
     private async Task ExecuteGroupedTestsAsync(
-        ExecutionPlan plan,
         GroupedTests groupedTests,
         ITestExecutor executor,
         CancellationToken cancellationToken)
@@ -85,10 +82,9 @@ private async Task ExecuteGroupedTestsAsync(
         var allTestTasks = new List<Task>();
 
         // 1. NotInParallel tests (global) - must run one at a time
-        if (groupedTests.NotInParallel.Count > 0)
+        if (groupedTests.NotInParallel.Length > 0)
         {
             var globalNotInParallelTask = ExecuteNotInParallelTestsAsync(
-                plan,
                 groupedTests.NotInParallel,
                 executor,
                 runningTasks,
@@ -98,11 +94,10 @@ private async Task ExecuteGroupedTestsAsync(
         }
 
         // 2. Keyed NotInParallel tests - can run in parallel with other keys
-        foreach (var kvp in groupedTests.KeyedNotInParallel)
+        foreach (var (key, tests) in groupedTests.KeyedNotInParallel)
         {
             var keyedTask = ExecuteKeyedNotInParallelTestsAsync(
-                plan,
-                kvp.Value,
+                tests,
                 executor,
                 runningTasks,
                 completedTests,
@@ -111,9 +106,9 @@ private async Task ExecuteGroupedTestsAsync(
         }
 
         // 3. Parallel groups - can run in parallel within constraints
-        foreach (var group in groupedTests.ParallelGroups)
+        foreach (var (groupName, orderedTests) in groupedTests.ParallelGroups)
         {
-            var groupTask = ExecuteParallelGroupAsync(group.Value,
+            var groupTask = ExecuteParallelGroupAsync(orderedTests,
                 executor,
                 runningTasks,
                 completedTests,
@@ -136,40 +131,23 @@ private async Task ExecuteGroupedTestsAsync(
     }
 
     private async Task ExecuteNotInParallelTestsAsync(
-        ExecutionPlan plan,
-        PriorityQueue<AbstractExecutableTest, TestPriority> queue,
+        AbstractExecutableTest[] tests,
         ITestExecutor executor,
         ConcurrentDictionary<AbstractExecutableTest, Task> runningTasks,
         ConcurrentDictionary<AbstractExecutableTest, bool> completedTests,
         CancellationToken cancellationToken)
     {
-        var testsWithPriority = new List<(AbstractExecutableTest Test, TestPriority Priority)>();
-        while (queue.TryDequeue(out var test, out var priority))
-        {
-            testsWithPriority.Add((test, priority));
-        }
-
-        // Group tests by class
-        var testsByClass = testsWithPriority
-            .GroupBy(t => t.Test.Context.TestDetails.ClassType)
+        // Tests are already sorted by priority from TestGroupingService
+        // Group tests by class for execution
+        var testsByClass = tests
+            .GroupBy(t => t.Context.TestDetails.ClassType)
             .ToList();
 
-        // Sort classes by their minimum test Order
-        testsByClass.Sort((a, b) =>
-        {
-            var aMinOrder = a.Min(t => t.Priority.Order);
-            var bMinOrder = b.Min(t => t.Priority.Order);
-            return aMinOrder.CompareTo(bMinOrder);
-        });
-
         // Execute class by class
         foreach (var classGroup in testsByClass)
         {
-            // Sort tests within the class by Order, then by execution plan order
-            var classTests = classGroup.OrderBy(t => t.Priority.Order)
-                .ThenBy(t => plan.ExecutionOrder.TryGetValue(t.Test, out var order) ? order : int.MaxValue)
-                .Select(t => t.Test)
-                .ToList();
+            // Tests are already in priority order, just execute them
+            var classTests = classGroup.ToList();
 
             // Execute all tests from this class sequentially
             foreach (var test in classTests)
@@ -180,40 +158,23 @@ private async Task ExecuteNotInParallelTestsAsync(
     }
 
     private async Task ExecuteKeyedNotInParallelTestsAsync(
-        ExecutionPlan plan,
-        PriorityQueue<AbstractExecutableTest, TestPriority> queue,
+        AbstractExecutableTest[] tests,
         ITestExecutor executor,
         ConcurrentDictionary<AbstractExecutableTest, Task> runningTasks,
         ConcurrentDictionary<AbstractExecutableTest, bool> completedTests,
         CancellationToken cancellationToken)
     {
-        var testsWithPriority = new List<(AbstractExecutableTest Test, TestPriority Priority)>();
-        while (queue.TryDequeue(out var test, out var priority))
-        {
-            testsWithPriority.Add((test, priority));
-        }
-
-        // Group tests by class
-        var testsByClass = testsWithPriority
-            .GroupBy(t => t.Test.Context.TestDetails.ClassType)
+        // Tests are already sorted by priority from TestGroupingService
+        // Group tests by class for execution
+        var testsByClass = tests
+            .GroupBy(t => t.Context.TestDetails.ClassType)
             .ToList();
 
-        // Sort classes by their minimum test Order
-        testsByClass.Sort((a, b) =>
-        {
-            var aMinOrder = a.Min(t => t.Priority.Order);
-            var bMinOrder = b.Min(t => t.Priority.Order);
-            return aMinOrder.CompareTo(bMinOrder);
-        });
-
         // Execute class by class within this key
         foreach (var classGroup in testsByClass)
         {
-            // Sort tests within the class by Order, then by execution plan order
-            var classTests = classGroup.OrderBy(t => t.Priority.Order)
-                .ThenBy(t => plan.ExecutionOrder.TryGetValue(t.Test, out var order) ? order : int.MaxValue)
-                .Select(t => t.Test)
-                .ToList();
+            // Tests are already in priority order, just execute them
+            var classTests = classGroup.ToList();
 
             // Execute all tests from this class sequentially
             foreach (var test in classTests)
@@ -223,17 +184,17 @@ private async Task ExecuteKeyedNotInParallelTestsAsync(
         }
     }
 
-    private async Task ExecuteParallelGroupAsync(SortedDictionary<int, List<AbstractExecutableTest>> orderGroups,
+    private async Task ExecuteParallelGroupAsync((int Order, AbstractExecutableTest[] Tests)[] orderedTests,
         ITestExecutor executor,
         ConcurrentDictionary<AbstractExecutableTest, Task> runningTasks,
         ConcurrentDictionary<AbstractExecutableTest, bool> completedTests,
         int? maxParallelism,
         CancellationToken cancellationToken)
     {
-        // Execute order groups sequentially
-        foreach (var orderGroup in orderGroups.OrderBy(og => og.Key))
+        // Execute order groups sequentially (already sorted by order)
+        foreach (var (order, tests) in orderedTests)
         {
-            var processor = orderGroup.Value
+            var processor = tests
                 .ForEachAsync(async test => await ExecuteTestWhenReadyAsync(test, executor, runningTasks, completedTests, cancellationToken));
 
             if (maxParallelism is > 0)
@@ -247,7 +208,7 @@ private async Task ExecuteParallelGroupAsync(SortedDictionary<int, List<Abstract
         }
     }
 
-    private async Task ExecuteParallelTestsAsync(IEnumerable<AbstractExecutableTest> tests,
+    private async Task ExecuteParallelTestsAsync(AbstractExecutableTest[] tests,
         ITestExecutor executor,
         ConcurrentDictionary<AbstractExecutableTest, Task> runningTasks,
         ConcurrentDictionary<AbstractExecutableTest, bool> completedTests,

TUnit.Engine/Services/TestGroupingService.cs

@@ -18,8 +18,8 @@ public ValueTask<GroupedTests> GroupTestsByConstraintsAsync(IEnumerable<Abstract
     {
         // Use collection directly if already materialized, otherwise create efficient list
         var allTests = tests as IReadOnlyList<AbstractExecutableTest> ?? tests.ToList();
-        var notInParallelQueue = new PriorityQueue<AbstractExecutableTest, TestPriority>();
-        var keyedNotInParallelQueues = new Dictionary<string, PriorityQueue<AbstractExecutableTest, TestPriority>>();
+        var notInParallelList = new List<(AbstractExecutableTest Test, TestPriority Priority)>();
+        var keyedNotInParallelLists = new Dictionary<string, List<(AbstractExecutableTest Test, TestPriority Priority)>>();
         var parallelTests = new List<AbstractExecutableTest>();
         var parallelGroups = new Dictionary<string, SortedDictionary<int, List<AbstractExecutableTest>>>();
 
@@ -30,7 +30,7 @@ public ValueTask<GroupedTests> GroupTestsByConstraintsAsync(IEnumerable<Abstract
             switch (constraint)
             {
                 case NotInParallelConstraint notInParallel:
-                    ProcessNotInParallelConstraint(test, notInParallel, notInParallelQueue, keyedNotInParallelQueues);
+                    ProcessNotInParallelConstraint(test, notInParallel, notInParallelList, keyedNotInParallelLists);
                     break;
 
                 case ParallelGroupConstraint parallelGroup:
@@ -43,12 +43,32 @@ public ValueTask<GroupedTests> GroupTestsByConstraintsAsync(IEnumerable<Abstract
             }
         }
 
+        // Sort the NotInParallel tests by priority and extract just the tests
+        notInParallelList.Sort((a, b) => a.Priority.CompareTo(b.Priority));
+        var sortedNotInParallel = notInParallelList.Select(t => t.Test).ToArray();
+
+        // Sort keyed lists by priority and convert to array of tuples
+        var keyedArrays = keyedNotInParallelLists.Select(kvp =>
+        {
+            kvp.Value.Sort((a, b) => a.Priority.CompareTo(b.Priority));
+            return (kvp.Key, kvp.Value.Select(t => t.Test).ToArray());
+        }).ToArray();
+
+        // Convert parallel groups to array of tuples
+        var parallelGroupArrays = parallelGroups.Select(kvp =>
+        {
+            var orderedTests = kvp.Value.Select(orderKvp => 
+                (orderKvp.Key, orderKvp.Value.ToArray())
+            ).ToArray();
+            return (kvp.Key, orderedTests);
+        }).ToArray();
+
         var result = new GroupedTests
         {
-            Parallel = parallelTests,
-            NotInParallel = notInParallelQueue,
-            KeyedNotInParallel = keyedNotInParallelQueues,
-            ParallelGroups = parallelGroups
+            Parallel = parallelTests.ToArray(),
+            NotInParallel = sortedNotInParallel,
+            KeyedNotInParallel = keyedArrays,
+            ParallelGroups = parallelGroupArrays
         };
 
         return new ValueTask<GroupedTests>(result);
@@ -57,8 +77,8 @@ public ValueTask<GroupedTests> GroupTestsByConstraintsAsync(IEnumerable<Abstract
     private static void ProcessNotInParallelConstraint(
         AbstractExecutableTest test, 
         NotInParallelConstraint constraint,
-        PriorityQueue<AbstractExecutableTest, TestPriority> notInParallelQueue,
-        Dictionary<string, PriorityQueue<AbstractExecutableTest, TestPriority>> keyedQueues)
+        List<(AbstractExecutableTest Test, TestPriority Priority)> notInParallelList,
+        Dictionary<string, List<(AbstractExecutableTest Test, TestPriority Priority)>> keyedLists)
     {
         var order = constraint.Order;
         var priority = test.Context.ExecutionPriority;
@@ -67,18 +87,18 @@ private static void ProcessNotInParallelConstraint(
 
         if (constraint.NotInParallelConstraintKeys.Count == 0)
         {
-            notInParallelQueue.Enqueue(test, testPriority);
+            notInParallelList.Add((test, testPriority));
         }
         else
         {
             foreach (var key in constraint.NotInParallelConstraintKeys)
             {
-                if (!keyedQueues.TryGetValue(key, out var queue))
+                if (!keyedLists.TryGetValue(key, out var list))
                 {
-                    queue = new PriorityQueue<AbstractExecutableTest, TestPriority>();
-                    keyedQueues[key] = queue;
+                    list = new List<(AbstractExecutableTest Test, TestPriority Priority)>();
+                    keyedLists[key] = list;
                 }
-                queue.Enqueue(test, testPriority);
+                list.Add((test, testPriority));
             }
         }
     }

TUnit.Engine/TestDiscoveryService.cs

@@ -7,7 +7,6 @@
 using TUnit.Engine.Building;
 using TUnit.Engine.Configuration;
 using TUnit.Engine.Services;
-using TUnit.Engine.Scheduling;
 
 namespace TUnit.Engine;
 
@@ -78,9 +77,6 @@ public async Task<TestDiscoveryResult> DiscoverTests(string testSessionId, ITest
         // Check for circular dependencies and mark failed tests
         _dependencyResolver.CheckForCircularDependencies();
 
-        // Create execution plan for ordering
-        var executionPlan = ExecutionPlan.Create(tests);
-
         // Apply filter first to get the tests we want to run
         var filteredTests = _testFilterService.FilterTests(filter, tests);