| // RUN: %target-run-stdlib-swift |
| // REQUIRES: executable_test |
| |
| import Swift |
| import SwiftPrivate |
| import StdlibUnittest |
| |
| |
| var HashingTestSuite = TestSuite("Hashing") |
| |
| func checkHash( |
| for value: UInt64, |
| withSeed seed: (UInt64, UInt64), |
| expected: UInt64, |
| file: String = #file, line: UInt = #line |
| ) { |
| var hasher = Hasher(_seed: seed) |
| hasher._combine(value) |
| let hash = hasher.finalize() |
| expectEqual( |
| hash, Int(truncatingIfNeeded: expected), |
| file: file, line: line) |
| } |
| |
| HashingTestSuite.test("Hasher/CustomKeys") { |
| // This assumes Hasher implements SipHash-1-3. |
| checkHash(for: 0, withSeed: (0, 0), expected: 0xbd60acb658c79e45) |
| checkHash(for: 0, withSeed: (0, 1), expected: 0x1ce32b0b44e61175) |
| checkHash(for: 0, withSeed: (1, 0), expected: 0x9c44b7c8df2ca74b) |
| checkHash(for: 0, withSeed: (1, 1), expected: 0x9653ca0a3b455506) |
| checkHash(for: 0, withSeed: (.max, .max), expected: 0x3ab336a4895e4d36) |
| |
| checkHash(for: 1, withSeed: (0, 0), expected: 0x1e9f734161d62dd9) |
| checkHash(for: 1, withSeed: (0, 1), expected: 0xb6fcf32d09f76cba) |
| checkHash(for: 1, withSeed: (1, 0), expected: 0xacb556b13007504a) |
| checkHash(for: 1, withSeed: (1, 1), expected: 0x7defec680db51d24) |
| checkHash(for: 1, withSeed: (.max, .max), expected: 0x212798441870ef6b) |
| |
| checkHash(for: .max, withSeed: (0, 0), expected: 0x2f205be2fec8e38d) |
| checkHash(for: .max, withSeed: (0, 1), expected: 0x3ff7fa33381ecf7b) |
| checkHash(for: .max, withSeed: (1, 0), expected: 0x404afd8eb2c4b22a) |
| checkHash(for: .max, withSeed: (1, 1), expected: 0x855642d657c1bd46) |
| checkHash(for: .max, withSeed: (.max, .max), expected: 0x5b16b7a8181980c2) |
| } |
| |
| HashingTestSuite.test("Hasher/DefaultKey") { |
| let value: UInt64 = 0x0102030405060708 |
| |
| let defaultHash = _hashValue(for: value) |
| |
| let rawHash = value._rawHashValue(seed: Hasher._seed) |
| expectEqual(rawHash, defaultHash) |
| |
| let oneShotHash = Hasher._hash(seed: Hasher._seed, value) |
| expectEqual(oneShotHash, defaultHash) |
| |
| var defaultHasher = Hasher() |
| defaultHasher._combine(value) |
| expectEqual(defaultHasher.finalize(), defaultHash) |
| |
| var customHasher = Hasher(_seed: Hasher._seed) |
| customHasher._combine(value) |
| expectEqual(customHasher.finalize(), defaultHash) |
| } |
| |
| HashingTestSuite.test("Hashing/TopLevelHashing/UInt64") { |
| func checkTopLevelHash( |
| for value: UInt64, |
| seed: (UInt64, UInt64), |
| file: String = #file, |
| line: UInt = #line) { |
| var hasher = Hasher(_seed: seed) |
| hasher._combine(value) |
| let expected = hasher.finalize() |
| let actual = Hasher._hash(seed: seed, value) |
| expectEqual(actual, expected, file: file, line: line) |
| } |
| checkTopLevelHash(for: 0, seed: (0, 0)) |
| checkTopLevelHash(for: 1, seed: (0, 0)) |
| checkTopLevelHash(for: 1, seed: (1, 0)) |
| checkTopLevelHash(for: 1, seed: (1, 1)) |
| checkTopLevelHash(for: 0x0102030405060708, seed: (1, 1)) |
| checkTopLevelHash( |
| for: 0x0102030405060708, |
| seed: (0x0807060504030201, 0x090a0b0c0d0e0f)) |
| checkTopLevelHash(for: UInt64.max, seed: (1, 1)) |
| checkTopLevelHash(for: UInt64.max, seed: (UInt64.max, UInt64.max)) |
| } |
| |
| HashingTestSuite.test("Hashing/TopLevelHashing/UInt") { |
| func checkTopLevelHash( |
| for value: UInt, |
| seed: (UInt64, UInt64), |
| file: String = #file, |
| line: UInt = #line) { |
| var hasher = Hasher(_seed: seed) |
| hasher._combine(value) |
| let expected = hasher.finalize() |
| let actual = Hasher._hash(seed: seed, value) |
| expectEqual(actual, expected, file: file, line: line) |
| } |
| checkTopLevelHash(for: 0, seed: (0, 0)) |
| checkTopLevelHash(for: 1, seed: (0, 0)) |
| checkTopLevelHash(for: 1, seed: (1, 0)) |
| checkTopLevelHash(for: 1, seed: (1, 1)) |
| checkTopLevelHash( |
| for: UInt(truncatingIfNeeded: 0x0102030405060708 as UInt64), |
| seed: (1, 1)) |
| checkTopLevelHash( |
| for: UInt(truncatingIfNeeded: 0x0102030405060708 as UInt64), |
| seed: (0x8877665544332211, 0x1122334455667788)) |
| checkTopLevelHash(for: UInt.max, seed: (1, 1)) |
| checkTopLevelHash(for: UInt.max, seed: (UInt64.max, UInt64.max)) |
| } |
| |
| HashingTestSuite.test("Hashing/TopLevelHashing/PartialUInt64") { |
| func checkTopLevelHash( |
| for value: UInt64, |
| count: Int, |
| seed: (UInt64, UInt64), |
| file: String = #file, |
| line: UInt = #line) { |
| var hasher = Hasher(_seed: seed) |
| hasher._combine(bytes: value, count: count) |
| let expected = hasher.finalize() |
| let actual = Hasher._hash(seed: seed, bytes: value, count: count) |
| expectEqual( |
| actual, |
| expected, |
| "seed: \(seed), value: \(value), count: \(count)", |
| file: file, |
| line: line) |
| } |
| for seed: (UInt64, UInt64) in [ |
| (0, 0), |
| (1, 0), |
| (1, 1), |
| (0x1827364554637281, 0xf9e8d7c6b5a49382) |
| ] { |
| for count in 1 ..< 8 { |
| checkTopLevelHash(for: 0, count: count, seed: seed) |
| } |
| checkTopLevelHash(for: 0x01, count: 1, seed: seed) |
| checkTopLevelHash(for: 0x0102, count: 2, seed: seed) |
| checkTopLevelHash(for: 0x010203, count: 3, seed: seed) |
| checkTopLevelHash(for: 0x01020304, count: 4, seed: seed) |
| checkTopLevelHash(for: 0x0102030405, count: 5, seed: seed) |
| checkTopLevelHash(for: 0x010203040506, count: 6, seed: seed) |
| checkTopLevelHash(for: 0x01020304050607, count: 7, seed: seed) |
| } |
| } |
| |
| HashingTestSuite.test("Hashing/TopLevelHashing/UnsafeRawBufferPointer") { |
| func checkTopLevelHash( |
| for buffer: [UInt8], |
| seed: (UInt64, UInt64), |
| file: String = #file, |
| line: UInt = #line) { |
| var hasher = Hasher(_seed: seed) |
| buffer.withUnsafeBytes { buffer in |
| hasher.combine(bytes: buffer) |
| } |
| let expected = hasher.finalize() |
| let actual = buffer.withUnsafeBytes { buffer in |
| Hasher._hash(seed: seed, bytes: buffer) |
| } |
| expectEqual( |
| actual, |
| expected, |
| "seed: \(seed), buffer: \(buffer)", |
| file: file, |
| line: line) |
| } |
| for seed: (UInt64, UInt64) in [ |
| (0, 0), |
| (1, 0), |
| (1, 1), |
| (0x1827364554637281, 0xf9e8d7c6b5a49382) |
| ] { |
| var zeros: [UInt8] = [] |
| var integers: [UInt8] = [] |
| for i: UInt8 in 0 ..< 20 { |
| zeros.append(0) |
| checkTopLevelHash(for: zeros, seed: seed) |
| integers.append(i) |
| checkTopLevelHash(for: integers, seed: seed) |
| } |
| } |
| } |
| |
| runAllTests() |