diff options
author | Burak Emir <emir@epfl.ch> | 2007-09-16 02:39:52 +0000 |
---|---|---|
committer | Burak Emir <emir@epfl.ch> | 2007-09-16 02:39:52 +0000 |
commit | 0b2f65aa6c6b3bb3e7628720893fb8116fdc8f71 (patch) | |
tree | 8ddae77b1334a6e4b80c47e3c58d650217fa80c1 /test/files/run/patmatnew.scala | |
parent | 4c74083c14c959370dd69dd6a745f56354143998 (diff) | |
download | scala-0b2f65aa6c6b3bb3e7628720893fb8116fdc8f71.tar.gz scala-0b2f65aa6c6b3bb3e7628720893fb8116fdc8f71.tar.bz2 scala-0b2f65aa6c6b3bb3e7628720893fb8116fdc8f71.zip |
fixed seq matching bug + reorganized test cases
Diffstat (limited to 'test/files/run/patmatnew.scala')
-rw-r--r-- | test/files/run/patmatnew.scala | 157 |
1 files changed, 153 insertions, 4 deletions
diff --git a/test/files/run/patmatnew.scala b/test/files/run/patmatnew.scala index a61e9eb797..dc8e21701a 100644 --- a/test/files/run/patmatnew.scala +++ b/test/files/run/patmatnew.scala @@ -29,9 +29,17 @@ object Test extends TestConsoleMain { SeqUnapply, applyFromJcl, new Test717, - new TestGuards, + TestGuards, TestEqualsPatternOpt, - new TestStream, + TestSequence01, + TestSequence02, + TestSequence03, + TestSequence04, + TestSequence05, + TestSequence06, + TestSequence07, + TestSequence08, + TestStream, new Test903, new Test1163_Order, new TestUnbox, @@ -126,7 +134,7 @@ object Test extends TestConsoleMain { } } - class TestGuards extends TestCase("multiple guards for same pattern") with Shmeez { + object TestGuards extends TestCase("multiple guards for same pattern") with Shmeez { val tree:Tree = Beez(2) override def runTest = { val res = tree match { @@ -153,7 +161,148 @@ object Test extends TestConsoleMain { } } - class TestStream extends TestCase("unapply for Streams") { + object TestSequence01 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") + } + } + + + object TestSequence02 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") + } + } + + object TestSequence03 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") + } + } + + + object TestSequence04 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') + } + } + + object TestSequence05 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() ) + } + } + + object TestSequence06 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) + } + + } + + object TestSequence07 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 + //} + def doMatch4(xs:Seq[Char]) = xs match { + case Seq(x, y, _*) => x::y::Nil + case Seq(x, y, z, w) => List(z,w) // redundant! + } + def doMatch5(xs:Seq[Char]) = xs match { + case Seq(x, y, 'c', w @ _*) => x::y::Nil + case Seq(x, y, z @ _*) => z + } + def doMatch6(xs:Seq[Char]) = xs match { + case Seq(x, 'b') => x::'b'::Nil + case Seq(x, y, z @ _*) => z.toList + } + + override def runTest() { + assertEquals(List('a','b'), doMatch1(List('a','b','c','d'))) + assertEquals(List('c','d'), doMatch2(List('a','b','c','d'))) + //assertEquals(doMatch3(List('a','b','c','d')), List('d')) + assertEquals(List('a','b'), doMatch4(List('a','b','c','d'))) + assertEquals(List('a','b'), doMatch5(List('a','b','c','d'))) + assertEquals(List('c','d'), doMatch6(List('a','b','c','d'))) + } + } + + object TestSequence08 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) + } + } + + + object TestStream extends TestCase("unapply for Streams") { def sum(stream: Stream[int]): int = stream match { case Stream.empty => 0 |