Merge pull request swiftlang#15045 from lorentey/hashValue-is-subject-to-change

Author: swift-ci

test/Interpreter/SDK/Foundation_bridge.swift

@@ -106,29 +106,29 @@ do {
 }
 
 // CHECK:      dictionary bridges to {
-// CHECK-NEXT:   2 = World;
-// CHECK-NEXT:   1 = Hello;
-// CHECK-NEXT: }
+// CHECK-DAG:   1 = Hello;
+// CHECK-DAG:   2 = World;
+// CHECK: }
 do {
   var dict: Dictionary<NSNumber, NSString> = [1: "Hello", 2: "World"]
   let obj = _bridgeAnythingToObjectiveC(dict)
   print("dictionary bridges to \(obj.description!)")
 }
 
 // CHECK:      dictionary bridges to {
-// CHECK-NEXT:   2 = World;
-// CHECK-NEXT:   1 = Hello;
-// CHECK-NEXT: }
+// CHECK-DAG:   1 = Hello;
+// CHECK-DAG:   2 = World;
+// CHECK: }
 do {
   var dict2 = [1: "Hello", 2: "World"]
   let obj = _bridgeAnythingToObjectiveC(dict2)
   print("dictionary bridges to \(obj.description!)")
 }
 
 // CHECK: dictionary bridges to {
-// CHECK-NEXT:   2 = "(\"World\", 2)";
-// CHECK-NEXT:   1 = "(\"Hello\", 1)";
-// CHECK-NEXT: }
+// CHECK-DAG:   1 = "(\"Hello\", 1)";
+// CHECK-DAG:   2 = "(\"World\", 2)";
+// CHECK: }
 do {
   var dict3 = [1: ("Hello", 1), 2: ("World", 2)]
   let obj = _bridgeAnythingToObjectiveC(dict3)
@@ -141,11 +141,11 @@ var dict4 = propListStr.propertyListFromStringsFileFormat()!
 var hello: NSString = "Hello"
 var world: NSString = "World"
 
-// Print out the keys. We only check one of these because the order is
-// nondeterministic.
-// CHECK: Hello
+// Print out the keys.
+// CHECK-DAG: Bridged key: Hello
+// CHECK-DAG: Bridged key: World
 for key in dict4.keys {
-  print(key.description)
+  print("Bridged key: \(key.description)")
 }
 
 // CHECK: Hello: 1

test/Interpreter/SDK/equatable_hashable.swift

@@ -8,20 +8,23 @@ import Foundation
 
 func testHash<H: Hashable>(_ x: H) -> Int { return x.hashValue }
 
+// CHECK: (1 as UInt8): hash = [[HASH:-?[0-9]+]]
+print("(1 as UInt8): hash = \((1 as UInt8).hashValue)")
+
 func test_CBool() {
   let x: CBool = true
   let hash = testHash(x)
   print("C_Bool: hash = \(hash)")
 }
-// CHECK: C_Bool: hash = 1
+// CHECK: C_Bool: hash = [[HASH]]
 test_CBool()
 
 func test_ObjCBool() {
   let x = ObjCBool(true)
   let hash = testHash(x.boolValue)
   print("ObjCBool: hash = \(hash)")
 }
-// CHECK-NEXT: ObjCBool: hash = 1
+// CHECK-NEXT: ObjCBool: hash = [[HASH]]
 test_ObjCBool()
 
 func testEquatable<E: Equatable>(_ x: E) {}

test/Interpreter/repl.swift

@@ -41,7 +41,7 @@ String(4.0)  // CHECK: String = "4.0"
 
 123 .
 hashValue
-// CHECK: Int = 123{{$}}
+// CHECK: Int = {{-?[0-9]+$}}
 
 // Check that we handle unmatched parentheses in REPL.
 1+1)

test/stdlib/ReflectionHashing.swift

@@ -2,14 +2,6 @@
 // RUN: %target-run %t.out
 // REQUIRES: executable_test
 
-// This test expects consistent hash code generation. However String instance
-// generate different values on Linux depending on which version of libicu is
-// installed. Therefore we run this test only on non-linux OSes, which is
-// best described as having objc_interop.
-
-// REQUIRES: objc_interop
-
-//
 // This file contains reflection tests that depend on hash values.
 // Don't add other tests here.
 //
@@ -36,46 +28,16 @@ Reflection.test("Dictionary") {
   var output = ""
   dump(dict, to: &output)
 
-#if arch(i386) || arch(arm)
-  var expected = ""
-  expected += "▿ 5 key/value pairs\n"
-  expected += "  ▿ (2 elements)\n"
-  expected += "    - key: \"Four\"\n"
-  expected += "    - value: 4\n"
-  expected += "  ▿ (2 elements)\n"
-  expected += "    - key: \"One\"\n"
-  expected += "    - value: 1\n"
-  expected += "  ▿ (2 elements)\n"
-  expected += "    - key: \"Two\"\n"
-  expected += "    - value: 2\n"
-  expected += "  ▿ (2 elements)\n"
-  expected += "    - key: \"Five\"\n"
-  expected += "    - value: 5\n"
-  expected += "  ▿ (2 elements)\n"
-  expected += "    - key: \"Three\"\n"
-  expected += "    - value: 3\n"
-#elseif arch(x86_64) || arch(arm64) || arch(powerpc64) || arch(powerpc64le) || arch(s390x)
+  // The order of elements in output depends on the hash values of dict's items,
+  // which isn't deterministic. However, iterating over dict will get us the
+  // same elements in the same order.
   var expected = ""
   expected += "▿ 5 key/value pairs\n"
-  expected += "  ▿ (2 elements)\n"
-  expected += "    - key: \"Three\"\n"
-  expected += "    - value: 3\n"
-  expected += "  ▿ (2 elements)\n"
-  expected += "    - key: \"Two\"\n"
-  expected += "    - value: 2\n"
-  expected += "  ▿ (2 elements)\n"
-  expected += "    - key: \"Four\"\n"
-  expected += "    - value: 4\n"
-  expected += "  ▿ (2 elements)\n"
-  expected += "    - key: \"One\"\n"
-  expected += "    - value: 1\n"
-  expected += "  ▿ (2 elements)\n"
-  expected += "    - key: \"Five\"\n"
-  expected += "    - value: 5\n"
-#else
-  fatalError("unimplemented")
-#endif
-
+  for (key, value) in dict {
+    expected += "  ▿ (2 elements)\n"
+    expected += "    - key: \"\(key)\"\n"
+    expected += "    - value: \(value)\n"
+  }
   expectEqual(expected, output)
 }
 
