Use NUnit.Engine for test discovery

Use worker's NUnit.Engine-based discovery instead of reflection-based
discovery. This properly expands parameterized tests (e.g., strict/
non-strict mode) and gives accurate counts upfront.

- Spawn discovery worker before execution
- Filter results using new TestFilter.Matches(fqn, displayName) overload
- Revert dynamic total updates (no longer needed)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: rogeralsing

src/Asynkron.TestRunner/LiveDisplay.cs

@@ -21,7 +21,6 @@ public class LiveDisplay
     private int _skipped;
     private int _hanging;
     private int _crashed;
-    private int _seen; // Actual unique tests seen (handles parameterized expansion)
     private readonly HashSet<string> _running = new();
     private string? _lastCompleted;
     private string? _lastStatus;
@@ -33,14 +32,7 @@ public void SetTotal(int total)
 
     public void TestStarted(string displayName)
     {
-        lock (_lock)
-        {
-            _running.Add(Truncate(displayName, ContentWidth));
-            _seen++;
-            // Update total if we're seeing more tests than discovered (parameterized expansion)
-            if (_seen > _total)
-                _total = _seen;
-        }
+        lock (_lock) _running.Add(Truncate(displayName, ContentWidth));
     }
 
     public void TestPassed(string displayName)

src/Asynkron.TestRunner/TestDiscovery.cs

@@ -73,6 +73,27 @@ public bool Matches(DiscoveredTest test)
         return true;
     }
 
+    /// <summary>
+    /// Matches against FQN and display name (for worker discovery results)
+    /// </summary>
+    public bool Matches(string fullyQualifiedName, string displayName)
+    {
+        // FQN format: Namespace.Class.Method
+        if (Namespace != null && !fullyQualifiedName.Contains(Namespace, StringComparison.OrdinalIgnoreCase))
+            return false;
+
+        if (Class != null && !fullyQualifiedName.Contains(Class, StringComparison.OrdinalIgnoreCase))
+            return false;
+
+        if (Method != null && !fullyQualifiedName.Contains(Method, StringComparison.OrdinalIgnoreCase))
+            return false;
+
+        if (DisplayName != null && !displayName.Contains(DisplayName, StringComparison.OrdinalIgnoreCase))
+            return false;
+
+        return true;
+    }
+
     public bool IsEmpty => Namespace == null && Class == null && Method == null && DisplayName == null;
 
     public override string ToString()

src/Asynkron.TestRunner/TestRunner.cs

@@ -46,10 +46,22 @@ public async Task<int> RunTestsAsync(string[] assemblyPaths)
 
             AnsiConsole.MarkupLine($"[dim]Running tests in:[/] {Path.GetFileName(assemblyPath)}");
 
-            // Discover all tests upfront
-            var filter = TestFilter.Parse(_filter);
-            var discovered = await TestDiscovery.DiscoverTestsAsync([assemblyPath], filter);
-            var allTests = discovered.Select(t => t.FullyQualifiedName).ToList();
+            // Discover tests using worker (NUnit.Engine expands parameterized tests correctly)
+            AnsiConsole.MarkupLine($"[dim]Discovering tests...[/]");
+            List<string> allTests;
+            await using (var discoveryWorker = WorkerProcess.Spawn())
+            {
+                var discovered = await discoveryWorker.DiscoverAsync(assemblyPath);
+
+                // Apply filter if specified
+                if (!string.IsNullOrWhiteSpace(_filter))
+                {
+                    var filter = TestFilter.Parse(_filter);
+                    discovered = discovered.Where(t => filter.Matches(t.FullyQualifiedName, t.DisplayName)).ToList();
+                }
+
+                allTests = discovered.Select(t => t.FullyQualifiedName).ToList();
+            }
 
             if (allTests.Count == 0)
             {