diff options
Diffstat (limited to 'test/files/run/patmatnew.scala')
-rw-r--r-- | test/files/run/patmatnew.scala | 858 |
1 files changed, 341 insertions, 517 deletions
diff --git a/test/files/run/patmatnew.scala b/test/files/run/patmatnew.scala index 025d6bf2ef..9e91a48258 100644 --- a/test/files/run/patmatnew.scala +++ b/test/files/run/patmatnew.scala @@ -1,102 +1,81 @@ -trait Treez { self: Shmeez => - abstract class Tree - case class Beez(i:Int) extends Tree - case object HagbardCeline extends Tree -} - -trait Shmeez extends AnyRef with Treez { - val tree: Tree - - def foo = tree match { - case Beez(2) => 1 - case HagbardCeline => 0 - } -} - -import scala.testing.SUnit._ - -object Test extends TestConsoleMain { - - //just compilation - def zipFun[a,b](xs:List[a], ys:List[b]):List[Pair[a,b]] = (Pair(xs,ys): @unchecked) match { - // !!! case Pair(List(), _), Pair(_, List()) => List() - case (x :: xs1, y :: ys1) => (x, y) :: zipFun(xs1, ys1) - } - - def suite = new TestSuite( - new TestSimpleIntSwitch, - new SimpleUnapply, - SeqUnapply, - applyFromJcl, - new Test717, - TestGuards, - TestEqualsPatternOpt, - TestSequence01, - TestSequence02, - TestSequence03, - TestSequence04, - TestSequence05, - TestSequence06, - TestSequence07, - TestSequence08, - TestStream, - new Test903, - new Test1163_Order, - new TestUnbox, - Bug457, - Bug508, - Bug789, - Bug995, - Bug1093, - Bug1094, - ClassDefInGuard, - Ticket2, - Ticket11, - Ticket37, - Ticket44, - Ticket346 - ) - - class Foo(j:Int) { - case class Bar(i:Int) - } - class SimpleUnapply extends TestCase("simpleUnapply") { - override def runTest() { // from sortedmap, old version +object Test { + + def main(args: Array[String]) { + ApplyFromJcl.run() + Bug1093.run() + Bug1094.run() + Bug1270.run() + Bug1281.run() + Bug457.run() + Bug508.run() + Bug789.run() + Bug881.run() + Bug995.run() + ClassDefInGuard.run() + SeqUnapply.run() + SimpleUnapply.run() + Test1163_Order.run() + Test717.run() + Test903.run() + TestEqualsPatternOpt.run() + TestGuards.run() + TestSequence01.run() + TestSequence02.run() + TestSequence03.run() + TestSequence04.run() + TestSequence05.run() + TestSequence06.run() + TestSequence07.run() + TestSequence08.run() + TestSimpleIntSwitch.run() + TestStream.run() + TestUnbox.run() + Ticket11.run() + Ticket2.run() + Ticket346.run() + Ticket37.run() + Ticket44.run() + } + + def assertEquals(a: Any, b: Any) { assert(a == b) } + def assertEquals(msg: String, a: Any, b: Any) { assert(a == b, msg) } + + object SimpleUnapply { + def run() { // from sortedmap, old version List((1, 2)).head match { - case kv @ Pair(key, _) => kv.toString + " " + key.toString + case kv@Pair(key, _) => kv.toString + " " + key.toString } - } } - object SeqUnapply extends TestCase("seqUnapply") { + object SeqUnapply { case class SFB(i: Int, xs: List[Int]) - override def runTest() { - List(1,2) match { + def run() { + List(1, 2) match { case List(1) => assert(false, "wrong case") - case List(1,2,xs @ _*) => assert(xs.isEmpty, "not empty") + case List(1, 2, xs@_*) => assert(xs.isEmpty, "not empty") case Nil => assert(false, "wrong case") } - SFB(1,List(1)) match { + SFB(1, List(1)) match { case SFB(_, List(x)) => assert(x == 1) case SFB(_, _) => assert(false) } } } - object applyFromJcl extends TestCase("applyFromJcl") { - override def runTest { - val p = (1,2) - Some(2) match { - case Some(p._2) => - case _ => assert(false) - } + object ApplyFromJcl { + def run() { + val p = (1, 2) + Some(2) match { + case Some(p._2) => + case _ => assert(false) + } } } - class TestSimpleIntSwitch extends TestCase("SimpleIntSwitch") { - override def runTest() = { + object TestSimpleIntSwitch { + def run() { assertEquals("s1", 1, 1 match { case 3 => 3 case 2 => 2 @@ -107,12 +86,12 @@ object Test extends TestConsoleMain { case 1 => 1 case _ => 0 }) - assertEquals("s2boxed", 1, (1:Any) match { + assertEquals("s2boxed", 1, (1: Any) match { case 1 => 1 case _ => 0 }) assertEquals("s3", 1, ("hello") match { - case s:String => 1 + case s: String => 1 //case _ => 0 // unreachable! }) val xyz: (Int, String, Boolean) = (1, "abc", true); @@ -122,69 +101,93 @@ object Test extends TestConsoleMain { }) } } - class Test717 extends TestCase("#717 test path of case classes") { + + // #717 test path of case classes + object Test717 { + class Foo(j: Int) { + case class Bar(i: Int) + } val foo1 = new Foo(1) val foo2 = new Foo(2) - - override def runTest() = { - val res = (foo1.Bar(2):Any) match { - case foo2.Bar(2) => false - case foo1.Bar(2) => true + def run() { + val res = (foo1.Bar(2): Any) match { + case foo2.Bar(2) => false + case foo1.Bar(2) => true } - assertTrue("ok", res); + assert(res) } } - object TestGuards extends TestCase("multiple guards for same pattern") with Shmeez { - val tree:Tree = Beez(2) - override def runTest = { + /// + + trait Treez { self: Shmeez => + abstract class Tree + case class Beez(i: Int) extends Tree + case object HagbardCeline extends Tree + } + + trait Shmeez extends AnyRef with Treez { + val tree: Tree + + def foo = tree match { + case Beez(2) => 1 + case HagbardCeline => 0 + } + } + + // multiple guards for same pattern + object TestGuards extends Shmeez { + val tree: Tree = Beez(2) + def run() { val res = tree match { case Beez(x) if x == 3 => false case Beez(x) if x == 2 => true } - assertTrue("ok", res); - val ret = (Beez(3):Tree) match { + assert(res) + val ret = (Beez(3): Tree) match { case Beez(x) if x == 3 => true case Beez(x) if x == 2 => false } - assertTrue("ok", ret); + assert(ret) } } - object TestEqualsPatternOpt extends TestCase("test EqualsPatternClass in combination with MixTypes opt, bug #1276") { + // test EqualsPatternClass in combination with MixTypes opt, bug #1276 + object TestEqualsPatternOpt { val NoContext = new Object - override def runTest { - assertEquals(1,((NoContext:Any) match { - case that : AnyRef if this eq that => 0 + def run() { + assertEquals(1, ((NoContext: Any) match { + case that: AnyRef if this eq that => 0 case NoContext => 1 case _ => 2 })) } } - object TestSequence01 extends TestCase("uno (all ignoring patterns on List)") { + // all ignoring patterns on List + object TestSequence01 { def doMatch(xs: List[String]): String = xs match { case List(_*) => "ok" } def doMatch2(xs: List[String]): List[String] = xs match { - case List(_, rest @ _*) => rest.toList + case List(_, rest@_*) => rest.toList } - override def runTest() { + def run() { val list1 = List() assertEquals(doMatch(list1), "ok") - val list2 = List("1","2","3") + val list2 = List("1", "2", "3") assertEquals(doMatch(list2), "ok") - val list3 = List("1","2","3") - assertEquals(doMatch2(list3), List("2","3")) + val list3 = List("1", "2", "3") + assertEquals(doMatch2(list3), List("2", "3")) } } - - object TestSequence02 extends TestCase("due (all ignoring patterns on Seq)") { + // all ignoring patterns on Seq + object TestSequence02 { def doMatch(l: Seq[String]): String = l match { case Seq(_*) => "ok" } - override def runTest() { + def run() { val list1 = List() assertEquals(doMatch(list1), "ok") val list2 = List("1", "2", "3") @@ -196,112 +199,104 @@ object Test extends TestConsoleMain { } } - object TestSequence03 extends TestCase("tre (right-ignoring patterns on List, defaults)") { + // right-ignoring patterns on List, defaults + object TestSequence03 { def doMatch(xs: List[String]): String = xs match { - case List(_,_,_,_*) => "ok" + case List(_, _, _, _*) => "ok" case _ => "not ok" } - override def runTest() { + def run() { val list1 = List() assertEquals(doMatch(list1), "not ok") - val list2 = List("1","2","3") + val list2 = List("1", "2", "3") assertEquals(doMatch(list2), "ok") - val list3 = List("1","2","3","4") + 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)") { + // all- and right-ignoring pattern on case class w/ seq param + object TestSequence04 { case class Foo(i: Int, chars: Char*) - override def runTest() = { + def run() { val a = Foo(0, 'a') match { - case Foo(i, c, chars @ _*) => c + case Foo(i, c, chars@_*) => c case _ => null } assertEquals(a, 'a') val b = Foo(0, 'a') match { - case Foo(i, chars @ _*) => 'b' + case Foo(i, chars@_*) => 'b' case _ => null } assertEquals(b, 'b') } } - object TestSequence05 extends TestCase("cinque (sealed case class with ignoring seq patterns)") { + // sealed case class with ignoring seq patterns + object TestSequence05 { sealed abstract class Con; case class Foo() extends Con - case class Bar(xs:Con*) extends Con + case class Bar(xs: Con*) extends Con - override def runTest() { - val res = (Bar(Foo()):Con) match { + def run() { + 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() ) + 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 ") { + // (not regular) fancy guards / bug#644 + object TestSequence06 { case class A(i: Any) def doMatch(x: Any, bla: Int) = x match { - case x:A if (bla==1) => 0 + 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) + def run() { + 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") { + // List of chars + object TestSequence07 { def doMatch1(xs: List[Char]) = xs match { - case List(x, y, _*) => x::y::Nil + 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 - //} - // - // Since the second case should have been unreachable all along, - // let's just comment this one out. - // - // 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() { + case List(x, y, z, w) => List(z, w) + } + def doMatch3(xs: Seq[Char]) = xs match { + case Seq(x, y, 'c', w@_*) => x :: y :: Nil + case Seq(x, y, z@_*) => z + } + def doMatch4(xs: Seq[Char]) = xs match { + case Seq(x, 'b') => x :: 'b' :: Nil + case Seq(x, y, z@_*) => z.toList + } + + def run() { + assertEquals(List('a', 'b'), doMatch1(List('a', 'b', 'c', 'd'))) + assertEquals(List('c', 'd'), doMatch2(List('a', 'b', 'c', 'd'))) + assertEquals(List('a', 'b'), doMatch3(List('a', 'b', 'c', 'd'))) + assertEquals(List('c', 'd'), doMatch4(List('a', 'b', 'c', 'd'))) + } + } + + // backquoted identifiers in pattern + object TestSequence08 { + def run() { val xs = List(2, 3) val ys = List(1, 2, 3) match { case x :: `xs` => xs @@ -311,20 +306,21 @@ object Test extends TestConsoleMain { } } - - object TestStream extends TestCase("unapply for Streams") { + // unapply for Streams + object TestStream { def sum(stream: Stream[Int]): Int = stream match { case Stream.Empty => 0 case Stream.cons(hd, tl) => hd + sum(tl) } - val str: Stream[Int] = List(1,2,3).iterator.toStream + val str: Stream[Int] = List(1, 2, 3).iterator.toStream - def runTest() = assertEquals(sum(str), 6) + def run() { assertEquals(sum(str), 6) } } - class Test1163_Order extends TestCase("bug#1163 order of temps must be preserved") { + // bug#1163 order of temps must be preserved + object Test1163_Order { abstract class Function case class Var(n: String) extends Function case class Const(v: Double) extends Function @@ -342,11 +338,11 @@ object Test extends TestConsoleMain { case n :: ls => flips((l take n reverse) ::: (l drop n)) + 1 } - def runTest() = assertEquals("both", (Var("x"),Var("y")), f) + def run() { assertEquals("both", (Var("x"), Var("y")), f) } } - class TestUnbox extends TestCase("unbox") { - override def runTest() { + object TestUnbox { + def run() { val xyz: (Int, String, Boolean) = (1, "abc", true) xyz._1 match { case 1 => "OK" @@ -356,82 +352,41 @@ object Test extends TestConsoleMain { } } - class Test806_818 { // #806, #811 compile only -- type of bind - // bug811 - trait Core { - trait NodeImpl - trait OtherImpl extends NodeImpl - trait DoubleQuoteImpl extends NodeImpl - def asDQ(node : OtherImpl) = node match { - case dq : DoubleQuoteImpl => dq - } + object Test903 { + class Person(_name: String, _father: Person) { + def name = _name + def father = _father } - trait IfElseMatcher { - type Node <: NodeImpl - trait NodeImpl - trait IfImpl - private def coerceIf(node: Node) = node match { - case node : IfImpl => node // var node is of type Node with IfImpl! - case _ => null - } + object PersonFather { + def unapply(p: Person): Option[Person] = + if (p.father == null) + None + else + Some(p.father) + } + def run() { + val p1 = new Person("p1", null) + val p2 = new Person("p2", p1) + assertEquals((p2.name, p1.name), p2 match { + case aPerson@PersonFather(f) => (aPerson.name, f.name) + case _ => "No father" + }) } } + object Bug881 { + object Foo1 { + class Bar1(val x: String) + def p(b: Bar1) = b.x - class Person(_name : String, _father : Person) { - def name = _name - def father = _father - } - - object PersonFather { - def unapply(p : Person) : Option[Person] = - if (p.father == null) - None - else - Some(p.father) - } - - class Test903 extends TestCase("bug903") { - - override def runTest = { - val p1 = new Person("p1",null) - val p2 = new Person("p2",p1) - assertEquals((p2.name, p1.name), p2 match { - case aPerson@PersonFather(f) => (aPerson.name,f.name) - case _ => "No father" - }) - } - } - - - object Test1253 { // compile-only - def foo(t : (Int, String)) = t match { - case (1, "") => throw new Exception - case (r, _) => throw new Exception(r.toString) + def unapply(s: String): Option[Bar1] = + Some(new Bar1(s)) } - } - - object Foo1258 { - case object baz - def foo(bar : AnyRef) = { - val Baz = baz - bar match { - case Baz => () - } + class Foo(j: Int) { + case class Bar(i: Int) } - } - - object Foo1 { - class Bar1(val x : String) - def p(b : Bar1) = Console.println(b.x) - - def unapply(s : String) : Option[Bar1] = - Some(new Bar1(s)) - } - - object bug881 extends TestCase("881") { - override def runTest = { + def run() { "baz" match { case Foo1(x) => Foo1.p(x) @@ -439,32 +394,31 @@ object Test extends TestConsoleMain { } } - // these are exhaustive matches // should not generate any warnings - def f[A](z:(Option[A],Option[A])) = z match { - case Pair(None,Some(x)) => 1 - case Pair(Some(x),None ) => 2 - case Pair(Some(x),Some(y)) => 3 + def f[A](z: (Option[A], Option[A])) = z match { + case Pair(None, Some(x)) => 1 + case Pair(Some(x), None) => 2 + case Pair(Some(x), Some(y)) => 3 case _ => 4 } - def g1[A](z:Option[List[A]]) = z match { + def g1[A](z: Option[List[A]]) = z match { case Some(Nil) => true - case Some(x::Nil) => true + case Some(x :: Nil) => true case _ => true } - def g2[A](z:Option[List[A]]) = z match { - case Some(x::Nil) => true + def g2[A](z: Option[List[A]]) = z match { + case Some(x :: Nil) => true case Some(_) => false case _ => true } - def h[A](x: (Option[A],Option[A])) = x match { - case Pair(None,_:Some[_]) => 1 - case Pair(_:Some[_],None ) => 2 - case Pair(_:Some[_],_:Some[_]) => 3 + def h[A](x: (Option[A], Option[A])) = x match { + case Pair(None, _: Some[_]) => 1 + case Pair(_: Some[_], None) => 2 + case Pair(_: Some[_], _: Some[_]) => 3 case _ => 4 } @@ -474,7 +428,7 @@ object Test extends TestConsoleMain { case (h1 :: t1, h2 :: t2) => 'c' } - def k (x:AnyRef) = x match { + def k(x: AnyRef) = x match { case null => 1 case _ => 2 } @@ -484,13 +438,11 @@ object Test extends TestConsoleMain { case FooBar => true } - object Bug1270 { // unapply13 - + object Bug1270 { // unapply13 class Sync { def apply(x: Int): Int = 42 def unapply(scrut: Any): Option[Int] = None } - class Buffer { object Get extends Sync @@ -498,111 +450,47 @@ object Test extends TestConsoleMain { case Get(y) if y > 4 => // y gets a wildcard type for some reason?! hack } } - - println((new Buffer).ps.isDefinedAt(42)) - } - - object Bug1261 { - sealed trait Elem - case class Foo() extends Elem - case class Bar() extends Elem - trait Row extends Elem - object Row { - def unapply(r: Row) = true - - def f(elem: Elem) { - elem match { - case Bar() => ; - case Row() => ; - case Foo() => ; // used to give ERROR (unreachable code) - }}} - } -/* - object Feature1196 { - def f(l: List[Int]) { } - - val l: Seq[Int] = List(1, 2, 3) - - l match { - case x @ List(1, _) => f(x) // x needs to get better type List[int] here - } - } -*/ - object TestIfOpt { //compile-only "test EqualsPatternClass in combination with MixTypes opt, bug #1278" - trait Token { - val offset : Int - def matching : Option[Token] - } - def go(tok : Token) = (tok.matching: @unchecked) match { - case Some(other) if true => Some(other) - case _ if true => tok.matching match { - case Some(other) => Some(other) - case _ => None - } + def run() { + assert(!(new Buffer).ps.isDefinedAt(42)) } } - object Go { // bug #1277 compile-only - trait Core { def next : Position = null } - trait Dir - val NEXT = new Dir{} - - trait Position extends Core - - (null:Core, null:Dir) match { - case (_, NEXT) if true => false // no matter whether NEXT test succeed, cannot throw column because of guard - case (at2:Position,dir) => true - } - } - - trait Outer { // bug #1282 compile-only - object No - trait File { - (null:AnyRef) match { - case No => false - } - } - } - - object cast2 { // #1281 - + object Bug1281 { class Sync { def unapplySeq(scrut: Int): Option[Seq[Int]] = { - println("unapplySeq: "+scrut) if (scrut == 42) Some(List(1, 2)) else None } } - class Buffer { val Get = new Sync - val jp: PartialFunction[Any, Any] = { - case Get(xs) => println(xs) // the argDummy <unapply-selector> should have proper arg.tpe (Int in this case) + case Get(xs) => // the argDummy <unapply-selector> should have proper arg.tpe (Int in this case) } } - - println((new Buffer).jp.isDefinedAt(40)) - println((new Buffer).jp.isDefinedAt(42)) + def run() { + assert(!(new Buffer).jp.isDefinedAt(40)) + assert(!(new Buffer).jp.isDefinedAt(42)) + } } - object ClassDefInGuard extends TestCase("classdef in guard") { // compile-and-load only - val z:PartialFunction[Any,Any] = { - case x::xs if xs.forall { y => y.hashCode() > 0 } => 1 + object ClassDefInGuard { + val z: PartialFunction[Any, Any] = { + case x :: xs if xs.forall { y => y.hashCode() > 0 } => 1 } - override def runTest { - val s:PartialFunction[Any,Any] = { - case List(4::xs) => 1 - case List(5::xs) => 1 - case _ if false => - case List(3::xs) if List(3:Any).forall { g => g.hashCode() > 0 } => 1 - } + def run() { + val s: PartialFunction[Any, Any] = { + case List(4 :: xs) => 1 + case List(5 :: xs) => 1 + case _ if false => + case List(3 :: xs) if List(3: Any).forall { g => g.hashCode() > 0 } => 1 + } z.isDefinedAt(42) s.isDefinedAt(42) // just load the thing, to see if the classes are found - (None:Option[Boolean] @unchecked) match { + (None: Option[Boolean] @unchecked) match { case x if x.map(x => x).isEmpty => } } @@ -610,33 +498,33 @@ object Test extends TestConsoleMain { // bug#457 - object Bug457 extends TestCase("Bug457") { + object Bug457 { def method1() = { val x = "Hello, world"; val y = 100; y match { case _: Int if (x match { case t => t.trim().length() > 0 }) => false; case _ => true; - }} + } + } def method2(): scala.Boolean = { val x: String = "Hello, world"; val y: scala.Int = 100; { var temp1: scala.Int = y var result: scala.Boolean = false - if ( - { - var result1: scala.Boolean = true; - if (y == 100) - result1 - else - throw new MatchError("crazybox.scala, line 11") - } && (y > 90) - ) + if ({ + var result1: scala.Boolean = true; + if (y == 100) + result1 + else + throw new MatchError("crazybox.scala, line 11") + } && (y > 90)) result - else - throw new MatchError("crazybox.scala, line 9") - }} + else + throw new MatchError("crazybox.scala, line 9") + } + } - override def runTest { + def run() { method1(); method2(); } @@ -644,7 +532,7 @@ object Test extends TestConsoleMain { // bug#508 - object Bug508 extends TestCase("aladdin #508") { + object Bug508 { case class Operator(x: Int); val EQ = new Operator(2); @@ -653,7 +541,7 @@ object Test extends TestConsoleMain { case Pair(EQ, 1) => "1" case Pair(EQ, 2) => "2" } - override def runTest { + def run() { val x = Pair(EQ, 0); assertEquals("0", analyze(x)); // should print "0" val y = Pair(EQ, 1); @@ -665,7 +553,7 @@ object Test extends TestConsoleMain { // bug#789 - object Bug789 extends TestCase("aladdin #789") { // don't do this at home + object Bug789 { // don't do this at home trait Impl @@ -675,21 +563,21 @@ object Test extends TestConsoleMain { type Both = SizeImpl with ColorImpl - def info(x:Impl) = x match { - case x:Both => "size "+x.size+" color "+x.color // you wish - case x:SizeImpl => "!size "+x.size - case x:ColorImpl => "color "+x.color - case _ => "n.a." + def info(x: Impl) = x match { + case x: Both => "size " + x.size + " color " + x.color // you wish + case x: SizeImpl => "!size " + x.size + case x: ColorImpl => "color " + x.color + case _ => "n.a." } - def info2(x:Impl) = x match { - case x:SizeImpl with ColorImpl => "size "+x.size+" color "+x.color // you wish - case x:SizeImpl => "!size "+x.size - case x:ColorImpl => "color "+x.color - case _ => "n.a." + def info2(x: Impl) = x match { + case x: SizeImpl with ColorImpl => "size " + x.size + " color " + x.color // you wish + case x: SizeImpl => "!size " + x.size + case x: ColorImpl => "color " + x.color + case _ => "n.a." } - override def runTest { + def run() { // make up some class that has a size class MyNode extends SizeImpl assertEquals("!size 42", info(new MyNode)) @@ -699,34 +587,36 @@ object Test extends TestConsoleMain { // bug#995 - object Bug995 extends TestCase("aladdin #995") { + object Bug995 { def foo(v: Any): String = v match { case s: Seq[_] => "Seq" // see hack in object Seq.unapplySeq case a: AnyRef if runtime.ScalaRunTime.isArray(a) => "Array" case _ => v.toString } - override def runTest { assertEquals("Array", foo(Array(0))) } + def run() { assertEquals("Array", foo(Array(0))) } } // bug#1093 (contribution #460) - object Bug1093 extends TestCase("aladdin #1093") { - override def runTest {assertTrue(Some(3) match { - case Some(1 | 2) => false - case Some(3) => true - })} + object Bug1093 { + def run() { + assert(Some(3) match { + case Some(1 | 2) => false + case Some(3) => true + }) + } } // bug#1094 (contribution #461) - object Bug1094 extends TestCase("aladdin #1094") { + object Bug1094 { def foo(ps: String*) = "Foo" case class X(p: String, ps: String*) def bar = X("a", "b") match { - case X(p, ps @ _*) => foo(ps : _*) + case X(p, ps@_*) => foo(ps: _*) } - override def runTest { assertEquals("Foo", bar) } + def run() { assertEquals("Foo", bar) } } // #2 @@ -740,17 +630,19 @@ object Test extends TestConsoleMain { } } - object Ticket2 extends TestCase("#2") { override def runTest { - val o1 = new Outer_2; val o2 = new Outer_2; val x: Any = o1.Foo(1, 2); val y: Any = o2.Foo(1, 2) - assertFalse("equals test returns true (but should not)", x equals y) - assertTrue("match enters wrong case", x match { - case o2.Foo(x, y) => false - case o1.Foo(x, y) => true - case _ => false - }) - }} + object Ticket2 { + def run() { + val o1 = new Outer_2; val o2 = new Outer_2; val x: Any = o1.Foo(1, 2); val y: Any = o2.Foo(1, 2) + assert(x != y, "equals test returns true (but should not)") + assert(x match { + case o2.Foo(x, y) => false + case o1.Foo(x, y) => true + case _ => false + }, "match enters wrong case") + } + } -// #11 + // #11 class MyException1 extends Exception @@ -761,31 +653,31 @@ object Test extends TestConsoleMain { class MyException2 extends MyException1 with SpecialException - object Ticket11 extends TestCase("#11") { - override def runTest { + object Ticket11 { + def run() { Array[Throwable](new Exception("abc"), - new MyException1, - new MyException2).foreach { e => - try { - throw e - } catch { - case e : SpecialException => { - assume(e.isInstanceOf[SpecialException]) - } - case e => { - assume(e.isInstanceOf[Throwable]) - } - } - } + new MyException1, + new MyException2).foreach { e => + try { + throw e + } catch { + case e: SpecialException => { + assume(e.isInstanceOf[SpecialException]) + } + case e => { + assume(e.isInstanceOf[Throwable]) + } + } + } } } // #37 - object Ticket37 extends TestCase("#37") { + object Ticket37 { def foo() {} - val (a,b) = { foo(); (2,3) } - override def runTest { assertEquals(this.a, 2) } + val (a, b) = { foo(); (2, 3) } + def run() { assertEquals(this.a, 2) } } // #44 @@ -793,146 +685,78 @@ object Test extends TestConsoleMain { trait _X { case class _Foo(); object _Bar { - def unapply(foo: _Foo):Boolean = true; + def unapply(foo: _Foo): Boolean = true; } } object Y extends _X { val foo = _Foo() foo match { case _Bar() => - case _ => assert(false) + case _ => assert(false) } } - object Ticket44 extends TestCase("#44") { - override def runTest { assert(Y.toString ne null) /*instantiate Y*/ } - } - - object Ticket211 extends TestCase("#211") { - override def runTest { - (Some(123):Option[Int]) match { - case (x:Option[a]) if false => {}; - case (y:Option[b]) => {}; - } - } + object Ticket44 { + def run() { assert(Y.toString ne null) /*instantiate Y*/ } } - sealed abstract class Tree - case class Node(l: Tree, v: Int, r: Tree) extends Tree - case object EmptyTree extends Tree - - object Ticket335 extends TestCase("#335") { // compile-only - override def runTest { - (EmptyTree: Tree @unchecked) match { - case Node(_,v,_) if (v == 0) => 0 - case EmptyTree => 2 + object Ticket211 { + def run() { + (Some(123): Option[Int]) match { + case (x: Option[a]) if false => {}; + case (y: Option[b]) => {}; } } } -// this test case checks nothing more than whether -// case N for object N is translated to a check scrutinee.equals(N) -// (or the other way round)... for a long time, we got away with -// scrutinee eq N, but those golden days are, apparently, over. - object Ticket346 extends TestCase("#346") { + // this test case checks nothing more than whether + // case N for object N is translated to a check scrutinee.equals(N) + // (or the other way round)... for a long time, we got away with + // scrutinee eq N, but those golden days are, apparently, over. + object Ticket346 { -class L(val content: List[Int]) { + class L(val content: List[Int]) { - def isEmpty = content.isEmpty - def head = content.head - def tail = content.tail + def isEmpty = content.isEmpty + def head = content.head + def tail = content.tail - override def equals(that: Any): Boolean = { + override def equals(that: Any): Boolean = { val result = that.isInstanceOf[N.type] - println("L("+content+").equals("+that+") returning "+result) + println("L(" + content + ").equals(" + that + ") returning " + result) result + } } -} -object N extends L(Nil) { - - override def equals(that: Any): Boolean = { - val result = (that.isInstanceOf[L] && that.asInstanceOf[L].isEmpty) - //println("N.equals("+that+") returning "+result) - result + object N extends L(Nil) { + override def equals(that: Any): Boolean = + (that.isInstanceOf[L] && that.asInstanceOf[L].isEmpty) } -} -object C { + object C { - def unapply(xs: L): Option[(Int, L)] = { - if (xs.isEmpty) - { println("xs is empty"); None } + def unapply(xs: L): Option[(Int, L)] = { + if (xs.isEmpty) { println("xs is empty"); None } else - Some((xs.head, new L(xs.tail))) - } - -} - + Some((xs.head, new L(xs.tail))) + } - def empty(xs : L) : Boolean = xs match { - case N => true - case _ => false } - def singleton(xs : L) : Boolean = xs match { - case C(_, N) => true - case _ => false + def empty(xs: L): Boolean = xs match { + case N => true + case _ => false } -override def runTest() { - assertTrue(empty( new L(Nil) )) - assertTrue(singleton( new L(List(1)) )) -} - -} // end Ticket346 - - object Ticket495bis { // compile-only - def signum(x: Int): Int = - x match { - case 0 => 0 - case _ if x < 0 => -1 - case _ if x > 0 => 1 - } - def pair_m(x: Int, y: Int) = - (x,y) match { - case (_, 0) => 0 - case (-1, _) => -1 - case (_, _) => 1 - } - } - - object Ticket522 { // compile-only - class Term[X] - object App { - // i'm hidden - case class InternalApply[Y,Z](fun:Y=>Z, arg:Y) extends Term[Z] - - def apply[Y,Z](fun:Y=>Z, arg:Y): Term[Z] = - new InternalApply[Y,Z](fun,arg) - - def unapply[X](arg: Term[X]): Option[(Y=>Z,Y)] forSome {type Y; type Z} = - arg match { - case i:InternalApply[y,z] => Some(i.fun, i.arg) - case _ => None - } - } - - App({x: Int => x}, 5) match { - case App(arg, a) => - } - } // end Ticket522 - + def singleton(xs: L): Boolean = xs match { + case C(_, N) => true + case _ => false + } - object Ticket710 { // compile-only - def method { - sealed class Parent() - case object Child extends Parent() - val x: Parent = Child - x match { - case Child => () - } + def run() { + assert(empty(new L(Nil))) + assert(singleton(new L(List(1)))) } - } -} + } // end Ticket346 +} |