@@ -85,25 +47,14 @@ Reflection.test("Set") {
   var output = ""
   dump(s, to: &output)
 
-#if arch(i386) || arch(arm)
-  var expected = ""
-  expected += "▿ 5 members\n"
-  expected += "  - 3\n"
-  expected += "  - 1\n"
-  expected += "  - 5\n"
-  expected += "  - 2\n"
-  expected += "  - 4\n"
-#elseif arch(x86_64) || arch(arm64) || arch(powerpc64) || arch(powerpc64le) || arch(s390x)
+  // The order of elements in output depends on the hash values of dict's items,
+  // which isn't deterministic. However, iterating over dict will get us the
+  // same elements in the same order.
   var expected = ""
   expected += "▿ 5 members\n"
-  expected += "  - 5\n"
-  expected += "  - 2\n"
-  expected += "  - 3\n"
-  expected += "  - 1\n"
-  expected += "  - 4\n"
-#else
-  fatalError("unimplemented")
-#endif
+  for i in s {
+    expected += "  - \(i)\n"
+  }
 
   expectEqual(expected, output)
 }

validation-test/stdlib/Dictionary.swift

@@ -4492,7 +4492,8 @@ DictionaryTestSuite.test("dropsBridgedCache") {
 }
 
 DictionaryTestSuite.test("getObjects:andKeys:") {
-  let d = ([1: "one", 2: "two"] as Dictionary<Int, String>) as NSDictionary
+  let native = [1: "one", 2: "two"] as Dictionary<Int, String>
+  let d = native as NSDictionary
   var keys = UnsafeMutableBufferPointer(
     start: UnsafeMutablePointer<NSNumber>.allocate(capacity: 2), count: 2)
   var values = UnsafeMutableBufferPointer(
@@ -4501,17 +4502,27 @@ DictionaryTestSuite.test("getObjects:andKeys:") {
   var vp = AutoreleasingUnsafeMutablePointer<AnyObject?>(values.baseAddress!)
   var null: AutoreleasingUnsafeMutablePointer<AnyObject?>?
 
+  let expectedKeys: [NSNumber]
+  let expectedValues: [NSString]
+  if native.first?.key == 1 {
+    expectedKeys = [1, 2]
+    expectedValues = ["one", "two"]
+  } else {
+    expectedKeys = [2, 1]
+    expectedValues = ["two", "one"]
+  }
+
   d.available_getObjects(null, andKeys: null) // don't segfault
 
   d.available_getObjects(null, andKeys: kp)
-  expectEqual([2, 1] as [NSNumber], Array(keys))
+  expectEqual(expectedKeys, Array(keys))
 
   d.available_getObjects(vp, andKeys: null)
-  expectEqual(["two", "one"] as [NSString], Array(values))
+  expectEqual(expectedValues, Array(values))
 
   d.available_getObjects(vp, andKeys: kp)
-  expectEqual([2, 1] as [NSNumber], Array(keys))
-  expectEqual(["two", "one"] as [NSString], Array(values))
+  expectEqual(expectedKeys, Array(keys))
+  expectEqual(expectedValues, Array(values))
 }
 #endif
 
@@ -4530,11 +4541,14 @@ DictionaryTestSuite.test("popFirst") {
       2020: 2020,
       3030: 3030,
     ]
-    let expected = Array(d.map{($0.0, $0.1)})
+    let expected = [(1010, 1010), (2020, 2020), (3030, 3030)]
     while let element = d.popFirst() {
       popped.append(element)
     }
-    expectEqualSequence(expected, Array(popped)) {
+    // Note that removing an element may reorder remaining items, so we
+    // can't compare ordering here.
+    popped.sort(by: { $0.0 < $1.0 })
+    expectEqualSequence(expected, popped) {
       (lhs: (Int, Int), rhs: (Int, Int)) -> Bool in
       lhs.0 == rhs.0 && lhs.1 == rhs.1
     }

validation-test/stdlib/Set.swift

@@ -3365,11 +3365,14 @@ SetTestSuite.test("popFirst") {
   do {
     var popped = [Int]()
     var s = Set([1010, 2020, 3030])
-    let expected = Array(s)
+    let expected = [1010, 2020, 3030]
     while let element = s.popFirst() {
       popped.append(element)
     }
-    expectEqualSequence(expected, Array(popped))
+    // Note that removing an element may reorder remaining items, so we
+    // can't compare ordering here.
+    popped.sort()
+    expectEqualSequence(expected, popped)
     expectTrue(s.isEmpty)
   }
 }