[test] checkHashable: Check that unequal values produce different hashes

This is safe to do with hash(into:), because random hash collisions can be eliminated with awesome certainty by trying a number of different hash seeds. (Unless there is a weakness in SipHash.)

In some cases, we intentionally want hashing to produce looser equivalency classes than equality — to let those cases keep working, add an optional hashEqualityOracle parameter.

Review usages of checkHashable and add hash oracles as needed.

Author: lorentey

stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb

@@ -2095,17 +2095,43 @@ public func checkEquatable<T : Equatable>(
     oracle: { expectedEqual || $0 == $1 }, ${trace}, showFrame: false)
 }
 
+internal func hash<H: Hashable>(_ value: H, seed: Int? = nil) -> Int {
+  var hasher = _Hasher()
+  if let seed = seed {
+    hasher.combine(seed)
+  }
+  hasher.combine(value)
+  return hasher.finalize()
+}
+
+/// Test that the elements of `instances` satisfy the semantic requirements of
+/// `Hashable`, using `equalityOracle` to generate equality and hashing
+/// expectations from pairs of positions in `instances`.
+public func checkHashable<Instances: Collection>(
+  _ instances: Instances,
+  equalityOracle: (Instances.Index, Instances.Index) -> Bool,
+  allowBrokenTransitivity: Bool = false,
+  ${TRACE}
+) where Instances.Iterator.Element: Hashable {
+  checkHashable(
+    instances,
+    equalityOracle: equalityOracle,
+    hashEqualityOracle: equalityOracle,
+    allowBrokenTransitivity: allowBrokenTransitivity,
+    ${trace})
+}
+
 /// Test that the elements of `instances` satisfy the semantic
 /// requirements of `Hashable`, using `equalityOracle` to generate
