From 5ecf93f72959dbaf10522c74d1f6f430bdc1ffb1 Mon Sep 17 00:00:00 2001
From: Jeremy Bannister <jeremy.a.bannister@gmail.com>
Date: Tue, 3 Feb 2026 18:19:15 +0100
Subject: [PATCH 1/2] feat: support Swift Testing

---
 Sources/OutputParser.swift | 85 +++++++++++++++++++++++++++++++++++++-
 Tests/ParsingTests.swift   | 25 +++++++++++
 2 files changed, 109 insertions(+), 1 deletion(-)

diff --git a/Sources/OutputParser.swift b/Sources/OutputParser.swift
index edaec18..057d6d5 100644
--- a/Sources/OutputParser.swift
+++ b/Sources/OutputParser.swift
@@ -696,7 +696,8 @@ class OutputParser {
             || line.contains("✘") || line.contains("✓") || line.contains("❌") || line.contains("Build succeeded")
             || line.contains("Build failed") || line.contains("Executed") || line.contains("] Testing ")
             || line.contains("BUILD SUCCEEDED") || line.contains("BUILD FAILED") || line.contains("TEST FAILED")
-            || line.contains("Build complete!") || line.hasPrefix("RegisterWithLaunchServices")
+            || line.contains("Build complete!") || line.contains("recorded an issue")
+            || line.hasPrefix("RegisterWithLaunchServices")
             || line.hasPrefix("Validate") || line.contains("Fatal error")
             || (line.hasPrefix("/") && line.contains(".swift:"))  // runtime warnings
 
@@ -1325,6 +1326,25 @@ class OutputParser {
             }
         }
 
