diff options
Diffstat (limited to 'test/files/run')
-rw-r--r-- | test/files/run/patmatnew.scala | 157 | ||||
-rw-r--r-- | test/files/run/regularpatmatnew.check | 0 | ||||
-rw-r--r-- | test/files/run/regularpatmatnew.scala | 158 |
3 files changed, 153 insertions, 162 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 diff --git a/test/files/run/regularpatmatnew.check b/test/files/run/regularpatmatnew.check deleted file mode 100644 index e69de29bb2..0000000000 --- a/test/files/run/regularpatmatnew.check +++ /dev/null diff --git a/test/files/run/regularpatmatnew.scala b/test/files/run/regularpatmatnew.scala deleted file mode 100644 index c610b80444..0000000000 --- a/test/files/run/regularpatmatnew.scala +++ /dev/null @@ -1,158 +0,0 @@ -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) - } - } - -} |