Fix parameterized test display and group test cases under parent test with proper indentation hierarchy

Author: tienquocbui

Sources/Testing/Events/Recorder/Event.HumanReadableOutputRecorder.swift

@@ -14,6 +14,15 @@ extension Event {
   /// This type encapsulates the logic for collecting failed tests from a test
   /// data graph and formatting them into a human-readable failure summary.
   private struct TestRunSummary: Sendable {
+    /// Information about a single failed test case (for parameterized tests).
+    struct FailedTestCase: Sendable {
+      /// The test case arguments for this parameterized test case.
+      var arguments: String
+
+      /// All issues recorded for this test case.
+      var issues: [HumanReadableOutputRecorder.Context.TestData.IssueInfo]
+    }
+
     /// Information about a single failed test.
     struct FailedTest: Sendable {
       /// The full hierarchical path to the test (e.g., suite names).
@@ -22,29 +31,14 @@ extension Event {
       /// The test's simple name (last component of the path).
       var name: String
 
-      /// All issues recorded for this test.
-      var issues: [IssueInfo]
-
       /// The test's display name, if any.
       var displayName: String?
 
-      /// The test case arguments for parameterized tests, if any.
-      var testCaseArguments: String?
-    }
-
-    /// Information about a single issue within a failed test.
-    struct IssueInfo: Sendable {
-      /// The source location where the issue occurred.
-      var sourceLocation: SourceLocation?
+      /// For non-parameterized tests: issues recorded directly on the test.
+      var issues: [HumanReadableOutputRecorder.Context.TestData.IssueInfo]
 
-      /// A detailed description of what failed.
-      var description: String
-
-      /// Whether this issue is a known issue.
-      var isKnown: Bool
-
-      /// The severity of this issue.
-      var severity: Issue.Severity
+      /// For parameterized tests: test cases with their issues.
+      var testCases: [FailedTestCase]
     }
 
     /// The list of failed tests collected from the test run.
@@ -55,62 +49,95 @@ extension Event {
     /// - Parameters:
     ///   - testData: The root test data graph to traverse.
     fileprivate init(from testData: Graph<HumanReadableOutputRecorder.Context.TestDataKey, HumanReadableOutputRecorder.Context.TestData?>) {
-      var collected: [FailedTest] = []
+      var testMap: [String: FailedTest] = [:]
 
       // Traverse the graph to find all tests with failures
-      func traverse(graph: Graph<HumanReadableOutputRecorder.Context.TestDataKey, HumanReadableOutputRecorder.Context.TestData?>, path: [String]) {
+      func traverse(graph: Graph<HumanReadableOutputRecorder.Context.TestDataKey, HumanReadableOutputRecorder.Context.TestData?>, path: [String], isTestCase: Bool = false) {
         // Check if this node has test data with failures
         if let testData = graph.value, !testData.issues.isEmpty {
           let testName = path.last ?? "Unknown"
 
-          // Convert Context.TestData.IssueInfo to TestRunSummary.IssueInfo
-          let issues = testData.issues.map { issue in
-            IssueInfo(
-              sourceLocation: issue.sourceLocation,
-              description: issue.description,
-              isKnown: issue.isKnown,
-              severity: issue.severity
+          // Use issues directly from testData
+          let issues = testData.issues
+
+          if isTestCase {
+            // This is a test case node - add it to the parent test's testCases array
+            // The parent test path is the path without the test case ID component
+            let parentPath = path.filter { !$0.hasPrefix("arguments:") }
+            let parentPathKey = parentPath.joined(separator: "/")
+
+            if var parentTest = testMap[parentPathKey] {
+              // Add this test case to the parent
+              if let arguments = testData.testCaseArguments, !arguments.isEmpty {
+                parentTest.testCases.append(FailedTestCase(
+                  arguments: arguments,
+                  issues: issues
+                ))
+                testMap[parentPathKey] = parentTest
+              }
+            } else {
+              // Parent test not found in map, but should exist - create it
+              let parentTest = FailedTest(
+                path: parentPath,
+                name: parentPath.last ?? "Unknown",
+                displayName: testData.displayName,
+                issues: [],
+                testCases: (testData.testCaseArguments?.isEmpty ?? true) ? [] : [FailedTestCase(
+                  arguments: testData.testCaseArguments ?? "",
+                  issues: issues
+                )]
+              )
+              testMap[parentPathKey] = parentTest
+            }
+          } else {
+            // This is a test node (not a test case)
+            let pathKey = path.joined(separator: "/")
+            let failedTest = FailedTest(
+              path: path,
+              name: testName,
+              displayName: testData.displayName,
+              issues: issues,
+              testCases: []
             )
+            testMap[pathKey] = failedTest
           }
-
-          collected.append(FailedTest(
-            path: path,
-            name: testName,
-            issues: issues,
-            displayName: testData.displayName,
-            testCaseArguments: testData.testCaseArguments
-          ))
         }
 
         // Recursively traverse children
         for (key, childGraph) in graph.children {
           let pathComponent: String?
+          let isChildTestCase: Bool
           switch key {
           case let .string(s):
             let parts = s.split(separator: ":")
             if s.hasSuffix(".swift:") || (parts.count >= 2 && parts[0].hasSuffix(".swift")) {
               pathComponent = nil // Filter out source location strings
+              isChildTestCase = false
             } else {
               pathComponent = s
+              isChildTestCase = false
             }
           case let .testCaseID(id):
             // Only include parameterized test case IDs in path
             if let argumentIDs = id.argumentIDs, let discriminator = id.discriminator {
               pathComponent = "arguments: \(argumentIDs), discriminator: \(discriminator)"
+              isChildTestCase = true
             } else {
               pathComponent = nil // Filter out non-parameterized test case IDs
+              isChildTestCase = false
             }
           }
 
           let newPath = pathComponent.map { path + [$0] } ?? path
-          traverse(graph: childGraph, path: newPath)
+          traverse(graph: childGraph, path: newPath, isTestCase: isChildTestCase)
         }
       }
 
       // Start traversal from root
       traverse(graph: testData, path: [])
 
-      self.failedTests = collected
+      // Convert map to array, ensuring we only include tests that have failures
+      self.failedTests = Array(testMap.values).filter { !$0.issues.isEmpty || !$0.testCases.isEmpty }
     }
 
     /// Generate a formatted failure summary string.
@@ -145,7 +172,13 @@ extension Event {
     /// - Returns: A string containing the header line.
     private func header() -> String {
       let failedTestsPhrase = failedTests.count.counting("test")
-      let totalIssuesCount = failedTests.reduce(0) { $0 + $1.issues.count }
+      var totalIssuesCount = 0
+      for test in failedTests {
+        totalIssuesCount += test.issues.count
+        for testCase in test.testCases {
+          totalIssuesCount += testCase.issues.count
+        }
+      }
       let issuesPhrase = totalIssuesCount.counting("issue")
       return "Test run had \(failedTestsPhrase) which recorded \(issuesPhrase) total:\n"
     }
@@ -166,14 +199,21 @@ extension Event {
 
       result += "\(symbol) \(fullyQualifiedName)\n"
 
-      // Show test case arguments for parameterized tests (once per test)
-      if let arguments = failedTest.testCaseArguments, !arguments.isEmpty {
-        result += "  (\(arguments))\n"
-      }
-
-      // List each issue for this test with indentation
-      for issue in failedTest.issues {
-        result += formatIssue(issue)
+      // For parameterized tests: show test cases grouped under the parent test
+      if !failedTest.testCases.isEmpty {
+        for testCase in failedTest.testCases {
+          // Show test case arguments with additional indentation
+          result += "  (\(testCase.arguments))\n"
+          // List each issue for this test case with additional indentation
+          for issue in testCase.issues {
+            result += formatIssue(issue, indentLevel: 2)
+          }
+        }
+      } else {
+        // For non-parameterized tests: show issues directly
+        for issue in failedTest.issues {
+          result += formatIssue(issue)
+        }
       }
 
       return result
@@ -185,31 +225,39 @@ extension Event {
     ///   - failedTest: The failed test.
     ///
     /// - Returns: The fully qualified name, with display name substituted if
-    ///   available.
+    ///   available. Test case ID components are filtered out since they're
+    ///   shown separately.
     private func fullyQualifiedName(for failedTest: FailedTest) -> String {
       // Omit the leading path component representing the module name from the
       // fully-qualified name of the test.
-      let path = failedTest.path.dropFirst()
+      var path = Array(failedTest.path.dropFirst())
 
-      // Use display name for the last component if available. Otherwise, join
-      // the path components.
-      return if let displayName = failedTest.displayName, !failedTest.path.isEmpty {
-        (path.dropLast() + [#""\#(displayName)""#]).joined(separator: "/")
-      } else {
-        path.joined(separator: "/")
+      // Filter out test case ID components (they're shown separately with arguments)
+      path = path.filter { !$0.hasPrefix("arguments:") }
+
+      // If we have a display name, replace the function name component (which is
+      // now the last component after filtering) with the display name. This avoids
+      // showing both the function name and display name.
+      if let displayName = failedTest.displayName, !path.isEmpty {
+        path[path.count - 1] = #""\#(displayName)""#
       }
+
+      return path.joined(separator: "/")
     }
 
     /// Format a single issue entry.
     ///
     /// - Parameters:
     ///   - issue: The issue to format.
+    ///   - indentLevel: The number of indentation levels (each level is 2 spaces).
+    ///     Defaults to 1.
     ///
     /// - Returns: A formatted string representing the issue with indentation.
-    private func formatIssue(_ issue: IssueInfo) -> String {
-      var result = "  - \(issue.description)\n"
+    private func formatIssue(_ issue: HumanReadableOutputRecorder.Context.TestData.IssueInfo, indentLevel: Int = 1) -> String {
+      let indent = String(repeating: "  ", count: indentLevel)
+      var result = "\(indent)- \(issue.description)\n"
       if let location = issue.sourceLocation {
-        result += "      at \(location)\n"
+        result += "\(indent)    at \(location)\n"
       }
       return result
     }