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
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
|
/*
* filter: inliner warnings; re-run with
*/
import scala.collection._
import scala.language.postfixOps
object Test extends App {
def orderedTraversableTest(empty: Traversable[Int]) {
println("new test starting with "+empty)
assert(empty.isEmpty)
val ten = empty ++ List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
println(ten.size+": "+ten)
println(ten.tail.size+": "+ten.tail)
assert(ten == empty ++ (1 to 10))
assert(ten.size == 10)
assert(ten forall (_ <= 10))
assert(ten exists (_ == 5))
assert((ten count (_ % 2 == 0)) == 5)
assert((ten find (_ % 2 == 0)) == Some(2))
assert((0 /: ten)(_ + _) == 55)
assert((ten :\ 0)(_ + _) == 55)
println(ten.head)
val x = ten reduceLeft (_ + _)
assert(x == 55, x)
assert((ten reduceRight (_ + _)) == 55)
val firstFive = empty ++ (1 to 5)
val secondFive = empty ++ (6 to 10)
assert(firstFive ++ secondFive == ten, firstFive ++ secondFive)
val odds = ten filter (_ % 2 != 0)
val evens = ten filterNot (_ % 2 != 0)
assert(odds.size == evens.size)
val (o, e) = ten.partition(_ % 2 == 0)
assert(o.size == e.size)
val gs = ten groupBy (x => x / 4)
val vs1 = (for (k <- gs.keysIterator; v <- gs(k).toIterable.iterator) yield v).toList.sorted
val vs2 = gs.values.toList.flatten.sorted
// val vs2 = gs.values.toList flatMap (xs => xs)
assert(ten.head == 1)
assert(ten.tail.head == 2)
assert(ten.tail.size == 9)
assert(ten.tail.foldLeft(10)(_ + _) == 64)
assert(ten.last == 10)
assert(List(ten.head) ++ ten.tail == ten)
assert(ten.init ++ List(ten.last) == ten, ten.init)
assert(vs1 == vs2, vs1+"!="+vs2)
assert(vs1 == ten)
assert((ten take 5) == firstFive)
assert((ten drop 5) == secondFive)
assert(ten slice (3, 3) isEmpty)
assert((ten slice (3, 6)) == List(4, 5, 6), ten slice (3, 6))
assert((ten takeWhile (_ <= 5)) == firstFive)
assert((ten dropWhile (_ <= 5)) == secondFive)
assert((ten span (_ <= 5)) == (firstFive, secondFive))
assert((ten splitAt 5) == (firstFive, secondFive), ten splitAt 5)
val buf = new mutable.ArrayBuffer[Int]
firstFive copyToBuffer buf
secondFive copyToBuffer buf
assert(buf.result == ten, buf.result)
assert(ten.toArray.size == 10)
assert(ten.toArray.toSeq == ten, ten.toArray.toSeq)
assert(ten.toIterable == ten)
assert(ten.toList == ten)
assert(ten.toSeq == ten)
assert(ten.toStream == ten)
assert(ten.toString endsWith "(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)")
assert(ten.mkString("[", "; ", "]") endsWith "[1; 2; 3; 4; 5; 6; 7; 8; 9; 10]")
}
def orderedIterableTest(empty: Iterable[Int]) {
orderedTraversableTest(empty)
val six = empty ++ List(1, 2, 3, 4, 5, 6)
assert(six.iterator.toStream == six)
assert(six.takeRight(4) == List(3, 4, 5, 6), six.takeRight(4))
assert(six.dropRight(3) == List(1, 2, 3))
assert(six sameElements (1 to 6))
}
def sequenceTest(empty: Seq[Int]) {
orderedIterableTest(empty)
val ten = empty ++ (1 to 10)
println(ten)
val tenPlus = ten map (_ + 1)
assert((ten zip tenPlus) forall { case (x, y) => x + 1 == y })
val dble = ten flatMap (x => List(x, x))
assert(dble.distinct == ten)
assert(ten.length == 10)
assert(ten(0) == 1 && ten(9) == 10)
assert((ten lengthCompare 10) == 0 && (ten lengthCompare 1) > 0 && (ten lengthCompare 11) < 0)
assert((ten isDefinedAt 0) && (ten isDefinedAt 9))
assert(!(ten isDefinedAt -1));
assert(!(ten isDefinedAt 10))
val tenten = ten zip ten
assert((tenten map (_._1)) == ten)
assert((tenten map (_._2)) == ten)
assert(ten.zipWithIndex forall { case (x, y) => x == y + 1 })
assert(ten.segmentLength(_ <= 8, 4) == 4, ten.segmentLength(_ <= 8, 4))
assert(ten.prefixLength(_ <= 8) == 8)
assert(ten.indexWhere(_ >= 8, 4) == 7, ten.indexWhere(_ >= 8, 4))
assert(ten.indexWhere(_ >= 8) == 7)
assert(ten.indexOf(5) == 4)
assert(ten.indexOf(5, 4) == 4)
assert(ten.indexOf(5, 5) == -1)
assert(ten.lastIndexOf(5) == 4, ten.lastIndexOf(5))
assert(ten.lastIndexOf(5, 4) == 4)
assert(ten.lastIndexOf(5, 3) == -1)
assert(ten.lastIndexWhere(_ <= 8) == 7)
assert(ten.lastIndexWhere(_ <= 8, 6) == 6)
assert(ten.lastIndexWhere(_ <= 8, 8) == 7)
assert(ten.reverse startsWith List(10, 9, 8), ten.reverse.take(10).toList)
assert(ten.reverse.length == 10)
assert(ten.reverse.reverse == ten)
assert(ten.reverseIterator.toList.reverse == ten, ten.reverseIterator.toList)
assert(ten.startsWith(List(1)))
assert(ten.startsWith(List(3, 4), 2))
assert(ten.endsWith(List(9, 10)))
assert(ten.endsWith(List()))
assert(ten.indexOfSlice(List(3, 4, 5)) == 2, ten.indexOfSlice(List(3, 4, 5)))
assert(ten.lastIndexOfSlice(List(8, 9, 10)) == 7)
assert(ten.lastIndexOfSlice(List(1, 2, 3)) == 0)
assert(ten.lastIndexOfSlice(List(9, 10, 11)) == -1)
assert(ten contains 1)
assert(ten contains 10)
assert(!(ten contains 0))
assert((empty ++ (1 to 7) union empty ++ (3 to 10)) == List(1, 2, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 8, 9, 10))
assert((ten diff ten).isEmpty)
assert((ten diff List()) == ten)
assert((ten diff (ten filter (_ % 2 == 0))) == (ten filterNot (_ % 2 == 0)))
assert((ten intersect ten) == ten)
assert((ten intersect List(5)) == List(5))
assert((ten ++ ten).distinct == ten)
assert(ten.patch(3, List(4, 5, 6, 7), 4) == ten)
assert(ten.patch(0, List(1, 2, 3), 9) == List(1, 2, 3, 10))
assert(empty.padTo(10, 7) == Array.fill(10)(7).toSeq)
assert((ten zip ten.indices) == ten.zipWithIndex)
assert(ten.sortWith(_ < _) == ten)
assert(ten.sortWith(_ > _) == ten.reverse)
}
def setTest(empty: => Set[String]) {
var s = empty + "A" + "B" + "C"
s += ("D", "E", "F")
s ++= List("G", "H", "I")
s ++= ('J' to 'Z') map (_.toString)
assert(s forall (s contains))
assert(s contains "X")
assert(!(s contains "0"))
s = s + "0"
assert(s contains "0")
s = s - "X"
assert(!(s contains "X"))
assert(empty.isEmpty)
assert(!s.isEmpty)
assert((s intersect s) == s)
assert((empty intersect s) == empty)
assert(!s.isEmpty)
val s1 = s intersect empty
assert(s1 == empty, s1)
def abc = empty + ("a", "b", "c")
def bc = empty + ("b", "c")
assert(bc subsetOf abc)
}
def rangeTest(r: Range) {
val ten = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
assert(r == ten)
assert(r.toList == ten)
assert((r filter (_ % 2 == 0)) == (ten filter (_ % 2 == 0)))
println((r map (_ + 1)) == (ten map (_ + 1)))
println((r map (_ * 2)) == (ten map (_ + 1)))
println((r flatMap (i => 0 until i)) == (ten flatMap (i => 0 until i)))
}
def mapTest(empty: => Map[String, String]) = {
var m = empty + ("A" -> "A") + ("B" -> "B") + ("C" -> "C")
m += (("D" -> "D"), ("E" -> "E"), ("F" -> "F"))
m ++= List(("G" -> "G"), ("H" -> "H"), ("I" -> "I"))
m ++= ('J' to 'Z') map (x => (x.toString -> x.toString))
println(m.toList.sorted)
assert(!m.isEmpty)
assert(m.keySet forall (k => (m get k) == Some(k)))
assert(m.keySet forall (k => (m apply k) == k))
assert(m.keySet forall (m contains))
assert(m.getOrElse("7", "@") == "@")
assert(m.keySet.size == 26)
assert(m.size == 26)
assert(m.keySet == Set() ++ m.keysIterator)
assert(m.keySet == m.keysIterator.toList.toSet, m.keySet.toList+"!="+m.keysIterator.toList.toSet)
val m1 = empty ++ m
val mm = m -- m.keySet.toList
assert(mm.isEmpty, mm)
def m3 = empty ++ m1
assert(m1 == m3)
println(m3.toList.sorted)
val m4 = m3 filterNot { case (k, v) => k != "A" }
assert(m4.size == 1, m4)
}
def mutableMapTest(empty: => mutable.Map[String, String]) = {
mapTest(empty)
val m1 = empty ++ (('A' to 'Z') map (_.toString) map (x => (x, x)))
val m2 = m1 retain ((k, v) => k == "N")
assert(m2.size == 1, m2)
}
sequenceTest(Nil)
sequenceTest(List())
sequenceTest(Stream.empty)
sequenceTest(Array[Int]())
sequenceTest(mutable.ArrayBuffer())
sequenceTest(mutable.ListBuffer())
orderedTraversableTest(Traversable())
orderedTraversableTest(mutable.Traversable())
orderedTraversableTest(immutable.Traversable())
orderedIterableTest(Iterable())
orderedIterableTest(mutable.Iterable())
orderedIterableTest(immutable.Iterable())
sequenceTest(Seq())
sequenceTest(mutable.Seq())
sequenceTest(immutable.Seq())
sequenceTest(LinearSeq())
sequenceTest(IndexedSeq())
sequenceTest(Vector())
// sequenceTest(mutable.LinearSeq())
sequenceTest(immutable.LinearSeq())
sequenceTest(mutable.IndexedSeq())
rangeTest(1 to 10)
setTest(Set())
setTest(mutable.Set())
setTest(immutable.Set())
setTest(mutable.HashSet())
setTest(mutable.LinkedHashSet())
setTest(immutable.HashSet())
mapTest(Map())
mutableMapTest(mutable.Map())
mapTest(immutable.Map())
mapTest(immutable.TreeMap())
mutableMapTest(mutable.HashMap())
mutableMapTest(mutable.LinkedHashMap())
mapTest(immutable.HashMap())
}
|
