Represent non-encodable test argument values in Test.Case.ID

Sources/Testing/ABI/Encoded/ABI.EncodedTest.swift

@@ -124,9 +124,13 @@ extension ABI {
     var displayName: String
 
     init(encoding testCase: borrowing Test.Case) {
+      guard let arguments = testCase.arguments else {
+        preconditionFailure("Attempted to initialize an EncodedTestCase encoding a test case which is not parameterized: \(testCase). Please file a bug report at https://github.com/swiftlang/swift-testing/issues/new")
+      }
+
       // TODO: define an encodable form of Test.Case.ID
       id = String(describing: testCase.id)
-      displayName = testCase.arguments.lazy
+      displayName = arguments.lazy
         .map(\.value)
         .map(String.init(describingForTest:))
         .joined(separator: ", ")

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

@@ -171,8 +171,14 @@ extension Test.Case {
   /// - Parameters:
   ///   - includeTypeNames: Whether the qualified type name of each argument's
   ///     runtime type should be included. Defaults to `false`.
+  ///
+  /// - Returns: A string containing the arguments of this test case formatted
+  ///   for presentation, or an empty string if this test cases is
+  ///   non-parameterized.
   fileprivate func labeledArguments(includingQualifiedTypeNames includeTypeNames: Bool = false) -> String {
-    arguments.lazy
+    guard let arguments else { return "" }
+
+    return arguments.lazy
       .map { argument in
         let valueDescription = String(describingForTest: argument.value)
 
@@ -494,14 +500,14 @@ extension Event.HumanReadableOutputRecorder {
       return result
 
     case .testCaseStarted:
-      guard let testCase = eventContext.testCase, testCase.isParameterized else {
+      guard let testCase = eventContext.testCase, testCase.isParameterized, let arguments = testCase.arguments else {
         break
       }
 
       return [
         Message(
           symbol: .default,
-          stringValue: "Passing \(testCase.arguments.count.counting("argument")) \(testCase.labeledArguments(includingQualifiedTypeNames: verbosity > 0)) to \(testName)"
+          stringValue: "Passing \(arguments.count.counting("argument")) \(testCase.labeledArguments(includingQualifiedTypeNames: verbosity > 0)) to \(testName)"
         )
       ]
 

Sources/Testing/Parameterization/CustomTestArgumentEncodable.swift

@@ -43,50 +43,76 @@ public protocol CustomTestArgumentEncodable: Sendable {
   func encodeTestArgument(to encoder: some Encoder) throws
 }
 
+/// Get the best encodable representation of a test argument value, if any.
+///
+/// - Parameters:
+///   - value: The value for which an encodable representation is requested.
+///
+/// - Returns: The best encodable representation of `value`, if one is available,
+///   otherwise `nil`.
+///
+/// For a description of the heuristics used to obtain an encodable
+/// representation of an argument value, see <doc:ParameterizedTesting>.
+func encodableArgumentValue(for value: some Sendable) -> (any Encodable)? {
+#if canImport(Foundation)
+  // Helper for opening an existential.
+  func customArgumentWrapper(for value: some CustomTestArgumentEncodable) -> some Encodable {
+    _CustomArgumentWrapper(rawValue: value)
+  }
+
+  return if let customEncodable = value as? any CustomTestArgumentEncodable {
+    customArgumentWrapper(for: customEncodable)
+  } else if let rawRepresentable = value as? any RawRepresentable, let encodableRawValue = rawRepresentable.rawValue as? any Encodable {
+    encodableRawValue
+  } else if let encodable = value as? any Encodable {
+    encodable
+  } else if let identifiable = value as? any Identifiable, let encodableID = identifiable.id as? any Encodable {
+    encodableID
+  } else {
+    nil
+  }
+#else
+  return nil
+#endif
+}
+
 extension Test.Case.Argument.ID {
   /// Initialize this instance with an ID for the specified test argument.
   ///
   /// - Parameters:
   ///   - value: The value of a test argument for which to get an ID.
+  ///   - encodableValue: An encodable representation of `value`, if any, with
+  ///     which to attempt to encode a stable representation.
   ///   - parameter: The parameter of the test function to which this argument
   ///     value was passed.
   ///
-  /// - Returns: `nil` if an ID cannot be formed from the specified test
-  ///   argument value.
-  ///
-  /// - Throws: Any error encountered while attempting to encode `value`.
+  /// If a representation of `value` can be successfully encoded, the value of
+  /// this instance's `bytes` property will be the the bytes of that encoded
+  /// JSON representation and the value of its `isStable` property will be
+  /// `true`. Otherwise, the value of its `bytes` property will be the bytes of
+  /// a textual description of `value` and the value of `isStable` will be
+  /// `false` to reflect that the representation is not considered stable.
   ///
   /// This function is not part of the public interface of the testing library.
   ///
   /// ## See Also
   ///
   /// - ``CustomTestArgumentEncodable``
-  init?(identifying value: some Sendable, parameter: Test.Parameter) throws {
+  init(identifying value: some Sendable, encodableValue: (any Encodable)?, parameter: Test.Parameter) {
 #if canImport(Foundation)
-    func customArgumentWrapper(for value: some CustomTestArgumentEncodable) -> some Encodable {
-      _CustomArgumentWrapper(rawValue: value)
-    }
-
-    let encodableValue: (any Encodable)? = if let customEncodable = value as? any CustomTestArgumentEncodable {
-      customArgumentWrapper(for: customEncodable)
-    } else if let rawRepresentable = value as? any RawRepresentable, let encodableRawValue = rawRepresentable.rawValue as? any Encodable {
-      encodableRawValue
-    } else if let encodable = value as? any Encodable {
-      encodable
-    } else if let identifiable = value as? any Identifiable, let encodableID = identifiable.id as? any Encodable {
-      encodableID
-    } else {
-      nil
-    }
-
-    guard let encodableValue else {
-      return nil
+    if let encodableValue {
+      do {
+        self = .init(bytes: try Self._encode(encodableValue, parameter: parameter), isStable: true)
+        return
+      } catch {
+        // FIXME: Capture the error and propagate to the user, not as a test
+        // failure but as an advisory warning. A missing argument ID will
+        // prevent re-running the test case, but is not a blocking issue.
+      }
     }
-
-    self = .init(bytes: try Self._encode(encodableValue, parameter: parameter))
-#else
-    nil
 #endif
+
+    self = .init(bytes: String(describingForTest: value).utf8, isStable: false)
   }
 
 #if canImport(Foundation)

Sources/Testing/Parameterization/Test.Case.Generator.swift

@@ -62,7 +62,7 @@ extension Test.Case {
       // A beautiful hack to give us the right number of cases: iterate over a
       // collection containing a single Void value.
       self.init(sequence: CollectionOfOne(())) { _ in
-        Test.Case(arguments: [], body: testFunction)
+        Test.Case(body: testFunction)
       }
     }
 
@@ -257,7 +257,32 @@ extension Test.Case {
 
 extension Test.Case.Generator: Sequence {
   func makeIterator() -> some IteratorProtocol<Test.Case> {
-    _sequence.lazy.map(_mapElement).makeIterator()
+    let state = (
+      iterator: _sequence.makeIterator(),
+      testCaseIDs: [Test.Case.ID: Int](minimumCapacity: underestimatedCount)
+    )
+
+    return sequence(state: state) { state in
+      guard let element = state.iterator.next() else {
+        return nil
+      }
+
+      var testCase = _mapElement(element)
+
+      if testCase.isParameterized {
+        // Store the original, unmodified test case ID. We're about to modify a
+        // property which affects it, and we want to update state based on the
+        // original one.
+        let testCaseID = testCase.id
+
+        // Ensure test cases with identical IDs each have a unique discriminator.
+        let discriminator = state.testCaseIDs[testCaseID, default: 0]
+        testCase.discriminator = discriminator
+        state.testCaseIDs[testCaseID] = discriminator + 1
+      }
+
+      return testCase
+    }
   }
 
   var underestimatedCount: Int {

Sources/Testing/Parameterization/Test.Case.ID.swift

@@ -15,50 +15,116 @@ extension Test.Case {
   /// parameterized test function. They are not necessarily unique across two
   /// different ``Test`` instances.
   @_spi(ForToolsIntegrationOnly)
-  public struct ID: Sendable, Equatable, Hashable {
+  public struct ID: Sendable {
     /// The IDs of the arguments of this instance's associated ``Test/Case``, in
     /// the order they appear in ``Test/Case/arguments``.
     ///
-    /// The value of this property is `nil` if _any_ of the associated test
-    /// case's arguments has a `nil` ID.
+    /// The value of this property is `nil` for the ID of the single test case
+    /// associated with a non-parameterized test function.
     public var argumentIDs: [Argument.ID]?
 
-    public init(argumentIDs: [Argument.ID]?) {
+    /// A number used to distinguish this test case from others associated with
+    /// the same parameterized test function whose arguments have the same ID.
+    ///
+    /// The value of this property is `nil` for the ID of the single test case
+    /// associated with a non-parameterized test function.
+    ///
+    /// ## See Also
+    ///
+    /// - ``Test/Case/discriminator``
+    public var discriminator: Int?
+
+    init(argumentIDs: [Argument.ID]?, discriminator: Int?) {
+      precondition((argumentIDs == nil) == (discriminator == nil))
+
       self.argumentIDs = argumentIDs
+      self.discriminator = discriminator
+    }
+
+    /// Whether or not this test case ID is considered stable across successive
+    /// runs.
+    ///
+    /// The value of this property is `true` if all of the argument IDs for this
+    /// instance are stable, otherwise it is `false`.
+    public var isStable: Bool {
+      (argumentIDs ?? []).allSatisfy(\.isStable)
     }
   }
 
   @_spi(ForToolsIntegrationOnly)
   public var id: ID {
-    let argumentIDs = arguments.compactMap(\.id)
-    guard argumentIDs.count == arguments.count else {
-      return ID(argumentIDs: nil)
-    }
-
-    return ID(argumentIDs: argumentIDs)
+    ID(argumentIDs: arguments.map { $0.map(\.id) }, discriminator: discriminator)
   }
 }
 
 // MARK: - CustomStringConvertible
 
 extension Test.Case.ID: CustomStringConvertible {
   public var description: String {
-    "argumentIDs: \(String(describing: argumentIDs))"
+    if let argumentIDs, let discriminator {
+      "argumentIDs: \(argumentIDs), discriminator: \(discriminator)"
+    } else {
+      "non-parameterized"
+    }
   }
 }
 
 // MARK: - Codable
 
-extension Test.Case.ID: Codable {}
+extension Test.Case.ID: Codable {
+  public init(from decoder: some Decoder) throws {
+    let container = try decoder.container(keyedBy: CodingKeys.self)
 
-// MARK: - Equatable
+    // The `argumentIDs` property is Optional but the meaning of `nil` has
+    // changed since this type was first introduced: it now identifies a
+    // non-parameterized test case, whereas it originally identified a
+    // parameterized test case for which one or more arguments could not be
+    // encoded. If it's present in the decoding container, accept whatever value
+    // is decoded (which may be `nil`). If it's absent, default to a single
+    // argument ID marked as non-stable to maintain previous behavior.
+    let argumentIDs: [Test.Case.Argument.ID]? = if container.contains(.argumentIDs) {
+      try container.decode(type(of: argumentIDs), forKey: .argumentIDs)
+    } else {
+      [Test.Case.Argument.ID(bytes: [], isStable: false)]
+    }
 
-// We cannot safely implement Equatable for Test.Case because its values are
-// type-erased. It does conform to `Identifiable`, but its ID type is composed
-// of the IDs of its arguments, and those IDs are not always available (for
-// example, if the type of an argument is not Codable). Thus, we cannot check
-// for equality of test cases based on this, because if two test cases had
-// different arguments, but the type of those arguments is not Codable, they
-// both will have a `nil` ID and would incorrectly be considered equal.
-//
-// `Test.Case.ID` is Equatable, however.
+    // The `discriminator` property was added after this type was first
+    // introduced. If it's present in the decoding container, accept whatever
+    // value is decoded (which may be `nil`). If it's absent, default to `nil`
+    // if `argumentIDs` was interpreted as a non-parameterized test above, or
+    // else 0, to maintain previous behavior.
+    let discriminator: Int? = if container.contains(.discriminator) {
+      try container.decode(type(of: discriminator), forKey: .discriminator)
+    } else {
+      if let argumentIDs {
+        argumentIDs.isEmpty ? nil : 0
+      } else {
+        nil
+      }
+    }
+
+    self.init(argumentIDs: argumentIDs, discriminator: discriminator)
+  }
+
+  public func encode(to encoder: some Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+
+    // The `argumentIDs` property is Optional but the meaning of `nil` has
+    // changed since this type was first introduced: it now identifies a
+    // non-parameterized test case, whereas it originally identified a
+    // parameterized test case for which one or more arguments could not be
+    // encoded. Explicitly encode `nil` values here, rather than omitting them,
+    // so that when decoding we can distinguish these two scenarios.
+    try container.encode(argumentIDs, forKey: .argumentIDs)
+
+    // The `discriminator` property was added after this type was first
+    // introduced. Explicitly encode `nil` values here, rather than omitting
+    // them, so that when decoding we can distinguish the older vs. newer
+    // implementations.
+    try container.encode(discriminator, forKey: .discriminator)
+  }
+}
+
+// MARK: - Equatable, Hashable
+
+extension Test.Case.ID: Equatable, Hashable {}