+        // Pattern: Test name() recorded an issue at file:line:column: message (Swift Testing, no quotes, leading glyphs)
+        if let testStart = line.range(of: "Test "),
+            let issueAt = line.range(of: " recorded an issue at ", range: testStart.upperBound ..< line.endIndex)
+        {
+            let afterTest = line[testStart.upperBound...]
+            if !afterTest.hasPrefix("run with ") {
+                let test = String(line[testStart.upperBound ..< issueAt.lowerBound]).trimmingCharacters(in: .whitespaces)
+                let afterIssue = String(line[issueAt.upperBound...])
+
+                // Parse file:line:column: message
+                let parts = afterIssue.split(separator: ":", maxSplits: 3, omittingEmptySubsequences: false)
+                if parts.count >= 4, let lineNum = Int(parts[1]) {
+                    let file = String(parts[0])
+                    let message = String(parts[3]).trimmingCharacters(in: .whitespaces)
+                    return FailedTest(test: test, message: message, file: file, line: lineNum)
+                }
+            }
+        }
+
         // Pattern: ✘ Test "name" failed after 0.123 seconds with N issues.
         if line.hasPrefix("✘ Test \""), let failedAfter = line.range(of: "\" failed after ") {
             let startIndex = line.index(line.startIndex, offsetBy: 8)
@@ -1347,6 +1367,33 @@ class OutputParser {
             return FailedTest(test: test, message: "Test failed", file: nil, line: nil, duration: duration)
         }
 
+        // Pattern: Test name() failed after 0.123 seconds with N issues. (Swift Testing, no quotes, leading glyphs)
+        if let testStart = line.range(of: "Test "),
+            let failedAfter = line.range(of: " failed after ", range: testStart.upperBound ..< line.endIndex)
+        {
+            let afterTest = line[testStart.upperBound...]
+            if !afterTest.hasPrefix("run with ") {
+                let test = String(line[testStart.upperBound ..< failedAfter.lowerBound])
+                    .trimmingCharacters(in: .whitespaces)
+
+                // Extract duration from "failed after X.XXX seconds"
+                var duration: Double? = nil
+                let afterStr = line[failedAfter.upperBound...]
+                if let secondsRange = afterStr.range(of: " seconds") {
+                    let durationStr = String(afterStr[..<secondsRange.lowerBound])
+                    duration = Double(durationStr)
+                }
+
+                // Track duration for slow test detection
+                let normalizedTest = normalizeTestName(test)
+                if let dur = duration {
+                    failedTestDurations[normalizedTest] = dur
+                }
+
+                return FailedTest(test: test, message: "Test failed", file: nil, line: nil, duration: duration)
+            }
+        }
+
         // Pattern: ❌ testname (message)
         if line.hasPrefix("❌ "), let parenStart = line.range(of: " ("),
             let parenEnd = line.range(of: ")", options: .backwards)
@@ -1476,6 +1523,42 @@ class OutputParser {
             return
         }
 
+        // Pattern: Test run with N test(s) in M suite(s) failed after X seconds with Y issue(s).
+        // Swift Testing failure summary format - TEST time
+        if let testRunRange = line.range(of: "Test run with "),
+            let failedAfterRange = line.range(of: " failed after ", range: testRunRange.upperBound ..< line.endIndex)
+        {
+            let beforeFailed = line[testRunRange.upperBound ..< failedAfterRange.lowerBound]
+            let totalCountStr = beforeFailed.split(separator: " ").first
+            if let totalCountStr = totalCountStr, let totalCount = Int(totalCountStr) {
+                swiftTestingExecutedCount = totalCount
+            }
+
+            // Extract TEST time and accumulate
+            let afterFailed = line[failedAfterRange.upperBound...]
+            if let secondsRange = afterFailed.range(of: " seconds", options: .backwards) {
+                accumulateTestTime(String(afterFailed[..<secondsRange.lowerBound]))
+
+                // Extract issue count (if present) from the trailing "with Y issue(s)"
+                let afterSeconds = afterFailed[secondsRange.upperBound...]
+                if let withRange = afterSeconds.range(of: " with "),
+                    let issueRange = afterSeconds.range(of: " issue", range: withRange.upperBound ..< afterSeconds.endIndex)
+                {
+                    let issueCountStr = afterSeconds[withRange.upperBound ..< issueRange.lowerBound]
+                    if let issueCount = Int(issueCountStr.trimmingCharacters(in: .whitespaces)) {
+                        if let totalCount = swiftTestingExecutedCount {
+                            swiftTestingFailedCount = min(issueCount, totalCount)
+                        } else {
+                            swiftTestingFailedCount = issueCount
+                        }
+                    }
+                }
+            } else {
+                accumulateTestTime(String(afterFailed))
+            }
+            return
+        }
+
         // Pattern: Test run with N tests in N suites passed after X seconds.
         // Swift Testing output format (passed-only case) - TEST time
         if let testRunRange = line.range(of: "Test run with "),
diff --git a/Tests/ParsingTests.swift b/Tests/ParsingTests.swift
index e824eef..cbeb162 100644
--- a/Tests/ParsingTests.swift
+++ b/Tests/ParsingTests.swift
@@ -779,6 +779,31 @@ final class ParsingTests: XCTestCase {
         XCTAssertEqual(result.summary.testTime, "0.050s")
     }
 
+    func testSwiftTesting() {
+        let parser = OutputParser()
+        let input = """
+            􀟈  Test shouldPass() started.
+            􀟈  Test shouldFail() started.
+            􁁛  Test shouldPass() passed after 0.001 seconds.
+            􀢄  Test shouldFail() recorded an issue at xcsift_problemsTests.swift:9:5: Expectation failed: Bool(false)
+            􀢄  Test shouldFail() failed after 0.001 seconds with 1 issue.
+            􀢄  Test run with 2 tests in 0 suites failed after 0.001 seconds with 1 issue.
+
+            """
+
+        let result = parser.parse(input: input)
+
+        XCTAssertEqual(result.status, "failed")
+        XCTAssertEqual(result.summary.passedTests, 1)
+        XCTAssertEqual(result.summary.failedTests, 1)
+        XCTAssertEqual(result.failedTests.count, 1)
+        XCTAssertEqual(result.failedTests[0].test, "shouldFail()")
+        XCTAssertEqual(result.failedTests[0].message, "Expectation failed: Bool(false)")
+        XCTAssertEqual(result.failedTests[0].file, "xcsift_problemsTests.swift")
+        XCTAssertEqual(result.failedTests[0].line, 9)
+        XCTAssertEqual(result.failedTests[0].duration, 0.001)
+    }
+
     // MARK: - Test Duration Parsing
 
     func testParseDurationFromXCTestPassed() {

From 6a07d6adc520ddd51f453c556086f232123ac061 Mon Sep 17 00:00:00 2001
From: alexey1312 <alexey1312ru@gmail.com>
Date: Wed, 4 Feb 2026 01:02:23 +0500
Subject: [PATCH 2/2] refactor: Unify Swift Testing parsing patterns

- Add extractSwiftTestingName() helper function that handles both:
  - Quoted format: Test "Human readable name" ...
  - Unquoted format: Test functionName() ...

- Replace 4 separate parsing blocks (~80 lines) with 1 universal block
  that uses the helper function

- Add tests for quoted format and mixed format scenarios

- Remove code duplication while maintaining full backward compatibility

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 Sources/OutputParser.swift | 167 ++++++++++++++++++++-----------------
 Tests/ParsingTests.swift   |  37 ++++++++
 2 files changed, 127 insertions(+), 77 deletions(-)

diff --git a/Sources/OutputParser.swift b/Sources/OutputParser.swift
index 057d6d5..568f136 100644
--- a/Sources/OutputParser.swift
+++ b/Sources/OutputParser.swift
@@ -897,6 +897,43 @@ class OutputParser {
         return testName
     }
 
+    // MARK: - Swift Testing Name Extraction
+
+    /// Extracts test name from Swift Testing output line.
+    /// Handles both formats:
+    /// - With displayName: `Test "Human readable name" ...`
+    /// - Without displayName: `Test functionName() ...`
+    ///
+    /// Returns: (testName, endIndex) or nil if not found
+    private func extractSwiftTestingName(
+        from line: String,
+        after startIndex: String.Index
+    ) -> (name: String, endIndex: String.Index)? {
+        let afterTest = line[startIndex...]
+
+        // Format 1: With quotes (displayName)
+        if afterTest.hasPrefix("\"") {
+            let nameStart = line.index(after: startIndex)
+            if let quoteEnd = line[nameStart...].firstIndex(of: "\"") {
+                let name = String(line[nameStart ..< quoteEnd])
+                return (name, line.index(after: quoteEnd))
+            }
+        }
+
+        // Format 2: Without quotes (function name)
+        // Find end markers: " recorded", " failed", " passed", " started"
+        let endMarkers = [" recorded", " failed", " passed", " started"]
+        for marker in endMarkers {
+            if let markerRange = afterTest.range(of: marker) {
+                let name = String(line[startIndex ..< markerRange.lowerBound])
+                    .trimmingCharacters(in: .whitespaces)
+                return (name, markerRange.lowerBound)
+            }
+        }
+
+        return nil
+    }
+
     private func hasSeenSimilarTest(_ normalizedTestName: String) -> Bool {
         return seenTestNames.contains(normalizedTestName)
     }
@@ -1311,86 +1348,59 @@ class OutputParser {
             return FailedTest(test: test, message: message, file: nil, line: nil, duration: duration)
         }
 
-        // Pattern: ✘ Test "name" recorded an issue at file:line:column: message
-        if line.hasPrefix("✘ Test \""), let issueAt = line.range(of: "\" recorded an issue at ") {
-            let startIndex = line.index(line.startIndex, offsetBy: 8)
-            let test = String(line[startIndex ..< issueAt.lowerBound])
-            let afterIssue = String(line[issueAt.upperBound...])
-
-            // Parse file:line:column: message
-            let parts = afterIssue.split(separator: ":", maxSplits: 3, omittingEmptySubsequences: false)
-            if parts.count >= 4, let lineNum = Int(parts[1]) {
-                let file = String(parts[0])
-                let message = String(parts[3]).trimmingCharacters(in: .whitespaces)
-                return FailedTest(test: test, message: message, file: file, line: lineNum)
-            }
-        }
-
-        // Pattern: Test name() recorded an issue at file:line:column: message (Swift Testing, no quotes, leading glyphs)
-        if let testStart = line.range(of: "Test "),
-            let issueAt = line.range(of: " recorded an issue at ", range: testStart.upperBound ..< line.endIndex)
-        {
-            let afterTest = line[testStart.upperBound...]
-            if !afterTest.hasPrefix("run with ") {
-                let test = String(line[testStart.upperBound ..< issueAt.lowerBound]).trimmingCharacters(in: .whitespaces)
-                let afterIssue = String(line[issueAt.upperBound...])
-
-                // Parse file:line:column: message
-                let parts = afterIssue.split(separator: ":", maxSplits: 3, omittingEmptySubsequences: false)
-                if parts.count >= 4, let lineNum = Int(parts[1]) {
-                    let file = String(parts[0])
-                    let message = String(parts[3]).trimmingCharacters(in: .whitespaces)
-                    return FailedTest(test: test, message: message, file: file, line: lineNum)
-                }
-            }
-        }
-
-        // Pattern: ✘ Test "name" failed after 0.123 seconds with N issues.
-        if line.hasPrefix("✘ Test \""), let failedAfter = line.range(of: "\" failed after ") {
-            let startIndex = line.index(line.startIndex, offsetBy: 8)
-            let test = String(line[startIndex ..< failedAfter.lowerBound])
-
-            // Extract duration from "failed after X.XXX seconds"
-            var duration: Double? = nil
-            let afterStr = line[failedAfter.upperBound...]
-            if let secondsRange = afterStr.range(of: " seconds") {
-                let durationStr = String(afterStr[..<secondsRange.lowerBound])
-                duration = Double(durationStr)
-            }
-
-            // Track duration for slow test detection
-            let normalizedTest = normalizeTestName(test)
-            if let dur = duration {
-                failedTestDurations[normalizedTest] = dur
-            }
-
-            return FailedTest(test: test, message: "Test failed", file: nil, line: nil, duration: duration)
-        }
+        // Swift Testing: Test {name} recorded an issue / failed after
+        // Supports: any leading symbol (✘, 􀢄, ◇, etc.), with or without quotes
+        // Formats:
+        //   - Test "Human readable name" recorded an issue at file:line:col: message
+        //   - Test functionName() recorded an issue at file:line:col: message
+        //   - Test "name" failed after 0.123 seconds [with N issues]
+        //   - Test name() failed after 0.123 seconds [with N issues]
+        if let testStart = line.range(of: "Test ") {
+            // Skip "Test run with" (summary line) and "Test Case" (XCTest format)
+            let beforeTest = line[..<testStart.lowerBound]
+            let afterTestStr = line[testStart.upperBound...]
+
+            if !afterTestStr.hasPrefix("run with ") && !afterTestStr.hasPrefix("Case ") {
+                if let (testName, nameEnd) = extractSwiftTestingName(from: line, after: testStart.upperBound) {
+                    let afterName = line[nameEnd...]
+
+                    // Pattern: recorded an issue at file:line:col: message
+                    if let issueAt = afterName.range(of: " recorded an issue at ") {
+                        let afterIssue = String(line[issueAt.upperBound...])
+
+                        // Parse file:line:column: message
+                        let parts = afterIssue.split(separator: ":", maxSplits: 3, omittingEmptySubsequences: false)
+                        if parts.count >= 4, let lineNum = Int(parts[1]) {
+                            let file = String(parts[0])
+                            let message = String(parts[3]).trimmingCharacters(in: .whitespaces)
+                            return FailedTest(test: testName, message: message, file: file, line: lineNum)
+                        }
+                    }
 
-        // Pattern: Test name() failed after 0.123 seconds with N issues. (Swift Testing, no quotes, leading glyphs)
-        if let testStart = line.range(of: "Test "),
-            let failedAfter = line.range(of: " failed after ", range: testStart.upperBound ..< line.endIndex)
-        {
-            let afterTest = line[testStart.upperBound...]
-            if !afterTest.hasPrefix("run with ") {
-                let test = String(line[testStart.upperBound ..< failedAfter.lowerBound])
-                    .trimmingCharacters(in: .whitespaces)
+                    // Pattern: failed after X.XXX seconds [with N issue(s)]
+                    if let failedAfter = afterName.range(of: " failed after ") {
+                        var duration: Double? = nil
+                        let afterFailed = line[failedAfter.upperBound...]
+                        if let secondsRange = afterFailed.range(of: " seconds") {
+                            let durationStr = String(afterFailed[..<secondsRange.lowerBound])
+                            duration = Double(durationStr)
+                        }
 
-                // Extract duration from "failed after X.XXX seconds"
-                var duration: Double? = nil
-                let afterStr = line[failedAfter.upperBound...]
-                if let secondsRange = afterStr.range(of: " seconds") {
-                    let durationStr = String(afterStr[..<secondsRange.lowerBound])
-                    duration = Double(durationStr)
-                }
+                        // Track duration for slow test detection
+                        let normalizedTest = normalizeTestName(testName)
+                        if let dur = duration {
+                            failedTestDurations[normalizedTest] = dur
+                        }
 
-                // Track duration for slow test detection
-                let normalizedTest = normalizeTestName(test)
-                if let dur = duration {
-                    failedTestDurations[normalizedTest] = dur
+                        return FailedTest(
+                            test: testName,
+                            message: "Test failed",
+                            file: nil,
+                            line: nil,
+                            duration: duration
+                        )
+                    }
                 }
-
-                return FailedTest(test: test, message: "Test failed", file: nil, line: nil, duration: duration)
             }
         }
 
@@ -1542,7 +1552,10 @@ class OutputParser {
                 // Extract issue count (if present) from the trailing "with Y issue(s)"
                 let afterSeconds = afterFailed[secondsRange.upperBound...]
                 if let withRange = afterSeconds.range(of: " with "),
-                    let issueRange = afterSeconds.range(of: " issue", range: withRange.upperBound ..< afterSeconds.endIndex)
+                    let issueRange = afterSeconds.range(
+                        of: " issue",
+                        range: withRange.upperBound ..< afterSeconds.endIndex
+                    )
                 {
                     let issueCountStr = afterSeconds[withRange.upperBound ..< issueRange.lowerBound]
                     if let issueCount = Int(issueCountStr.trimmingCharacters(in: .whitespaces)) {
diff --git a/Tests/ParsingTests.swift b/Tests/ParsingTests.swift
index cbeb162..ab88ede 100644
--- a/Tests/ParsingTests.swift
+++ b/Tests/ParsingTests.swift
@@ -804,6 +804,43 @@ final class ParsingTests: XCTestCase {
         XCTAssertEqual(result.failedTests[0].duration, 0.001)
     }
 
+    func testSwiftTestingWithQuotes() {
+        let parser = OutputParser()
+        let input = """
+            ✘ Test "Food truck exists" recorded an issue at FoodTruckTests.swift:15:5: Assertion failed
+            ✘ Test "Food truck exists" failed after 0.002 seconds with 1 issue.
+            """
+
+        let result = parser.parse(input: input)
+
+        XCTAssertEqual(result.status, "failed")
+        XCTAssertEqual(result.failedTests.count, 1)
+        XCTAssertEqual(result.failedTests[0].test, "Food truck exists")
+        XCTAssertEqual(result.failedTests[0].message, "Assertion failed")
+        XCTAssertEqual(result.failedTests[0].file, "FoodTruckTests.swift")
+        XCTAssertEqual(result.failedTests[0].line, 15)
+    }
+
+    func testSwiftTestingMixedFormats() {
+        // Test that both quoted and unquoted formats work together
+        let parser = OutputParser()
+        let input = """
+            ✘ Test "Human readable test" recorded an issue at Tests.swift:10:3: First failure
+            ✘ Test "Human readable test" failed after 0.001 seconds with 1 issue.
+            􀢄  Test functionTest() recorded an issue at Tests.swift:20:5: Second failure
+            􀢄  Test functionTest() failed after 0.002 seconds with 1 issue.
+            """
+
+        let result = parser.parse(input: input)
+
+        XCTAssertEqual(result.status, "failed")
+        XCTAssertEqual(result.failedTests.count, 2)
+        XCTAssertEqual(result.failedTests[0].test, "Human readable test")
+        XCTAssertEqual(result.failedTests[0].message, "First failure")
+        XCTAssertEqual(result.failedTests[1].test, "functionTest()")
+        XCTAssertEqual(result.failedTests[1].message, "Second failure")
+    }
+
     // MARK: - Test Duration Parsing
 
     func testParseDurationFromXCTestPassed() {