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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
object Test {
def main(args: Array[String]) {
val test = scala.reflect.internal.util.WeakHashSetTest
test.checkEmpty
test.checkPlusEquals
test.checkPlusEqualsCollisions
test.checkRehashing
test.checkRehashCollisions
test.checkFindOrUpdate
test.checkMinusEquals
test.checkMinusEqualsCollisions
test.checkClear
test.checkIterator
test.checkIteratorCollisions
// This test is commented out because it relies on gc behavior which isn't reliable enough in an automated environment
// test.checkRemoveUnreferencedObjects
}
}
// put the main test object in the same package as WeakHashSet because
// it uses the package private "diagnostics" method
package scala.reflect.internal.util {
object WeakHashSetTest {
// a class guaranteed to provide hash collisions
case class Collider(x : String) extends Comparable[Collider] with Serializable {
override def hashCode = 0
def compareTo(y : Collider) = this.x compareTo y.x
}
// basic emptiness check
def checkEmpty {
val hs = new WeakHashSet[String]()
assert(hs.size == 0)
hs.diagnostics.fullyValidate
}
// make sure += works
def checkPlusEquals {
val hs = new WeakHashSet[String]()
val elements = List("hello", "goodbye")
elements foreach (hs += _)
assert(hs.size == 2)
assert(hs contains "hello")
assert(hs contains "goodbye")
hs.diagnostics.fullyValidate
}
// make sure += works when there are collisions
def checkPlusEqualsCollisions {
val hs = new WeakHashSet[Collider]()
val elements = List("hello", "goodbye") map Collider
elements foreach (hs += _)
assert(hs.size == 2)
assert(hs contains Collider("hello"))
assert(hs contains Collider("goodbye"))
hs.diagnostics.fullyValidate
}
// add a large number of elements to force rehashing and then validate
def checkRehashing {
val size = 200
val hs = new WeakHashSet[String]()
val elements = (0 until size).toList map ("a" + _)
elements foreach (hs += _)
elements foreach {i => assert(hs contains i)}
hs.diagnostics.fullyValidate
}
// make sure rehashing works properly when the set is rehashed
def checkRehashCollisions {
val size = 200
val hs = new WeakHashSet[Collider]()
val elements = (0 until size).toList map {x => Collider("a" + x)}
elements foreach (hs += _)
elements foreach {i => assert(hs contains i)}
hs.diagnostics.fullyValidate
}
// test that unreferenced objects are removed
// not run in an automated environment because gc behavior can't be relied on
def checkRemoveUnreferencedObjects {
val size = 200
val hs = new WeakHashSet[Collider]()
val elements = (0 until size).toList map {x => Collider("a" + x)}
elements foreach (hs += _)
// don't throw the following into a retained collection so gc
// can remove them
for (i <- 0 until size) {
hs += Collider("b" + i)
}
System.gc()
Thread.sleep(1000)
assert(hs.size == 200)
elements foreach {i => assert(hs contains i)}
for (i <- 0 until size) {
assert(!(hs contains Collider("b" + i)))
}
hs.diagnostics.fullyValidate
}
// make sure findOrUpdate returns the originally entered element
def checkFindOrUpdate {
val size = 200
val hs = new WeakHashSet[Collider]()
val elements = (0 until size).toList map {x => Collider("a" + x)}
elements foreach {x => assert(hs findEntryOrUpdate x eq x)}
for (i <- 0 until size) {
// when we do a lookup the result should be the same reference we
// original put in
assert(hs findEntryOrUpdate(Collider("a" + i)) eq elements(i))
}
hs.diagnostics.fullyValidate
}
// check -= functionality
def checkMinusEquals {
val hs = new WeakHashSet[String]()
val elements = List("hello", "goodbye")
elements foreach (hs += _)
hs -= "goodbye"
assert(hs.size == 1)
assert(hs contains "hello")
assert(!(hs contains "goodbye"))
hs.diagnostics.fullyValidate
}
// check -= when there are collisions
def checkMinusEqualsCollisions {
val hs = new WeakHashSet[Collider]
val elements = List(Collider("hello"), Collider("goodbye"))
elements foreach (hs += _)
hs -= Collider("goodbye")
assert(hs.size == 1)
assert(hs contains Collider("hello"))
assert(!(hs contains Collider("goodbye")))
hs -= Collider("hello")
assert(hs.size == 0)
assert(!(hs contains Collider("hello")))
hs.diagnostics.fullyValidate
}
// check that the clear method actually cleans everything
def checkClear {
val size = 200
val hs = new WeakHashSet[String]()
val elements = (0 until size).toList map ("a" + _)
elements foreach (hs += _)
hs.clear()
assert(hs.size == 0)
elements foreach {i => assert(!(hs contains i))}
hs.diagnostics.fullyValidate
}
// check that the iterator covers all the contents
def checkIterator {
val hs = new WeakHashSet[String]()
val elements = (0 until 20).toList map ("a" + _)
elements foreach (hs += _)
assert(elements.iterator.toList.sorted == elements.sorted)
hs.diagnostics.fullyValidate
}
// check that the iterator covers all the contents even when there is a collision
def checkIteratorCollisions {
val hs = new WeakHashSet[Collider]
val elements = (0 until 20).toList map {x => Collider("a" + x)}
elements foreach (hs += _)
assert(elements.iterator.toList.sorted == elements.sorted)
hs.diagnostics.fullyValidate
}
}
}
|
