Fix NotInParallel Order property not being respected for class-level attributes

TUnit.Engine/Scheduling/TestScheduler.cs

@@ -126,22 +126,28 @@ private async Task ExecuteNotInParallelTestsAsync(
         ConcurrentDictionary<AbstractExecutableTest, bool> completedTests,
         CancellationToken cancellationToken)
     {
-        var tests = new List<AbstractExecutableTest>();
-        while (queue.TryDequeue(out var test, out _))
+        var testsWithPriority = new List<(AbstractExecutableTest Test, TestPriority Priority)>();
+        while (queue.TryDequeue(out var test, out var priority))
         {
-            tests.Add(test);
+            testsWithPriority.Add((test, priority));
         }
 
-        // Sort by execution order from the plan
-        tests.Sort((a, b) =>
+        // Sort by NotInParallel Order first, then by execution order from the plan for dependency resolution
+        testsWithPriority.Sort((a, b) =>
         {
-            var aOrder = plan.ExecutionOrder.TryGetValue(a, out var ao) ? ao : int.MaxValue;
-            var bOrder = plan.ExecutionOrder.TryGetValue(b, out var bo) ? bo : int.MaxValue;
+            // Primary sort: NotInParallel Order (from TestPriority)
+            var priorityComparison = a.Priority.CompareTo(b.Priority);
+            if (priorityComparison != 0)
+                return priorityComparison;
+
+            // Secondary sort: ExecutionPlan order for dependency resolution when NotInParallel orders are equal
+            var aOrder = plan.ExecutionOrder.TryGetValue(a.Test, out var ao) ? ao : int.MaxValue;
+            var bOrder = plan.ExecutionOrder.TryGetValue(b.Test, out var bo) ? bo : int.MaxValue;
             return aOrder.CompareTo(bOrder);
         });
 
         // Execute sequentially
-        foreach (var test in tests)
+        foreach (var (test, _) in testsWithPriority)
         {
             await ExecuteTestWhenReadyAsync(test, executor, runningTasks, completedTests, cancellationToken);
         }
@@ -155,22 +161,28 @@ private async Task ExecuteKeyedNotInParallelTestsAsync(
         ConcurrentDictionary<AbstractExecutableTest, bool> completedTests,
         CancellationToken cancellationToken)
     {
-        var tests = new List<AbstractExecutableTest>();
-        while (queue.TryDequeue(out var test, out _))
+        var testsWithPriority = new List<(AbstractExecutableTest Test, TestPriority Priority)>();
+        while (queue.TryDequeue(out var test, out var priority))
         {
-            tests.Add(test);
+            testsWithPriority.Add((test, priority));
         }
 
-        // Sort by execution order
-        tests.Sort((a, b) =>
+        // Sort by NotInParallel Order first, then by execution order from the plan for dependency resolution
+        testsWithPriority.Sort((a, b) =>
         {
-            var aOrder = plan.ExecutionOrder.TryGetValue(a, out var ao) ? ao : int.MaxValue;
-            var bOrder = plan.ExecutionOrder.TryGetValue(b, out var bo) ? bo : int.MaxValue;
+            // Primary sort: NotInParallel Order (from TestPriority)
+            var priorityComparison = a.Priority.CompareTo(b.Priority);
+            if (priorityComparison != 0)
+                return priorityComparison;
+
+            // Secondary sort: ExecutionPlan order for dependency resolution when NotInParallel orders are equal
+            var aOrder = plan.ExecutionOrder.TryGetValue(a.Test, out var ao) ? ao : int.MaxValue;
+            var bOrder = plan.ExecutionOrder.TryGetValue(b.Test, out var bo) ? bo : int.MaxValue;
             return aOrder.CompareTo(bOrder);
         });
 
         // Execute sequentially within this key
-        foreach (var test in tests)
+        foreach (var (test, _) in testsWithPriority)
         {
             await ExecuteTestWhenReadyAsync(test, executor, runningTasks, completedTests, cancellationToken);
         }

TUnit.TestProject/NotInParallelOrderTest.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Threading.Tasks;
+using TUnit.Core;
+
+namespace TUnit.TestProject;
+
+[NotInParallel(Order = 2)]
+public sealed class Test1
+{
+    [Test]
+    public async Task TestCase1()
+    {
+        await Task.Delay(100);
+        Console.WriteLine("Test 1 - Order 2");
+    }
+}
+
+[NotInParallel(Order = 1)]
+public sealed class Test2
+{
+    [Test]
+    public Task TestCase2()
+    {
+        Console.WriteLine("Test 2 - Order 1");
+        return Task.CompletedTask;
+    }
+}
+
+[NotInParallel(Order = 3)]
+public sealed class Test3
+{
+    [Test]
+    public Task TestCase3()
+    {
+        Console.WriteLine("Test 3 - Order 3");
+        return Task.CompletedTask;
+    }
+}