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
|
/**
* Checks that serialization of hash-based collections works correctly if the hashCode
* changes on deserialization.
*/
object Test {
import collection._
def main(args: Array[String]) {
for (i <- Seq(0, 1, 2, 10, 100)) {
def entries = (0 until i).map(i => (new Foo, i)).toList
def elements = entries.map(_._1)
val maps = Seq[Map[Foo, Int]](new mutable.HashMap, new mutable.LinkedHashMap,
immutable.HashMap.empty).map(_ ++ entries)
test[Map[Foo, Int]](maps, entries.size, assertMap _)
val sets = Seq[Set[Foo]](new mutable.HashSet, new mutable.LinkedHashSet,
immutable.HashSet.empty).map(_ ++ elements)
test[Set[Foo]](sets, entries.size, assertSet _)
}
}
private def test[A <: AnyRef](collections: Seq[A], expectedSize: Int, assertFunction: (A, Int) => Unit) {
for (collection <- collections) {
assertFunction(collection, expectedSize)
val bytes = toBytes(collection)
Foo.hashCodeModifier = 1
val deserializedCollection = toObject[A](bytes)
assertFunction(deserializedCollection, expectedSize)
assert(deserializedCollection.getClass == collection.getClass,
"collection class should remain the same after deserialization ("+deserializedCollection.getClass+" != "+collection.getClass+")")
Foo.hashCodeModifier = 0
}
}
private def toObject[A](bytes: Array[Byte]): A = {
val in = new java.io.ObjectInputStream(new java.io.ByteArrayInputStream(bytes))
in.readObject.asInstanceOf[A]
}
private def toBytes(o: AnyRef): Array[Byte] = {
val bos = new java.io.ByteArrayOutputStream
val out = new java.io.ObjectOutputStream(bos)
out.writeObject(o)
out.close
bos.toByteArray
}
private def assertMap[A, B](map: Map[A, B], expectedSize: Int) {
assert(expectedSize == map.size, "expected map size: " + expectedSize + ", actual size: " + map.size)
map.foreach { case (k, v) =>
assert(map.contains(k), "contains should return true for key in the map, key: " + k)
assert(map(k) == v)
}
}
private def assertSet[A](set: Set[A], expectedSize: Int) {
assert(expectedSize == set.size, "expected set size: " + expectedSize + ", actual size: " + set.size)
set.foreach { e => assert(set.contains(e), "contains should return true for element in the set, element: " + e) }
}
object Foo {
/* Used to simulate a hashCode change caused by deserializing an instance with an
* identity-based hashCode in another JVM.
*/
var hashCodeModifier = 0
}
@serializable
class Foo {
override def hashCode = System.identityHashCode(this) + Foo.hashCodeModifier
}
}
|
