Removes SUnit (long deprecated!) from the stand...

Removes SUnit (long deprecated!) from the standard library.

the relatively small number of partest tests in Scala's suite that
were still using SUnit now either just use regular asserts, or they
print stuff that partest checks with a .check file. Also fixed some bad
indentation, removed ancient useless-looking commented-out code, etc.

Contributed by Seth Tisue (way to go seth) no review.

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
 
+}