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
|
object Test {
import scala.testing.SUnit._
def main(args: Array[String]) {
val tr = new TestResult
new TestSuite(
new Test01,
new Test02,
new Test03,
new Test04,
new Test05,
new Test06,
new Test07,
new Test08
).run(tr)
for (val f <- tr.failures()) println(f)
}
class Test01 extends TestCase("uno (all ignoring patterns on List)") {
def doMatch(xs: List[String]): String = xs match {
case List(_*) => "ok"
}
override def runTest() {
val list1 = List()
assertEquals(doMatch(list1), "ok")
val list2 = List("1","2","3")
assertEquals(doMatch(list2), "ok")
}
}
/* these are not allowed, for strange reasons I will never figure out
def doMatch(l:Seq[String]):String = l match {
case List(_*) => "ok"
case _ => "not ok"
}
def doMatch(l:Seq[String]):String = l match {
case Array(_*) => "ok"
case _ => "not ok"
}
*/
class Test02 extends TestCase("due (all ignoring patterns on Seq)") {
def doMatch(l: Seq[String]): String = l match {
case Seq(_*) => "ok"
}
override def runTest() {
val list1 = List()
assertEquals(doMatch(list1), "ok")
val list2 = List("1", "2", "3")
assertEquals(doMatch(list2), "ok")
val array3 = Array[String]()
assertEquals(doMatch(array3), "ok")
val array4 = Array[String]("ga", "gu")
assertEquals(doMatch(array4), "ok")
}
}
class Test03 extends TestCase("tre (right-ignoring patterns on List, defaults)") {
def doMatch(xs: List[String]): String = xs match {
case List(_,_,_,_*) => "ok"
case _ => "not ok"
}
override def runTest() {
val list1 = List()
assertEquals(doMatch(list1), "not ok")
val list2 = List("1","2","3")
assertEquals(doMatch(list2), "ok")
val list3 = List("1","2","3","4")
assertEquals(doMatch(list3), "ok")
}
}
class Test04 extends TestCase("quattro (all- and right-ignoring pattern on case class w/ seq param)") {
case class Foo(i: Int, chars: Char*)
override def runTest() = {
val a = Foo(0, 'a') match {
case Foo(i, c, chars @ _*) => c
case _ => null
}
assertEquals(a, 'a')
val b = Foo(0, 'a') match {
case Foo(i, chars @ _*) => 'b'
case _ => null
}
assertEquals(b, 'b')
}
}
class Test05 extends TestCase("cinque (sealed case class with ignoring seq patterns)") {
sealed abstract class Con;
case class Foo() extends Con
case class Bar(xs:Con*) extends Con
override def runTest() {
val res = (Bar(Foo()):Con) match {
case Bar(xs@_*) => xs // this should be optimized away to a pattern Bar(xs)
case _ => Nil
}
assertEquals("res instance"+res.isInstanceOf[Seq[Con] forSome { type Con }]+" res(0)="+res(0), true, res.isInstanceOf[Seq[Foo] forSome { type Foo}] && res(0) == Foo() )
}
}
class Test06 extends TestCase("sei (not regular) fancy guards / bug#644 ") {
case class A(i: Any)
def doMatch(x: Any, bla: int) = x match {
case x:A if (bla==1) => 0
case A(1) => 1
case A(A(1)) => 2
}
override def runTest() {
assertEquals(doMatch(A(null),1), 0)
assertEquals(doMatch(A(1),2), 1)
assertEquals(doMatch(A(A(1)),2), 2)
}
}
class Test07 extends TestCase("sette List of chars") {
def doMatch1(xs: List[char]) = xs match {
case List(x, y, _*) => x::y::Nil
}
def doMatch2(xs:List[char]) = xs match {
case List(x, y, z, w) => List(z,w)
}
//def doMatch3(xs:List[char]) = xs match {
// case List(_*, z, w) => w::Nil
//}
override def runTest() {
assertEquals(doMatch1(List('a','b','c','d')), List('a','b'))
assertEquals(doMatch2(List('a','b','c','d')), List('c','d'))
//assertEquals(doMatch3(List('a','b','c','d')), List('d'))
}
}
class Test08 extends TestCase("backquoted identifiers in pattern") {
override def runTest() {
val xs = List(2, 3)
val ys = List(1, 2, 3) match {
case x :: `xs` => xs
case _ => Nil
}
assertEquals(xs, ys)
}
}
}
|