-/// equality expectations from pairs of positions in `instances`.
-public func checkHashable<Instances : Collection>(
+/// equality expectations from pairs of positions in `instances`,
+/// and `hashEqualityOracle` to do the same for hashing.
+public func checkHashable<Instances: Collection>(
   _ instances: Instances,
   equalityOracle: (Instances.Index, Instances.Index) -> Bool,
+  hashEqualityOracle: (Instances.Index, Instances.Index) -> Bool,
   allowBrokenTransitivity: Bool = false,
   ${TRACE}
-) where
-  Instances.Iterator.Element : Hashable {
-
+) where Instances.Iterator.Element: Hashable {
   checkEquatable(
     instances,
     oracle: equalityOracle,
@@ -2116,11 +2142,55 @@ public func checkHashable<Instances : Collection>(
     let x = instances[i]
     for j in instances.indices {
       let y = instances[j]
+      let predicted = hashEqualityOracle(i, j)
+      expectEqual(
+        predicted, hashEqualityOracle(j, i),
+        "bad hash oracle: broken symmetry between indices \(i), \(j)",
+        stackTrace: ${stackTrace})
       if x == y {
+        expectTrue(
+          predicted,
+          """
+          bad hash oracle: equality must imply hash equality
+          lhs (at index \(i)): \(x)\nrhs (at index \(j)): \(y)
+          """,
+          stackTrace: ${stackTrace})
+      }
+      if predicted {
+        expectEqual(
+          hash(x), hash(y),
+          "hash(into:) expected to match, found to differ\n" +
+          "lhs (at index \(i)): \(x)\nrhs (at index \(j)): \(y)",
+          stackTrace: ${stackTrace})
         expectEqual(
           x.hashValue, y.hashValue,
+          "hashValue expected to match, found to differ\n" +
           "lhs (at index \(i)): \(x)\nrhs (at index \(j)): \(y)",
           stackTrace: ${stackTrace})
+        expectEqual(
+          x._unsafeHashValue(), y._unsafeHashValue(),
+          "_unsafeHashValue() expected to match, found to differ\n" +
+          "lhs (at index \(i)): \(x)\nrhs (at index \(j)): \(y)",
+          stackTrace: ${stackTrace})
+      } else {
+        // Try a few different seeds; one of them must discriminate
+        // between the hashes.
+        var pass = false
+        for s in 0..<10 {
+          if hash(x, seed: s) != hash(y, seed: s) {
+            // Triggers on first iteration in most cases.
+            pass = true
+            break
+          }
+        }
+        if !pass {
+          expectTrue(
+            AssertionResult(isPass: pass)
+              .withDescription(
+                "_hash(into:) expected to differ, found to match"),
+            "lhs (at index \(i)): \(x)\nrhs (at index \(j)): \(y)",
+            stackTrace: ${stackTrace})
+        }
       }
     }
   }

validation-test/stdlib/AnyHashable.swift.gyb

@@ -175,7 +175,13 @@ AnyHashableTests.test("AnyHashable(mixed minimal hashables)/Hashable") {
 %   end
 % end
 
-  checkHashable(xs, equalityOracle: { $0 / 2 == $1 / 2 })
+  checkHashable(
+    xs,
+    equalityOracle: { $0 / 2 == $1 / 2 },
+    // FIXME: Types that hash the same way will produce hash collisions when
+    // converted to AnyHashable. Arguably, the type id should be used as a hash
+    // discriminator.
+    hashEqualityOracle: { $0 / 2 % 6 == $1 / 2 % 6 })
 }
 
 % for (kw, name) in [
@@ -575,18 +581,27 @@ let interestingBitVectorArrays: [[UInt8]] = [
 AnyHashableTests.test("AnyHashable(CFBitVector)/Hashable, .base") {
   let bitVectors: [CFBitVector] =
     interestingBitVectorArrays.map(CFBitVector.makeImmutable)
+  let hashEqualityOracle: (Int, Int) -> Bool = {
+    // CFBitVector returns its count as the hash.
+    interestingBitVectorArrays[$0].count == interestingBitVectorArrays[$1].count
+  }
   let arrays = bitVectors.map { $0.asArray }
   func isEq(_ lhs: [[UInt8]], _ rhs: [[UInt8]]) -> Bool {
     return zip(lhs, rhs).map { $0 == $1 }.reduce(true, { $0 && $1 })
   }
   expectEqualTest(interestingBitVectorArrays, arrays, sameValue: isEq)
-  checkHashable(bitVectors, equalityOracle: { $0 == $1 })
+  checkHashable(
+    bitVectors,
+    equalityOracle: { $0 == $1 },
+    hashEqualityOracle: hashEqualityOracle)
 
   do {
     expectEqual(.foreignClass, SwiftRuntime.metadataKind(of: bitVectors.first!))
 
     let anyHashables = bitVectors.map(AnyHashable.init)
-    checkHashable(anyHashables, equalityOracle: { $0 == $1 })
+    checkHashable(anyHashables,
+      equalityOracle: { $0 == $1 },
+      hashEqualityOracle: hashEqualityOracle)
 
     let v = anyHashables.first!.base
     expectTrue(type(of: v) is CFBitVector.Type)
@@ -600,7 +615,9 @@ AnyHashableTests.test("AnyHashable(CFBitVector)/Hashable, .base") {
       SwiftRuntime.metadataKind(of: bitVectorsAsAnyObjects.first!))
 
     let anyHashables = bitVectorsAsAnyObjects.map(AnyHashable.init)
-    checkHashable(anyHashables, equalityOracle: { $0 == $1 })
+    checkHashable(anyHashables,
+      equalityOracle: { $0 == $1 },
+      hashEqualityOracle: hashEqualityOracle)
 
     let v = anyHashables.first!.base
     expectTrue(type(of: v) is CFBitVector.Type)
@@ -612,20 +629,30 @@ AnyHashableTests.test("AnyHashable(CFMutableBitVector)/Hashable, .base") {
   // CFBitVector.
   let bitVectors: [CFMutableBitVector] =
     interestingBitVectorArrays.map(CFMutableBitVector.makeMutable)
+  let hashEqualityOracle: (Int, Int) -> Bool = {
+    // CFBitVector returns its count as the hash.
+    interestingBitVectorArrays[$0].count == interestingBitVectorArrays[$1].count
+  }
   let arrays = bitVectors.map { $0.asArray }
   func isEq(_ lhs: [[UInt8]], _ rhs: [[UInt8]]) -> Bool {
     return zip(lhs, rhs).map { $0 == $1 }.reduce(true, { $0 && $1 })
   }
   expectEqualTest(interestingBitVectorArrays, arrays, sameValue: isEq)
-  checkHashable(bitVectors, equalityOracle: { $0 == $1 })
+  checkHashable(
+    bitVectors,
+    equalityOracle: { $0 == $1 },
+    hashEqualityOracle: hashEqualityOracle)
 
   do {
     expectEqual(
       .foreignClass,
       SwiftRuntime.metadataKind(of: bitVectors.first!))
 
     let anyHashables = bitVectors.map(AnyHashable.init)
-    checkHashable(anyHashables, equalityOracle: { $0 == $1 })
+    checkHashable(
+      anyHashables,
+      equalityOracle: { $0 == $1 },
+      hashEqualityOracle: hashEqualityOracle)
 
     let v = anyHashables.first!.base
     expectTrue(type(of: v) is CFMutableBitVector.Type)
@@ -634,14 +661,20 @@ AnyHashableTests.test("AnyHashable(CFMutableBitVector)/Hashable, .base") {
     let bitVectorsAsAnyObjects: [NSObject] = bitVectors.map {
       ($0 as AnyObject) as! NSObject
     }
-    checkHashable(bitVectorsAsAnyObjects, equalityOracle: { $0 == $1 })
+    checkHashable(
+      bitVectorsAsAnyObjects,
+      equalityOracle: { $0 == $1 },
+      hashEqualityOracle: hashEqualityOracle)
 
     expectEqual(
       .objCClassWrapper,
       SwiftRuntime.metadataKind(of: bitVectorsAsAnyObjects.first!))
 
     let anyHashables = bitVectorsAsAnyObjects.map(AnyHashable.init)
-    checkHashable(anyHashables, equalityOracle: { $0 == $1 })
+    checkHashable(
+      anyHashables,
+      equalityOracle: { $0 == $1 },
+      hashEqualityOracle: hashEqualityOracle)
 
     let v = anyHashables.first!.base
     expectTrue(type(of: v) is CFMutableBitVector.Type)
@@ -717,10 +750,14 @@ AnyHashableTests.test("AnyHashable(MinimalHashableRCSwiftError)/Hashable") {
     .caseC(LifetimeTracked(2)), .caseC(LifetimeTracked(2)),
   ]
   expectEqual(.enum, SwiftRuntime.metadataKind(of: xs.first!))
-  checkHashable(xs, equalityOracle: { $0 / 2 == $1 / 2 })
+  checkHashable(
+    xs,
+    equalityOracle: { $0 / 2 == $1 / 2 },
+    hashEqualityOracle: { $0 / 4 == $1 / 4 })
   checkHashable(
     xs.map(AnyHashable.init),
-    equalityOracle: { $0 / 2 == $1 / 2 })
+    equalityOracle: { $0 / 2 == $1 / 2 },
+    hashEqualityOracle: { $0 / 4 == $1 / 4 })
 }
 
 AnyHashableTests.test("AnyHashable(MinimalHashableRCSwiftError).base") {
@@ -763,8 +800,16 @@ AnyHashableTests.test("AnyHashable(Wrappers)/Hashable") {
     return lhs == rhs
   }
 
-  checkHashable(values, equalityOracle: equalityOracle,
-                allowBrokenTransitivity: true)
+  func hashEqualityOracle(_ lhs: Int, _ rhs: Int) -> Bool {
+    // Elements in [0, 3] hash the same, as do elements in [4, 7].
+    return lhs / 4 == rhs / 4
+  }
+
+  checkHashable(
+    values,
+    equalityOracle: equalityOracle,
+    hashEqualityOracle: hashEqualityOracle,
+    allowBrokenTransitivity: true)
 }
 
 AnyHashableTests.test("AnyHashable(Set)/Hashable") {
@@ -789,8 +834,10 @@ AnyHashableTests.test("AnyHashable(Set)/Hashable") {
     }
   }
 
-  checkHashable(values, equalityOracle: equalityOracle,
-                allowBrokenTransitivity: true)
+  checkHashable(
+    values,
+    equalityOracle: equalityOracle,
+    allowBrokenTransitivity: true)
 }
 
 AnyHashableTests.test("AnyHashable(Array)/Hashable") {
@@ -902,6 +949,12 @@ AnyHashableTests.test("AnyHashable(_SwiftNativeNSError(MinimalHashableRCSwiftErr
     .caseC(LifetimeTracked(1)), .caseC(LifetimeTracked(1)),
     .caseC(LifetimeTracked(2)), .caseC(LifetimeTracked(2)),
   ]
+  checkHashable(
+    swiftErrors,
+    equalityOracle: { $0 / 2 == $1 / 2 },
+    hashEqualityOracle: { $0 / 4 == $1 / 4 },
+    allowBrokenTransitivity: false)
+
   let nsErrors: [NSError] = swiftErrors.flatMap {
     swiftError -> [NSError] in
     let bridgedNSError = swiftError as NSError
@@ -938,16 +991,23 @@ AnyHashableTests.test("AnyHashable(_SwiftNativeNSError(MinimalHashableRCSwiftErr
     return false
   }
 
+  func hashEqualityOracle(_ lhs: Int, _ rhs: Int) -> Bool {
+    // Every NSError that has the same domain and code hash the same way.
+    return lhs / 8 == rhs / 8
+  }
+
   // FIXME: transitivity is broken because pure `NSError`s can compare equal to
   // Swift errors with payloads just based on the domain and code, and Swift
   // errors with payloads don't compare equal when payloads differ.
   checkHashable(
     nsErrors,
     equalityOracle: equalityOracle,
+    hashEqualityOracle: hashEqualityOracle,
     allowBrokenTransitivity: true)
   checkHashable(
     nsErrors.map(AnyHashable.init),
     equalityOracle: equalityOracle,
+    hashEqualityOracle: hashEqualityOracle,
     allowBrokenTransitivity: true)
 
   // FIXME(id-as-any): run `checkHashable` on an array of mixed