Show the number of test cases that ran at the end of a test

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

@@ -62,6 +62,9 @@ extension Event {
 
         /// The number of known issues recorded for the test.
         var knownIssueCount = 0
+
+        /// The number of test cases for the test.
+        var testCasesCount: Int = 0
       }
 
       /// Data tracked on a per-test basis.
@@ -146,6 +149,29 @@ extension Event.HumanReadableOutputRecorder {
 
     return (errorIssueCount, warningIssueCount, knownIssueCount, totalIssueCount,  description)
   }
+
+  /// Returns a formatted string describing the number of arguments in a test,
+  /// based on verbosity level.
+  ///
+  /// - Parameters:
+  ///   - isParameterized: To check test cases count should be included.
+  ///   - count: The number of test cases in the test.
+  ///   - verbosity: The verbosity level. If it's very verbose or higher,
+  ///     the test cases count might get included.
+  ///
+  ///
+  /// - Returns: A string describing the number of test cases in the test,
+  ///   or an empty string if it's not very verbose level.
+  ///
+  private func _includeNumberOfTestCasesIfNeeded(
+      _ isParameterized: Bool,
+      count testCasesCount: Int,
+      verbosity verbose: Int
+  ) -> String {
+    guard verbose >= 2, isParameterized else { return "" }
+    return " with \(testCasesCount.counting("test case"))"
+  }
+
 }
 
 /// Generate a title for the specified test (either "Test" or "Suite"),
@@ -281,6 +307,18 @@ extension Event.HumanReadableOutputRecorder {
           testData.issueCount[issue.severity] = issueCount + 1
         }
         context.testData[id] = testData
+
+      case .testCaseStarted:
+        guard verbosity >= 2 else { break }
+        let id: [String] = if let test {
+          test.id.keyPathRepresentation
+        } else {
+          []
+        }
+        var testData = context.testData[id] ?? .init(startInstant: instant)
+        testData.testCasesCount += 1
+        context.testData[id] = testData
+
 
       default:
         // These events do not manipulate the context structure.
@@ -366,18 +404,21 @@ extension Event.HumanReadableOutputRecorder {
       let testData = testDataGraph?.value ?? .init(startInstant: instant)
       let issues = _issueCounts(in: testDataGraph)
       let duration = testData.startInstant.descriptionOfDuration(to: instant)
+      let testCasesCountMessage = _includeNumberOfTestCasesIfNeeded(test.isParameterized,
+                                                                    count: testData.testCasesCount,
+                                                                    verbosity: verbosity)
       return if issues.errorIssueCount > 0 {
         CollectionOfOne(
           Message(
             symbol: .fail,
-            stringValue: "\(_capitalizedTitle(for: test)) \(testName) failed after \(duration)\(issues.description)."
+            stringValue: "\(_capitalizedTitle(for: test)) \(testName)\(testCasesCountMessage) failed after \(duration)\(issues.description)."
           )
         ) + _formattedComments(for: test)
       } else {
         [
           Message(
             symbol: .pass(knownIssueCount: issues.knownIssueCount),
-            stringValue: "\(_capitalizedTitle(for: test)) \(testName) passed after \(duration)\(issues.description)."
+            stringValue: "\(_capitalizedTitle(for: test)) \(testName)\(testCasesCountMessage) passed after \(duration)\(issues.description)."
           )
         ]
       }

Tests/TestingTests/EventRecorderTests.swift

@@ -178,6 +178,45 @@ struct EventRecorderTests {
         .first != nil
     )
   }
+
+  @available(_regexAPI, *)
+  @Test(
+    "number of arguments based on verbosity level at the end of test run",
+    arguments: [
+      ("f()", #".* Test f\(\) failed after .*"# ,  0),
+      ("f()", #".* Test f\(\) failed after .*"# ,  2),
+      ("d(_:)", #".* Test d\(_:\) with .+ test cases passed after.*"# , 2),
+      ("PredictablyFailingTests", #".* Suite PredictablyFailingTests failed after .*"# , 1),
+      ("PredictablyFailingTests", #".* Suite PredictablyFailingTests failed after .*"# , 2),
+    ]
+  )
+  func numberOfArgumentsAtTheEndOfTests(testName: String, expectedPattern: String, verbosity: Int) async throws {
+    let stream = Stream()
+
+    var configuration = Configuration()
+    let eventRecorder = Event.ConsoleOutputRecorder(writingUsing: stream.write)
+    configuration.eventHandler = { event, context in
+      eventRecorder.record(event, in: context)
+    }
+    configuration.verbosity = verbosity
+
+    await runTest(for: PredictablyFailingTests.self, configuration: configuration)
+
+    let buffer = stream.buffer.rawValue
+    if testsWithSignificantIOAreEnabled {
+      print(buffer, terminator: "")
+    }
+
+    let aurgmentRegex = try Regex(expectedPattern)
+
+    #expect(
+      (try buffer
+        .split(whereSeparator: \.isNewline)
+        .compactMap(aurgmentRegex.wholeMatch(in:))
+        .first) != nil
+    )
+  }
+
 
   @available(_regexAPI, *)
   @Test(
@@ -536,6 +575,11 @@ struct EventRecorderTests {
       #expect(Bool(false))
     }
   }
+
+  @Test(.hidden, arguments: [1, 2, 3])
+  func d(_ arg: Int) {
+    #expect(arg > 0)
+  }
 
   @Test(.hidden) func g() {
     #expect(Bool(false))
@@ -566,3 +610,4 @@ struct EventRecorderTests {
     }
   }
 }
+