Eliminate boilerplate from stdlib tests

Author: gribozavr

Diff for: test/Interpreter/SDK/CoreGraphics_CGFloat.swift

@@ -54,37 +54,12 @@ CGFloatTestSuite.test("initOtherTypesFromCGFloat") {
 }
 
 CGFloatTestSuite.test("comparisons") {
-  let x = 3.14
-  let y = 3.14
-  let z = 2.71
-
-  expectTrue(x == y)
-  expectFalse(x != y)
-  checkHashable(true, x, y)
-
-  expectFalse(x == z)
-  expectTrue(x != z)
-  checkHashable(false, x, z)
-
-  expectFalse(x < z)
-  expectFalse(x <= z)
-  expectTrue(x >= z)
-  expectTrue(x > z)
-  checkComparable(.gt, x, z)
-
-  expectTrue(z < x)
-  expectTrue(z <= x)
-  expectFalse(z >= x)
-  expectFalse(z > x)
-  checkComparable(.lt, z, x)
-
-  expectFalse(x < y)
-  expectTrue(x <= y)
-  expectTrue(x >= y)
-  expectFalse(x > y)
-  checkComparable(.eq, x, y)
-}
+  let instances: [CGFloat] = [ 2.71, 3.14 ]
+
+  checkHashable(instances, equalityOracle: { $0 == $1 })
 
+  checkComparable(instances, oracle: { $0 <=> $1 })
+}
 
 CGFloatTestSuite.test("arithmetic") {
   let x: CGFloat = 0.25

Diff for: test/stdlib/Character.swift

@@ -154,13 +154,7 @@ CharacterTests.test("Hashable") {
     continuingScalars.map { String($0) },
     testCharacters
   ] {
-    for i in characters.indices {
-      for j in characters.indices {
-        var ci = Character(characters[i])
-        var cj = Character(characters[j])
-        checkHashable(i == j, ci, cj, "i=\(i), j=\(j)")
-      }
-    }
+    checkHashable(characters, equalityOracle: { $0 == $1 })
   }
 }
 

Diff for: test/stdlib/UnsafePointer.swift.gyb

@@ -141,13 +141,7 @@ ${SelfName}TestSuite.test("Hashable") {
     ${SelfType}(bitPattern: 0x12345678)!,
     ${SelfType}(bitPattern: 0x87654321 as UInt)!,
   ]
-  for i in ptrs.indices {
-    for j in ptrs.indices {
-      var pi = ptrs[i]
-      var pj = ptrs[j]
-      checkHashable(i == j, pi, pj, "i=\(i), j=\(j)")
-    }
-  }
+  checkHashable(ptrs, equalityOracle: { $0 == $1 })
 }
 
 ${SelfName}TestSuite.test("toInteger") {

Diff for: validation-test/stdlib/ObjectiveC.swift

@@ -29,21 +29,15 @@ class NSObjectWithCustomHashable : NSObject {
 }
 
 ObjectiveCTests.test("NSObject/Hashable") {
-  let objects = [
-    NSObjectWithCustomHashable(value: 10, hashValue: 100),
-    NSObjectWithCustomHashable(value: 10, hashValue: 100),
-    NSObjectWithCustomHashable(value: 20, hashValue: 100),
-    NSObjectWithCustomHashable(value: 30, hashValue: 300),
+  let instances: [(order: Int, object: NSObject)] = [
+    (10, NSObjectWithCustomHashable(value: 10, hashValue: 100)),
+    (10, NSObjectWithCustomHashable(value: 10, hashValue: 100)),
+    (20, NSObjectWithCustomHashable(value: 20, hashValue: 100)),
+    (30, NSObjectWithCustomHashable(value: 30, hashValue: 300)),
   ]
-  for (i, object1) in objects.enumerated() {
-    for (j, object2) in objects.enumerated() {
-      checkHashable(
-        object1._value == object2._value,
-        object1,
-        object2,
-        "i=\(i), j=\(j)")
-    }
-  }
+  checkHashable(
+    instances.map { $0.object },
+    equalityOracle: { instances[$0].order == instances[$1].order })
 }
 
 runAllTests()

Diff for: validation-test/stdlib/Set.swift

@@ -3727,14 +3727,13 @@ SetTestSuite.test("misc") {
 SetTestSuite.test("Hashable") {
   let s1 = Set([1010])
   let s2 = Set([2020])
-  checkHashable(s1 == s2, s1, s2)
+  checkHashable([s1, s2], equalityOracle: { $0 == $1 })
 
   // Explicit types help the type checker quite a bit.
   let ss1 = Set([Set([1010] as [Int]), Set([2020] as [Int]), Set([3030] as [Int])])
   let ss11 = Set([Set([2020] as [Int]), Set([3030] as [Int]), Set([2020] as [Int])])
   let ss2 = Set([Set([9090] as [Int])])
-  checkHashable(ss1 == ss11, ss1, ss11)
-  checkHashable(ss1 == ss2, ss1, ss2)
+  checkHashable([ss1, ss11, ss2], equalityOracle: { $0 == $1 })
 }
 
 SetTestSuite.test("Operator.Precedence") {