Merge pull request #4802 from apple/stdlib-test-fixes

stdlib: test fixes

Author: gribozavr

stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb

@@ -2073,7 +2073,7 @@ public func checkHashable<Instances : Collection>(
 }
 
 public func checkHashable<T : Hashable>(
-  _ expectedEqual: Bool, _ lhs: T, _ rhs: T, ${TRACE}
+  expectedEqual: Bool, _ lhs: T, _ rhs: T, ${TRACE}
 ) {
   checkHashable(
     [lhs, rhs], equalityOracle: { expectedEqual || $0 == $1 }, ${trace})

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

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 })
   }
 }
 

test/stdlib/FloatingPoint.swift.gyb

@@ -518,7 +518,9 @@ func checkFloatingPointComparison_${FloatSelf}(
   let message = { "expected: lhs=\(lhs) \(expected) rhs=\(rhs)" }
   expectEqual(expected.isEQ(), lhs == rhs, message(), stackTrace: newTrace)
   expectEqual(expected.isNE(), lhs != rhs, message(), stackTrace: newTrace)
-  checkHashable(expected.isEQ(), lhs, rhs, message(), stackTrace: newTrace)
+  checkHashable(
+    expectedEqual: expected.isEQ(),
+    lhs, rhs, message(), stackTrace: newTrace)
 
   expectEqual(expected.isLT(), lhs < rhs, message(), stackTrace: newTrace)
   expectEqual(expected.isLE(), lhs <= rhs, message(), stackTrace: newTrace)

test/stdlib/StringAPI.swift

@@ -145,7 +145,8 @@ func checkStringComparison(
   expectEqual(expected.isEQ(), lhs == rhs, stackTrace: stackTrace)
   expectEqual(expected.isNE(), lhs != rhs, stackTrace: stackTrace)
   checkHashable(
-    expected.isEQ(), lhs, rhs, stackTrace: stackTrace.withCurrentLoc())
+    expectedEqual: expected.isEQ(),
+    lhs, rhs, stackTrace: stackTrace.withCurrentLoc())
 
   expectEqual(expected.isLT(), lhs < rhs, stackTrace: stackTrace)
   expectEqual(expected.isLE(), lhs <= rhs, stackTrace: stackTrace)
@@ -167,7 +168,8 @@ func checkStringComparison(
     !expectedEqualUnicodeScalars, lhsNSString != rhsNSString,
     stackTrace: stackTrace)
   checkHashable(
-    expectedEqualUnicodeScalars, lhsNSString, rhsNSString,
+    expectedEqual: expectedEqualUnicodeScalars,
+    lhsNSString, rhsNSString,
     stackTrace: stackTrace.withCurrentLoc())
 #endif
 }
@@ -215,7 +217,8 @@ func checkCharacterComparison(
   expectEqual(expected.isEQ(), lhs == rhs, stackTrace: stackTrace)
   expectEqual(expected.isNE(), lhs != rhs, stackTrace: stackTrace)
   checkHashable(
-    expected.isEQ(), lhs, rhs, stackTrace: stackTrace.withCurrentLoc())
+    expectedEqual: expected.isEQ(),
+    lhs, rhs, stackTrace: stackTrace.withCurrentLoc())
 
   expectEqual(expected.isLT(), lhs < rhs, stackTrace: stackTrace)
   expectEqual(expected.isLE(), lhs <= rhs, stackTrace: stackTrace)

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") {

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()

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") {