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
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
//############################################################################
// Lists
//############################################################################
//############################################################################
import testing.SUnit._
/** Test the Scala implementation of class <code>scala.List</code>.
*
* @author Stephane Micheloud
*/
object Test extends TestConsoleMain {
def suite = new TestSuite(
Test_multiset, // multiset operations: union, intersect, diff
Test1, //count, exists, filter, ..
Test2, //#468
Test3, //#1691
Test4, //#1721
Test5
)
}
object Test_multiset extends TestCase("multiset") with Assert {
override def enableStackTrace = false
override def runTest {
def isSubListOf[A](thiz: List[A], that: List[A]): Boolean =
thiz forall (that contains _)
val xs = List(1, 1, 2)
val ys = List(1, 2, 2, 3)
assertEquals("xs_union_ys", List(1, 1, 2, 1, 2, 2, 3), xs union ys)
assertEquals("ys_union_xs", List(1, 2, 2, 3, 1, 1, 2), ys union xs)
assertEquals("xs_intersect_ys", List(1, 2), xs intersect ys)
assertEquals("ys_intersect_xs", List(1, 2), ys intersect xs)
assertEquals("xs_diff_ys", List(1), xs diff ys)
assertEquals("ys_diff_xs", List(2, 3), ys diff xs)
assertTrue("xs_subset_ys", isSubListOf(xs -- ys, xs diff ys))
val zs = List(0, 1, 1, 2, 2, 2)
assertEquals("zs_union_ys", List(0, 1, 1, 2, 2, 2, 1, 2, 2, 3), zs union ys)
assertEquals("ys_union_zs", List(1, 2, 2, 3, 0, 1, 1, 2, 2, 2), ys union zs)
assertEquals("zs_intersect_ys", List(1, 2, 2), zs intersect ys)
assertEquals("ys_intersect_zs", List(1, 2, 2), ys intersect zs)
assertEquals("zs_diff_ys", List(0, 1, 2), zs diff ys)
assertEquals("ys_diff_zs", List(3), ys diff zs)
assertTrue("xs_subset_ys", isSubListOf(zs -- ys, zs diff ys))
val ws = List(2)
assertEquals("ws_union_ys", List(2, 1, 2, 2, 3), ws union ys)
assertEquals("ys_union_ws", List(1, 2, 2, 3, 2), ys union ws)
assertEquals("ws_intersect_ys", List(2), ws intersect ys)
assertEquals("ys_intersect_ws", List(2), ys intersect ws)
assertEquals("ws_diff_ys", List(), ws diff ys)
assertEquals("ys_diff_ws", List(1, 2, 3), ys diff ws)
assertTrue("ws_subset_ys", isSubListOf(ws -- ys, ws diff ys))
val vs = List(3, 2, 2, 1)
assertEquals("xs_union_vs", List(1, 1, 2, 3, 2, 2, 1), xs union vs)
assertEquals("vs_union_xs", List(3, 2, 2, 1, 1, 1, 2), vs union xs)
assertEquals("xs_intersect_vs", List(1, 2), xs intersect vs)
assertEquals("vs_intersect_xs", List(2, 1), vs intersect xs)
assertEquals("xs_diff_vs", List(1), xs diff vs)
assertEquals("vs_diff_xs", List(3, 2), vs diff xs)
assertTrue("xs_subset_vs", isSubListOf(xs -- vs, xs diff vs))
// tests adapted from Thomas Jung
assertTrue(
"be symmetric after sorting", {
def sort(zs: List[Int]) = zs sort ( _ > _ )
sort(xs intersect ys) == sort(ys intersect xs)
})
assertTrue(
"obey min cardinality", {
def cardinality[A](zs: List[A], e: A): Int = zs count (e == _)
val intersection = xs intersect ys
xs forall (e => cardinality(intersection, e) == (cardinality(xs, e)
min cardinality(ys, e)))
})
assertTrue(
"maintain order", {
val intersection = xs intersect ys
val unconsumed = xs.foldLeft(intersection){(rest, e) =>
if (! rest.isEmpty && e == rest.head) rest.tail else rest
}
unconsumed.isEmpty
})
assertTrue(
"has the list as again intersection",
xs == (xs intersect xs)
)
}
}
object Test1 extends TestCase("ctor") with Assert {
override def enableStackTrace = false
override def runTest {
val xs1 = List(1, 2, 3)
val xs2 = List('a', 'b')
val xs3 = List(List(1, 2), List(4, 5))
val xs4 = List(2, 4, 6, 8)
val xs5 = List(List(3, 4), List(3), List(4, 5))
{
val n1 = xs1 count { e => e % 2 != 0 }
val n2 = xs4 count { e => e < 5 }
assertEquals("check_count", 4, n1 + n2)
}
{
val b1 = xs1 exists { e => e % 2 == 0 }
val b2 = xs4 exists { e => e == 5 }
assertEquals("check_exists", false , b1 & b2)
}
{
val ys1 = xs1 filter { e => e % 2 == 0 }
val ys2 = xs4 filter { e => e < 5 }
assertEquals("check_filter", 3, ys1.length + ys2.length)
}
{
val n1 = xs1.foldLeft(0)((e1, e2) => e1 + e2)
val ys1 = xs4.foldLeft(List[Int]())((e1, e2) => e2 :: e1)
assertEquals("check_foldLeft", 10, n1 + ys1.length)
}
{
val b1 = xs1 forall { e => e < 10}
val b2 = xs4 forall { e => e % 2 == 0 }
assertEquals("check_forall", true, b1 & b2)
}
{
val ys1 = xs1 remove { e => e % 2 != 0 }
val ys2 = xs4 remove { e => e < 5 }
assertEquals("check_remove", 3, ys1.length + ys2.length)
}
{
val ys1 = xs1 zip xs2
val ys2 = xs1 zip xs3
assertEquals("check_zip", 4, ys1.length + ys2.length)
}
{
val ys1 = xs1.zipAll(xs2, 0, '_')
val ys2 = xs2.zipAll(xs1, '_', 0)
val ys3 = xs1.zipAll(xs3, 0, List(-1))
assertEquals("check_zipAll", 9, ys1.length + ys2.length + ys3.length)
}
}
}
object Test2 extends TestCase("t0468") with Assert {
override def enableStackTrace = false
override def runTest {
val xs1 = List(1, 2, 3)
val xs2 = List(0)
val ys1 = xs1 ::: List(4)
assertEquals("check_:::", List(1, 2, 3, 4), ys1)
val ys2 = ys1 - 4
assertEquals("check_-", xs1, ys2)
val n2 = (xs1 ++ ys1).length
val n3 = (xs1 ++ Nil).length
val n4 = (xs1 ++ ((new collection.mutable.ArrayBuffer[Int]) + 0)).length
assertEquals("check_++", 14, n2 + n3 + n4)
}
}
object Test3 extends TestCase("t1691") with Assert {
override def enableStackTrace = false
override def runTest {
try {
List.range(1, 10, 0)
} catch {
case e: IllegalArgumentException => ()
case _ => throw new Error("List.range(1, 10, 0)")
}
try {
List.range(1, 10, x => 4)
} catch {
case e: IllegalArgumentException => ()
case _ => throw new Error("List.range(1, 10, x => 4)")
}
assertEquals(List.range(10, 0, x => x - 2),
List(10, 8, 6, 4, 2))
}
}
object Test4 extends TestCase("t1721") with Assert {
override def enableStackTrace = false
override def runTest {
assertTrue(List(1,2,3).endsWith(List(2,3)))
assertFalse(List(1,2,3).endsWith(List(1,3)))
assertTrue(List(1,2,3).endsWith(List()))
assertFalse(List(1,2,3).endsWith(List(0,1,2,3)))
assertTrue(List(1,2,3).endsWith(List(1,2,3)))
assertFalse(List().endsWith(List(1,2,3)))
assertTrue(List().endsWith(List()))
}
}
object Test5 extends TestCase("list pattern matching") {
def show(xs: List[String]) = xs match {
case "foo" :: args => args.toString
case List(x) => x.toString
case Nil => "Nil"
}
override def runTest {
assert(show(List()) == "Nil")
assert(show(List("a")) == "a")
assert(show(List("foo", "b")) == "List(b)")
}
}
|
