Change Argument.ID.bytes to a SHA256 hash (#1642)

It's wasteful to send the entire JSON content of an argument as the ID
for an argument. Use the SHA256 instead.

### Motivation:

The JSON string for each parameterized test argument can be very large;
for one sample project, each argument was half a kilobyte, multiplied by
~10,000 cases and it starts to add up.

This PR standardizes argument IDs as SHA256 hashes. I considered doing
this only when it would be profitable to do so (e.g. if the JSON
encoding is less than 256 bits), but this makes collisions more likely
since we wouldn't be able to guarantee the distribution of bytes that
SHA256 gives us. But if that's not really a concern, it's easy enough to
only perform this transformation when the encoded input is >32 bytes.

Fixes rdar://118992957

### Modifications:

- Adds a `_TestingUtilities` module and moves SHA256.swift into it
- Imports that from both TestingMacros and Testing
- This required rebuilding it a 2nd time while building TestingMacros in
CMake, which I think is acceptable since it's just one file for now.

### Checklist:

- [x] Code and documentation should follow the style of the [Style
Guide](https://github.com/apple/swift-testing/blob/main/Documentation/StyleGuide.md).
- [x] If public symbols are renamed or modified, DocC references should
be updated.

Author: harlanhaskins

Sources/Testing/CMakeLists.txt

@@ -101,6 +101,7 @@ add_library(Testing
   Support/Graph.swift
   Support/JSON.swift
   Support/Serializer.swift
+  Support/SHA256.swift
   Support/VersionNumber.swift
   Support/Versions.swift
   Discovery+Macro.swift

Sources/Testing/Parameterization/CustomTestArgumentEncodable.swift

@@ -71,7 +71,7 @@ extension Test.Case.Argument.ID {
   init?(identifying value: some Sendable, parameter: Test.Parameter) throws {
 #if canImport(Foundation)
     func customArgumentWrapper(for value: some CustomTestArgumentEncodable) -> some Encodable {
-      _CustomArgumentWrapper(rawValue: value)
+      CustomArgumentWrapper(rawValue: value)
     }
 
     let encodableValue: (any Encodable)? = if let customEncodable = value as? any CustomTestArgumentEncodable {
@@ -110,13 +110,16 @@ extension Test.Case.Argument.ID {
   ///
   /// - Throws: Any error encountered during encoding.
   private static func _encode(_ value: some Encodable, parameter: Test.Parameter) throws -> [UInt8] {
-    try JSON.withEncoding(of: value, userInfo: [._testParameterUserInfoKey: parameter], Array.init)
+    /// The encoded representation of an argument is the SHA256 hash of its Codable JSON representation.
+    try JSON.withEncoding(of: value, userInfo: [._testParameterUserInfoKey: parameter]) { buffer in
+      SHA256.hash(buffer)
+    }
   }
 #endif
 }
 
 /// A encodable type which wraps a ``CustomTestArgumentEncodable`` value.
-private struct _CustomArgumentWrapper<T>: RawRepresentable, Encodable where T: CustomTestArgumentEncodable {
+struct CustomArgumentWrapper<T>: RawRepresentable, Encodable where T: CustomTestArgumentEncodable {
   /// The value this instance wraps, which implements custom test argument
   /// encoding logic.
   var rawValue: T

Sources/Testing/Support/SHA256.swift

@@ -0,0 +1 @@
+../../TestingMacros/Support/SHA256.swift

Sources/TestingMacros/Support/SHA256.swift

@@ -69,62 +69,63 @@ enum SHA256 {
 
   /// Process and compute hash from a block.
   private static func _process(_ block: ArraySlice<UInt8>, hash: inout [UInt32]) {
-
     // Compute message schedule.
-    var W = [UInt32](repeating: 0, count: _konstants.count)
-    for t in 0..<W.count {
-      switch t {
-      case 0...15:
-        let index = block.startIndex.advanced(by: t * 4)
-        // Put 4 bytes in each message.
+    withUnsafeTemporaryAllocation(of: UInt32.self, capacity: _konstants.count) { W in
+      // Load the 16 message words from the block.
+      let base = block.startIndex
+      for t in 0..<16 {
+        let index = base + t * 4
         W[t]  = UInt32(block[index + 0]) << 24
         W[t] |= UInt32(block[index + 1]) << 16
         W[t] |= UInt32(block[index + 2]) << 8
         W[t] |= UInt32(block[index + 3])
-      default:
+      }
+
+      // Extend to 64 words.
+      for t in 16..<64 {
         let σ1 = W[t-2].rotateRight(by: 17) ^ W[t-2].rotateRight(by: 19) ^ (W[t-2] >> 10)
         let σ0 = W[t-15].rotateRight(by: 7) ^ W[t-15].rotateRight(by: 18) ^ (W[t-15] >> 3)
         W[t] = σ1 &+ W[t-7] &+ σ0 &+ W[t-16]
       }
-    }
 
-    var a = hash[0]
-    var b = hash[1]
-    var c = hash[2]
-    var d = hash[3]
-    var e = hash[4]
-    var f = hash[5]
-    var g = hash[6]
-    var h = hash[7]
-
-    // Run the main algorithm.
-    for t in 0..<_konstants.count {
-      let Σ1 = e.rotateRight(by: 6) ^ e.rotateRight(by: 11) ^ e.rotateRight(by: 25)
-      let ch = (e & f) ^ (~e & g)
-      let t1 = h &+ Σ1 &+ ch &+ _konstants[t] &+ W[t]
-
-      let Σ0 = a.rotateRight(by: 2) ^ a.rotateRight(by: 13) ^ a.rotateRight(by: 22)
-      let maj = (a & b) ^ (a & c) ^ (b & c)
-      let t2 = Σ0 &+ maj
-
-      h = g
-      g = f
-      f = e
-      e = d &+ t1
-      d = c
-      c = b
-      b = a
-      a = t1 &+ t2
-    }
+      var a = hash[0]
+      var b = hash[1]
+      var c = hash[2]
+      var d = hash[3]
+      var e = hash[4]
+      var f = hash[5]
+      var g = hash[6]
+      var h = hash[7]
+
+      // Run the main algorithm.
+      for t in 0..<_konstants.count {
+        let Σ1 = e.rotateRight(by: 6) ^ e.rotateRight(by: 11) ^ e.rotateRight(by: 25)
+        let ch = (e & f) ^ (~e & g)
+        let t1 = h &+ Σ1 &+ ch &+ _konstants[t] &+ W[t]
+
+        let Σ0 = a.rotateRight(by: 2) ^ a.rotateRight(by: 13) ^ a.rotateRight(by: 22)
+        let maj = (a & b) ^ (a & c) ^ (b & c)
+        let t2 = Σ0 &+ maj
+
+        h = g
+        g = f
+        f = e
+        e = d &+ t1
+        d = c
+        c = b
+        b = a
+        a = t1 &+ t2
+      }
 
-    hash[0] = a &+ hash[0]
-    hash[1] = b &+ hash[1]
-    hash[2] = c &+ hash[2]
-    hash[3] = d &+ hash[3]
-    hash[4] = e &+ hash[4]
-    hash[5] = f &+ hash[5]
-    hash[6] = g &+ hash[6]
-    hash[7] = h &+ hash[7]
+      hash[0] = a &+ hash[0]
+      hash[1] = b &+ hash[1]
+      hash[2] = c &+ hash[2]
+      hash[3] = d &+ hash[3]
+      hash[4] = e &+ hash[4]
+      hash[5] = f &+ hash[5]
+      hash[6] = g &+ hash[6]
+      hash[7] = h &+ hash[7]
+    }
   }
 
   /// Pad the given byte array to be a multiple of 512 bits.

Tests/TestingTests/SHA256Tests.swift

@@ -0,0 +1,34 @@
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014–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
+// See https://swift.org/CONTRIBUTORS.txt for Swift project authors
+//
+
+#if canImport(CryptoKit)
+
+import CryptoKit
+@testable import Testing
+
+@Suite
+struct SHA256Tests {
+  @Test(arguments: [
+    [],
+    withUnsafeBytes(of: UInt64.random(in: 0 ..< .max), Array.init),
+    Array(0..<20),
+    Array("Hello, world".utf8),
+    Array(#"{"key": "value", "key2": 123, "key3": null}"#.utf8),
+    (0..<1_024).map { _ in .random(in: 0 ..< .max) }
+  ])
+  func matchesCryptoKit(data: [UInt8]) {
+    let expected = CryptoKit::SHA256.hash(data: data)
+    let ours = Testing::SHA256.hash(data)
+
+    #expect(expected == ours, "Data \(data) did not hash to the same value")
+  }
+}
+
+#endif

Tests/TestingTests/Test.Case.Argument.IDTests.swift

@@ -23,13 +23,14 @@ struct Test_Case_Argument_IDTests {
     let arguments = try #require(testCase.arguments)
     #expect(arguments.count == 1)
     let argument = try #require(arguments.first)
-    #expect(String(decoding: argument.id.bytes, as: UTF8.self) == "123")
+    #expect(argument.id.bytes == SHA256.hash("123".utf8))
   }
 
   @Test("One CustomTestArgumentEncodable parameter")
   func oneCustomParameter() async throws {
+    let argumentValue = MyCustomTestArgument(x: 123, y: "abc")
     let test = Test(
-      arguments: [MyCustomTestArgument(x: 123, y: "abc")],
+      arguments: [argumentValue],
       parameters: [Test.Parameter(index: 0, firstName: "value", type: MyCustomTestArgument.self)]
     ) { _ in }
     let testCases = try #require(test.testCases)
@@ -38,10 +39,9 @@ struct Test_Case_Argument_IDTests {
     #expect(arguments.count == 1)
     let argument = try #require(arguments.first)
 #if canImport(Foundation)
-    let decodedArgument = try argument.id.bytes.withUnsafeBufferPointer { argumentID in
-      try JSON.decode(MyCustomTestArgument.self, from: .init(argumentID))
+    try JSON.withEncoding(of: CustomArgumentWrapper(rawValue: argumentValue)) { data in
+      #expect(argument.id.bytes == SHA256.hash(data))
     }
-    #expect(decodedArgument == MyCustomTestArgument(x: 123, y: "abc"))
 #endif
   }
 
@@ -56,7 +56,7 @@ struct Test_Case_Argument_IDTests {
     let arguments = try #require(testCase.arguments)
     #expect(arguments.count == 1)
     let argument = try #require(arguments.first)
-    #expect(String(decoding: argument.id.bytes, as: UTF8.self) == #""abc""#)
+    #expect(argument.id.bytes == SHA256.hash(#""abc""#.utf8))
   }
 
   @Test("One RawRepresentable parameter")
@@ -70,7 +70,7 @@ struct Test_Case_Argument_IDTests {
     let arguments = try #require(testCase.arguments)
     #expect(arguments.count == 1)
     let argument = try #require(arguments.first)
-    #expect(String(decoding: argument.id.bytes, as: UTF8.self) == #""abc""#)
+    #expect(argument.id.bytes == SHA256.hash(#""abc""#.utf8))
   }
 }