1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
|
// RUN: %target-run-simple-swift
// REQUIRES: executable_test
import StdlibUnittest
struct Value: Hashable {
let v: Int
}
struct Pair<T: Hashable, U: Hashable>: Hashable {
let a: T
let b: U
}
typealias PSI = Pair<String, Int>
var StructSynthesisTests = TestSuite("StructSynthesis")
StructSynthesisTests.test("BasicEquatability/Hashability") {
checkHashable([Value(v: 1), Value(v: 2)], equalityOracle: { $0 == $1 })
}
// Not guaranteed by the semantics of Hashable, but we soundness check that the
// synthesized hash function is good enough to not let nearby values collide.
StructSynthesisTests.test("CloseValuesDoNotCollide") {
expectNotEqual(Value(v: 1).hashValue, Value(v: 2).hashValue)
}
StructSynthesisTests.test("GenericEquatability/Hashability") {
checkHashable([
PSI(a: "foo", b: 0),
PSI(a: "bar", b: 0),
PSI(a: "foo", b: 5),
PSI(a: "bar", b: 5),
], equalityOracle: { $0 == $1 })
}
StructSynthesisTests.test("CloseGenericValuesDoNotCollide") {
expectNotEqual(PSI(a: "foo", b: 0).hashValue, PSI(a: "goo", b: 0).hashValue)
expectNotEqual(PSI(a: "foo", b: 0).hashValue, PSI(a: "foo", b: 1).hashValue)
expectNotEqual(PSI(a: "foo", b: 0).hashValue, PSI(a: "goo", b: 1).hashValue)
}
func hashEncode(_ body: (inout Hasher) -> ()) -> Int {
var hasher = Hasher()
body(&hasher)
return hasher.finalize()
}
// Make sure that if the user overrides the synthesized member, that one gets
// used instead.
struct Overrides: Hashable {
let a: Int
var hashValue: Int { return 2 }
func hash(into hasher: inout Hasher) {
hasher.combine(2)
}
static func == (lhs: Overrides, rhs: Overrides) -> Bool { return true }
}
StructSynthesisTests.test("ExplicitOverridesSynthesized") {
checkHashable(expectedEqual: true, Overrides(a: 4), Overrides(a: 5))
expectEqual(Overrides(a: 4).hashValue, 2)
expectEqual(
hashEncode { $0.combine(Overrides(a: 4)) },
hashEncode { $0.combine(2) })
}
// ...even in an extension.
struct OverridesInExtension: Hashable {
let a: Int
}
extension OverridesInExtension {
var hashValue: Int { return 2 }
func hash(into hasher: inout Hasher) {
hasher.combine(2)
}
static func == (lhs: OverridesInExtension, rhs: OverridesInExtension) -> Bool { return true }
}
StructSynthesisTests.test("ExplicitOverridesSynthesizedInExtension") {
checkHashable(expectedEqual: true, OverridesInExtension(a: 4), OverridesInExtension(a: 5))
expectEqual(OverridesInExtension(a: 4).hashValue, 2)
expectEqual(
hashEncode { $0.combine(OverridesInExtension(a: 4)) },
hashEncode { $0.combine(2) })
}
runAllTests()
|
