Merge pull request #30 from alexey1312/alexey1312/fix-parallel-tests-total-count

Fix parallel test count parsing for Swift Testing

Author: alexey1312

Sources/OutputParser.swift

@@ -12,6 +12,7 @@ class OutputParser {
     private var summaryFailedTestsCount: Int?
     private var passedTestsCount: Int = 0
     private var seenPassedTestNames: Set<String> = []
+    private var parallelTestsTotalCount: Int?
 
     // Linker error parsing state
     private var currentLinkerArchitecture: String?
@@ -302,6 +303,17 @@ class OutputParser {
         ".xctest'"
     }
 
+    // Parallel test scheduling pattern: [N/TOTAL] Testing Module.Class/method
+    nonisolated(unsafe) private static let parallelTestSchedulingRegex = Regex {
+        "["
+        Capture(OneOrMore(.digit))
+        "/"
+        Capture(OneOrMore(.digit))
+        "] Testing "
+        Capture(OneOrMore(.any, .reluctant))
+        Anchor.endOfSubject
+    }
+
     func parse(
         input: String,
         printWarnings: Bool = false,
@@ -339,9 +351,16 @@ class OutputParser {
 
         let summaryFailedCount = summaryFailedTestsCount ?? failedTests.count
         let computedPassedTests: Int? = {
+            // Priority 1: Use parallel test total count if available
+            // This is the authoritative count from [N/TOTAL] Testing lines
+            if let parallelTotal = parallelTestsTotalCount {
+                return max(parallelTotal - summaryFailedCount, 0)
+            }
+            // Priority 2: Use executed tests count from summary line
             if let executed = executedTestsCount {
                 return max(executed - summaryFailedCount, 0)
             }
+            // Priority 3: Use counted passed tests
             if passedTestsCount > 0 {
                 return passedTestsCount
             }
@@ -407,6 +426,7 @@ class OutputParser {
         pendingLinkerSymbol = nil
         pendingDuplicateSymbol = nil
         pendingConflictingFiles = []
+        parallelTestsTotalCount = nil
     }
 
     private func parseLine(_ line: String) {
@@ -424,12 +444,23 @@ class OutputParser {
         let containsRelevant =
             line.contains("error:") || line.contains("warning:") || line.contains("failed") || line.contains("passed")
             || line.contains("✘") || line.contains("✓") || line.contains("❌") || line.contains("Build succeeded")
-            || line.contains("Build failed") || line.contains("Executed")
+            || line.contains("Build failed") || line.contains("Executed") || line.contains("] Testing ")
 
         if !containsRelevant {
             return
         }
 
+        // Parse parallel test scheduling lines: [N/TOTAL] Testing Module.Class/method
+        if line.contains("] Testing "), let match = line.firstMatch(of: Self.parallelTestSchedulingRegex) {
+            if let _ = Int(match.1), let total = Int(match.2) {
+                // Only set on first match (total should be consistent across all lines)
+                if parallelTestsTotalCount == nil {
+                    parallelTestsTotalCount = total
+                }
+            }
+            return
+        }
+
         if let failedTest = parseFailedTest(line) {
             let normalizedTestName = normalizeTestName(failedTest.test)
 
@@ -914,6 +945,36 @@ class OutputParser {
             }
         }
 
+        // Pattern: ✘ Test run with N test(s) failed, N test(s) passed after X seconds.
+        // Swift Testing failure summary format (check this BEFORE the passed-only pattern)
+        if let testRunRange = line.range(of: "Test run with "),
+            let failedRange = line.range(of: " failed, ", range: testRunRange.upperBound ..< line.endIndex),
+            let passedRange = line.range(of: " passed after ", range: failedRange.upperBound ..< line.endIndex)
+        {
+            // Extract failed count
+            let beforeFailed = line[testRunRange.upperBound ..< failedRange.lowerBound]
+            let failedCountStr = beforeFailed.split(separator: " ").first
+            if let failedCountStr = failedCountStr, let failedCount = Int(failedCountStr) {
+                summaryFailedTestsCount = failedCount
+            }
+
+            // Extract passed count (for executedTestsCount calculation)
+            let beforePassed = line[failedRange.upperBound ..< passedRange.lowerBound]
+            let passedCountStr = beforePassed.split(separator: " ").first
+            if let passedCountStr = passedCountStr, let passedCount = Int(passedCountStr),
+                let failedCount = summaryFailedTestsCount
+            {
+                executedTestsCount = passedCount + failedCount
+            }
+
+            // Extract time
+            let afterPassed = line[passedRange.upperBound...]
+            if let secondsRange = afterPassed.range(of: " seconds", options: .backwards) {
+                return String(afterPassed[..<secondsRange.lowerBound])
+            }
+            return String(afterPassed).trimmingCharacters(in: CharacterSet(charactersIn: "."))
+        }
+
         // Pattern: Test run with N tests in N suites passed after X seconds.
         // Note: Swift Testing output may have a Unicode checkmark prefix (e.g., "􁁛  Test run with...")
         if let testRunRange = line.range(of: "Test run with "),

Tests/ParsingTests.swift

@@ -380,4 +380,129 @@ final class ParsingTests: XCTestCase {
         XCTAssertEqual(result.errors[0].line, 15)
         XCTAssertEqual(result.errors[0].message, "use of undeclared identifier 'unknown'")
     }
+
+    // MARK: - Swift Test Parallel Tests
+
+    func testSwiftTestParallelAllPassed() {
+        let parser = OutputParser()
+        let input = """
+            Building for debugging...
+            Build complete! (5.00s)
+            [1/20] Testing ModuleA.TestClassA/testMethod1
+            [2/20] Testing ModuleA.TestClassA/testMethod2
+            [3/20] Testing ModuleA.TestClassA/testMethod3
+            [4/20] Testing ModuleA.TestClassB/testMethod1
+            [5/20] Testing ModuleA.TestClassB/testMethod2
+            [6/20] Testing ModuleB.TestClassC/testMethod1
+            [7/20] Testing ModuleB.TestClassC/testMethod2
+            [8/20] Testing ModuleB.TestClassC/testMethod3
+            [9/20] Testing ModuleB.TestClassD/testMethod1
+            [10/20] Testing ModuleB.TestClassD/testMethod2
+            [11/20] Testing ModuleC.TestClassE/testMethod1
+            [12/20] Testing ModuleC.TestClassE/testMethod2
+            [13/20] Testing ModuleC.TestClassE/testMethod3
+            [14/20] Testing ModuleC.TestClassE/testMethod4
+            [15/20] Testing ModuleC.TestClassF/testMethod1
+            [16/20] Testing ModuleC.TestClassF/testMethod2
+            [17/20] Testing ModuleD.TestClassG/testMethod1
+            [18/20] Testing ModuleD.TestClassG/testMethod2
+            [19/20] Testing ModuleD.TestClassG/testMethod3
+            [20/20] Testing ModuleD.TestClassH/testMethod1
+            ◇ Test run started.
+            ↳ Testing Library Version: 6.0.3
+            ◇ Suite "TestClassG" started.
+            ✔ Test "testMethod1" passed after 0.005 seconds.
+            ✔ Test "testMethod2" passed after 0.004 seconds.
+            ✔ Test "testMethod3" passed after 0.003 seconds.
+            ✔ Suite "TestClassG" passed after 0.010 seconds.
+            ✔ Test run with 4 tests passed after 0.015 seconds.
+            """
+
+        let result = parser.parse(input: input)
+
+        XCTAssertEqual(result.status, "success")
+        XCTAssertEqual(result.summary.passedTests, 20)
+        XCTAssertEqual(result.summary.failedTests, 0)
+    }
+
+    func testSwiftTestParallelWithFailure() {
+        let parser = OutputParser()
+        let input = """
+            Building for debugging...
+            Build complete! (5.00s)
+            [1/10] Testing ModuleA.TestClassA/testMethod1
+            [2/10] Testing ModuleA.TestClassA/testMethod2
+            [3/10] Testing ModuleA.TestClassA/testMethod3
+            [4/10] Testing ModuleA.TestClassB/testMethod1
+            [5/10] Testing ModuleA.TestClassB/testMethod2
+            [6/10] Testing ModuleB.TestClassC/testMethod1
+            [7/10] Testing ModuleB.TestClassC/testMethod2
+            [8/10] Testing ModuleB.TestClassC/testMethod3
+            [9/10] Testing ModuleB.TestClassD/testMethod1
+            [10/10] Testing ModuleB.TestClassD/testMethod2
+            ◇ Test run started.
+            ↳ Testing Library Version: 6.0.3
+            ◇ Suite "TestClassD" started.
+            ✔ Test "testMethod1" passed after 0.005 seconds.
+            ✘ Test "testMethod2" failed after 0.010 seconds.
+            ✘ Test run with 1 test failed, 1 test passed after 0.020 seconds.
+            """
+
+        let result = parser.parse(input: input)
+
+        XCTAssertEqual(result.status, "failed")
+        XCTAssertEqual(result.summary.passedTests, 9)
+        XCTAssertEqual(result.summary.buildTime, "0.020")
+    }
+
+    func testSwiftTestParallelLargeCount() {
+        let parser = OutputParser()
+        // Simulate a large test run with 1306 tests
+        var input = "Building for debugging...\nBuild complete! (5.00s)\n"
+        for i in 1 ... 1306 {
+            input += "[\(i)/1306] Testing Module.TestClass/testMethod\(i)\n"
+        }
+        input += "◇ Test run started.\n"
+        input += "✔ Test run with 82 tests passed after 0.170 seconds.\n"
+
+        let result = parser.parse(input: input)
+
+        XCTAssertEqual(result.status, "success")
+        XCTAssertEqual(result.summary.passedTests, 1306)
+        XCTAssertEqual(result.summary.failedTests, 0)
+    }
+
+    func testSwiftTestParallelPrioritizesSchedulingCount() {
+        let parser = OutputParser()
+        // When both [N/TOTAL] and "Test run with X tests passed" are present,
+        // the [N/TOTAL] count should take priority
+        let input = """
+            [1/100] Testing Module.TestClass/testMethod1
+            [100/100] Testing Module.TestClass/testMethod100
+            ◇ Test run started.
+            ✔ Test run with 5 tests passed after 0.015 seconds.
+            """
+
+        let result = parser.parse(input: input)
+
+        // Should use 100 from [N/TOTAL], not 5 from summary
+        XCTAssertEqual(result.summary.passedTests, 100)
+    }
+
+    func testSwiftTestingFailureSummaryParsing() {
+        let parser = OutputParser()
+        let input = """
+            ◇ Test run started.
+            ✘ Test "testMethod" failed after 0.010 seconds.
+            ✘ Test run with 3 tests failed, 7 tests passed after 0.050 seconds.
+            """
+
+        let result = parser.parse(input: input)
+
+        XCTAssertEqual(result.status, "failed")
+        // Without [N/TOTAL] lines, should use summary: 3 failed + 7 passed = 10 total
+        // passed = 10 - 3 = 7
+        XCTAssertEqual(result.summary.passedTests, 7)
+        XCTAssertEqual(result.summary.buildTime, "0.050")
+    }
 }