Review feedback

Author: harlanhaskins

Sources/Testing/ABI/Encoded/ABI.EncodedEvent.swift

@@ -117,6 +117,9 @@ extension ABI {
       case .testStarted:
         kind = .testStarted
       case .testCaseStarted:
+        // For non-parameterized tests, we elide `testCaseStarted` calls because it would be
+        // redundant. However, for multiple iterations of a test case within a non-parameterized
+        // function, we need to emit another `testStarted` event.
         if eventContext.test?.isParameterized == false {
           if let iteration = eventContext.iteration, iteration > 1 {
             kind = .testStarted

Sources/Testing/ABI/EntryPoints/EntryPoint.swift

@@ -333,6 +333,7 @@ public struct __CommandLineArguments_v0: Sendable {
   /// The value of the `--repeat-until` argument.
   public var repeatUntil: String?
 
+  /// Whether or not to use the per-test-case repetition mode.
   var usePerTestCaseRepetition: Bool = false
 
   /// The value of the `--attachments-path` argument.

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

@@ -572,16 +572,13 @@ extension Event.HumanReadableOutputRecorder {
       guard let test, let testCase else { break }
       let iteration = eventContext.iteration ?? 1
 
-      let shouldShowMessage = testCase.isParameterized || iteration > 1
-
-      guard shouldShowMessage else {
-        break
-      }
-
-      var message = if testCase.isParameterized, let arguments = testCase.arguments {
-        "Test case passing \(arguments.count.counting("argument")) \(testCase.labeledArguments(includingQualifiedTypeNames: verbosity > 0)) to \(testName) started"
+      var message: String
+      if testCase.isParameterized, let arguments = testCase.arguments {
+        message = "Test case passing \(arguments.count.counting("argument")) \(testCase.labeledArguments(includingQualifiedTypeNames: verbosity > 0)) to \(testName) started"
+      } else if iteration > 1 {
+        message = testStartedMessage(for: test)
       } else {
-        testStartedMessage(for: test)
+        break
       }
 
       if iteration > 1 {

Sources/Testing/Running/Configuration.swift

@@ -134,6 +134,7 @@ public struct Configuration: Sendable {
 
   /// Whether to perform test repetition at the plan level or on a per-test-
   /// case basis.
+  @_spi(Experimental)
   public var shouldUseLegacyPlanLevelRepetition: Bool = true
 
   /// Whether or not, and how, to iterate the test plan repeatedly.

Sources/Testing/Running/Runner.RuntimeState.swift

@@ -29,7 +29,7 @@ extension Runner {
     /// The test case that is running on the current task, if any.
     var testCase: Test.Case?
 
-    /// The current iteration of the test repetition policy.
+    /// The current iteration of the test repetition policy, if any.
     var iteration: Int?
 
     /// The runtime state related to the runner running on the current task,
@@ -201,7 +201,7 @@ extension Configuration {
   }
 }
 
-// MARK: - Current test and test case
+// MARK: - Current test, test case, and iteration
 
 extension Test {
   /// The test that is running on the current task, if any.
@@ -237,6 +237,7 @@ extension Test {
     }
   }
 
+  /// The current iteration of the currently-running test case, if any.
   static var currentIteration: Int? {
     Runner.RuntimeState.current?.iteration
   }

Sources/Testing/Running/Runner.swift

@@ -385,9 +385,9 @@ extension Runner {
       if let testCaseSerializer = context.testCaseSerializer {
         // Note that if .serialized is applied to an inner scope, we still use
         // this serializer (if set) so that we don't overcommit.
-        await testCaseSerializer.run { await _runTestCase(testCase, within: step, context: context) }
+        await testCaseSerializer.run { await _runTestCase(testCase, within: step) }
       } else {
-        await _runTestCase(testCase, within: step, context: context)
+        await _runTestCase(testCase, within: step)
       }
     }
   }
@@ -402,8 +402,7 @@ extension Runner {
   /// body closure.
   private static func _runTestCase(
     _ testCase: Test.Case,
-    within step: Plan.Step,
-    context: _Context
+    within step: Plan.Step
   ) async {
     if _configuration.shouldUseLegacyPlanLevelRepetition {
       await _runSingleTestCaseIteration(testCase, within: step)
@@ -456,8 +455,6 @@ extension Runner {
   /// repeatedly until the continuation condition is satisfied.
   ///
   /// - Parameters:
-  ///   - test: The test being executed.
-  ///   - testCase: The test case being iterated.
   ///   - body: The actual body of the function which must ultimately call into the test function.
   ///
   /// - Note: This function updates ``Configuration/current`` before invoking the test body.
@@ -554,15 +551,15 @@ extension Runner {
           defer {
             Event.post(.iterationEnded(iterationIndex), configuration: runner.configuration)
           }
-          await runner.runAll(context: context)
+          await runner._runAllTests(context: context)
         }
       } else {
-        await runner.runAll(context: context)
+        await runner._runAllTests(context: context)
       }
     }
   }
 
-  private func runAll(context: _Context) async {
+  private func _runAllTests(context: _Context) async {
     await withTaskGroup { taskGroup in
       _ = taskGroup.addTaskUnlessCancelled(name: decorateTaskName("test run", withAction: nil)) {
         try? await Self._runStep(atRootOf: plan.stepGraph, context: context)

Tests/TestingTests/TestCaseIterationTests.swift

@@ -1,7 +1,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2024 Apple Inc. and the Swift project authors
+// Copyright (c) 2026 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information