diff options
Diffstat (limited to 'test/files/run')
-rw-r--r-- | test/files/run/lists-run.scala | 171 | ||||
-rw-r--r-- | test/files/run/patmatnew.scala | 858 | ||||
-rw-r--r-- | test/files/run/unapply.scala | 77 | ||||
-rw-r--r-- | test/files/run/unittest_collection.scala | 123 | ||||
-rw-r--r-- | test/files/run/unittest_io.scala | 41 |
5 files changed, 506 insertions, 764 deletions
diff --git a/test/files/run/lists-run.scala b/test/files/run/lists-run.scala index 6871a96183..9e9e49e818 100644 --- a/test/files/run/lists-run.scala +++ b/test/files/run/lists-run.scala @@ -1,99 +1,84 @@ -//############################################################################ -// Lists -//############################################################################ - -//############################################################################ - -import testing.SUnit._ - /** Test the Scala implementation of class <code>scala.List</code>. * * @author Stephane Micheloud */ -object Test extends TestConsoleMain { - def suite = new TestSuite( - Test_multiset, // multiset operations: union, intersect, diff - Test1, //count, exists, filter, .. - Test2, //#468 - Test3, //#1691 - Test4, //#1721 - Test5 - ) +object Test { + def main(args: Array[String]) { + Test_multiset.run() // multiset operations: union, intersect, diff + Test1.run() //count, exists, filter, .. + Test2.run() //#468 + Test3.run() //#1691 + Test4.run() //#1721 + Test5.run() + } } -object Test_multiset extends TestCase("multiset") with Assert { - override def enableStackTrace = false - override def runTest { +object Test_multiset { + def run() { def isSubListOf[A](thiz: List[A], that: List[A]): Boolean = thiz forall (that contains _) val xs = List(1, 1, 2) val ys = List(1, 2, 2, 3) - assertEquals("xs_union_ys", List(1, 1, 2, 1, 2, 2, 3), xs union ys) - assertEquals("ys_union_xs", List(1, 2, 2, 3, 1, 1, 2), ys union xs) - assertEquals("xs_intersect_ys", List(1, 2), xs intersect ys) - assertEquals("ys_intersect_xs", List(1, 2), ys intersect xs) - assertEquals("xs_diff_ys", List(1), xs diff ys) - assertEquals("ys_diff_xs", List(2, 3), ys diff xs) - assertTrue("xs_subset_ys", isSubListOf(xs -- ys, xs diff ys)) + assert(List(1, 1, 2, 1, 2, 2, 3) == (xs union ys), "xs_union_ys") + assert(List(1, 2, 2, 3, 1, 1, 2) == (ys union xs), "ys_union_xs") + assert(List(1, 2) == (xs intersect ys), "xs_intersect_ys") + assert(List(1, 2) == (ys intersect xs), "ys_intersect_xs") + assert(List(1) == (xs diff ys), "xs_diff_ys") + assert(List(2, 3) == (ys diff xs), "ys_diff_xs") + assert(isSubListOf(xs -- ys, xs diff ys), "xs_subset_ys") val zs = List(0, 1, 1, 2, 2, 2) - assertEquals("zs_union_ys", List(0, 1, 1, 2, 2, 2, 1, 2, 2, 3), zs union ys) - assertEquals("ys_union_zs", List(1, 2, 2, 3, 0, 1, 1, 2, 2, 2), ys union zs) - assertEquals("zs_intersect_ys", List(1, 2, 2), zs intersect ys) - assertEquals("ys_intersect_zs", List(1, 2, 2), ys intersect zs) - assertEquals("zs_diff_ys", List(0, 1, 2), zs diff ys) - assertEquals("ys_diff_zs", List(3), ys diff zs) - assertTrue("xs_subset_ys", isSubListOf(zs -- ys, zs diff ys)) + assert(List(0, 1, 1, 2, 2, 2, 1, 2, 2, 3) == (zs union ys), "zs_union_ys") + assert(List(1, 2, 2, 3, 0, 1, 1, 2, 2, 2) == (ys union zs), "ys_union_zs") + assert(List(1, 2, 2) == (zs intersect ys), "zs_intersect_ys") + assert(List(1, 2, 2) == (ys intersect zs), "ys_intersect_zs") + assert(List(0, 1, 2) == (zs diff ys), "zs_diff_ys") + assert(List(3) == (ys diff zs), "ys_diff_zs") + assert(isSubListOf(zs -- ys, zs diff ys), "xs_subset_ys") val ws = List(2) - assertEquals("ws_union_ys", List(2, 1, 2, 2, 3), ws union ys) - assertEquals("ys_union_ws", List(1, 2, 2, 3, 2), ys union ws) - assertEquals("ws_intersect_ys", List(2), ws intersect ys) - assertEquals("ys_intersect_ws", List(2), ys intersect ws) - assertEquals("ws_diff_ys", List(), ws diff ys) - assertEquals("ys_diff_ws", List(1, 2, 3), ys diff ws) - assertTrue("ws_subset_ys", isSubListOf(ws -- ys, ws diff ys)) + assert(List(2, 1, 2, 2, 3) == (ws union ys), "ws_union_ys") + assert(List(1, 2, 2, 3, 2) == (ys union ws), "ys_union_ws") + assert(List(2) == (ws intersect ys), "ws_intersect_ys") + assert(List(2) == (ys intersect ws), "ys_intersect_ws") + assert(List() == (ws diff ys), "ws_diff_ys") + assert(List(1, 2, 3) == (ys diff ws), "ys_diff_ws") + assert(isSubListOf(ws -- ys, ws diff ys), "ws_subset_ys") val vs = List(3, 2, 2, 1) - assertEquals("xs_union_vs", List(1, 1, 2, 3, 2, 2, 1), xs union vs) - assertEquals("vs_union_xs", List(3, 2, 2, 1, 1, 1, 2), vs union xs) - assertEquals("xs_intersect_vs", List(1, 2), xs intersect vs) - assertEquals("vs_intersect_xs", List(2, 1), vs intersect xs) - assertEquals("xs_diff_vs", List(1), xs diff vs) - assertEquals("vs_diff_xs", List(3, 2), vs diff xs) - assertTrue("xs_subset_vs", isSubListOf(xs -- vs, xs diff vs)) + assert(List(1, 1, 2, 3, 2, 2, 1) == (xs union vs), "xs_union_vs") + assert(List(3, 2, 2, 1, 1, 1, 2) == (vs union xs), "vs_union_xs") + assert(List(1, 2) == (xs intersect vs), "xs_intersect_vs") + assert(List(2, 1) == (vs intersect xs), "vs_intersect_xs") + assert(List(1) == (xs diff vs), "xs_diff_vs") + assert(List(3, 2) == (vs diff xs), "vs_diff_xs") + assert(isSubListOf(xs -- vs, xs diff vs), "xs_subset_vs") // tests adapted from Thomas Jung - assertTrue( - "be symmetric after sorting", { + assert({ def sort(zs: List[Int]) = zs sort ( _ > _ ) sort(xs intersect ys) == sort(ys intersect xs) - }) - assertTrue( - "obey min cardinality", { + }, "be symmetric after sorting") + assert({ def cardinality[A](zs: List[A], e: A): Int = zs count (e == _) val intersection = xs intersect ys xs forall (e => cardinality(intersection, e) == (cardinality(xs, e) min cardinality(ys, e))) - }) - assertTrue( - "maintain order", { + }, "obey min cardinality") + assert({ val intersection = xs intersect ys val unconsumed = xs.foldLeft(intersection){(rest, e) => if (! rest.isEmpty && e == rest.head) rest.tail else rest } unconsumed.isEmpty - }) - assertTrue( - "has the list as again intersection", - xs == (xs intersect xs) - ) + }, "maintain order") + assert(xs == (xs intersect xs), + "has the list as again intersection") } } -object Test1 extends TestCase("ctor") with Assert { - override def enableStackTrace = false - override def runTest { +object Test1 { + def run() { val xs1 = List(1, 2, 3) val xs2 = List('a', 'b') val xs3 = List(List(1, 2), List(4, 5)) @@ -103,100 +88,96 @@ object Test1 extends TestCase("ctor") with Assert { { val n1 = xs1 count { e => e % 2 != 0 } val n2 = xs4 count { e => e < 5 } - assertEquals("check_count", 4, n1 + n2) + assert(4 == (n1 + n2), "check_count") } { val b1 = xs1 exists { e => e % 2 == 0 } val b2 = xs4 exists { e => e == 5 } - assertEquals("check_exists", false , b1 & b2) + assert(!(b1 & b2), "check_exists") } { val ys1 = xs1 filter { e => e % 2 == 0 } val ys2 = xs4 filter { e => e < 5 } - assertEquals("check_filter", 3, ys1.length + ys2.length) + assert(3 == ys1.length + ys2.length, "check_filter") } { val n1 = xs1.foldLeft(0)((e1, e2) => e1 + e2) val ys1 = xs4.foldLeft(List[Int]())((e1, e2) => e2 :: e1) - assertEquals("check_foldLeft", 10, n1 + ys1.length) + assert(10 == n1 + ys1.length, "check_foldLeft") } { val b1 = xs1 forall { e => e < 10} val b2 = xs4 forall { e => e % 2 == 0 } - assertEquals("check_forall", true, b1 & b2) + assert(b1 & b2, "check_forall") } { val ys1 = xs1 filterNot { e => e % 2 != 0 } val ys2 = xs4 filterNot { e => e < 5 } - assertEquals("check_remove", 3, ys1.length + ys2.length) + assert(3 == ys1.length + ys2.length, "check_remove") } { val ys1 = xs1 zip xs2 val ys2 = xs1 zip xs3 - assertEquals("check_zip", 4, ys1.length + ys2.length) + assert(4 == ys1.length + ys2.length, "check_zip") } { val ys1 = xs1.zipAll(xs2, 0, '_') val ys2 = xs2.zipAll(xs1, '_', 0) val ys3 = xs1.zipAll(xs3, 0, List(-1)) - assertEquals("check_zipAll", 9, ys1.length + ys2.length + ys3.length) + assert(9 == ys1.length + ys2.length + ys3.length, "check_zipAll") } } } -object Test2 extends TestCase("t0468") with Assert { - override def enableStackTrace = false - override def runTest { +object Test2 { + def run() { val xs1 = List(1, 2, 3) val xs2 = List(0) val ys1 = xs1 ::: List(4) - assertEquals("check_:::", List(1, 2, 3, 4), ys1) + assert(List(1, 2, 3, 4) == ys1, "check_:::") val ys2 = ys1 - 4 - assertEquals("check_-", xs1, ys2) + assert(xs1 == ys2, "check_-") val n2 = (xs1 ++ ys1).length val n3 = (xs1 ++ Nil).length val n4 = (xs1 ++ ((new collection.mutable.ArrayBuffer[Int]) + 0)).length - assertEquals("check_++", 14, n2 + n3 + n4) + assert(14 == n2 + n3 + n4, "check_++") } } -object Test3 extends TestCase("t1691") with Assert { - override def enableStackTrace = false - override def runTest { +object Test3 { + def run() { try { List.range(1, 10, 0) } catch { case e: IllegalArgumentException => () case _ => throw new Error("List.range(1, 10, 0)") } - assertEquals(List.range(10, 0, -2), - List(10, 8, 6, 4, 2)) + assert(List.range(10, 0, -2) == List(10, 8, 6, 4, 2)) } } -object Test4 extends TestCase("t1721") with Assert { - override def enableStackTrace = false - override def runTest { - assertTrue(List(1,2,3).endsWith(List(2,3))) - assertFalse(List(1,2,3).endsWith(List(1,3))) - assertTrue(List(1,2,3).endsWith(List())) - assertFalse(List(1,2,3).endsWith(List(0,1,2,3))) - assertTrue(List(1,2,3).endsWith(List(1,2,3))) - assertFalse(List().endsWith(List(1,2,3))) - assertTrue(List().endsWith(List())) +object Test4 { + def run() { + assert(List(1,2,3).endsWith(List(2,3))) + assert(!List(1,2,3).endsWith(List(1,3))) + assert(List(1,2,3).endsWith(List())) + assert(!List(1,2,3).endsWith(List(0,1,2,3))) + assert(List(1,2,3).endsWith(List(1,2,3))) + assert(!List().endsWith(List(1,2,3))) + assert(List().endsWith(List())) } } -object Test5 extends TestCase("list pattern matching") { +object Test5 { def show(xs: List[String]) = xs match { case "foo" :: args => args.toString case List(x) => x.toString case Nil => "Nil" } - override def runTest { + def run() { assert(show(List()) == "Nil") assert(show(List("a")) == "a") assert(show(List("foo", "b")) == "List(b)") 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 +} diff --git a/test/files/run/unapply.scala b/test/files/run/unapply.scala index 810616850d..85c384ab1f 100644 --- a/test/files/run/unapply.scala +++ b/test/files/run/unapply.scala @@ -1,12 +1,11 @@ -import scala.testing.SUnit._ - -object Test extends TestConsoleMain { - def suite = new TestSuite( - Foo, - Mas, - LisSeqArr, - StreamFoo - ) +object Test { + def main(args: Array[String]) { + Foo.run() + Mas.run() + LisSeqArr.run() + StreamFoo.run() + Test1256.run() + } } // this class is used for representation @@ -31,7 +30,8 @@ object FaaPreciseSome { object VarFoo { def unapply(a : Int)(implicit b : Int) : Option[Int] = Some(a + b) } -object Foo extends TestCase("Foo") with Assert { + +object Foo { def unapply(x: Any): Option[Product2[Int, String]] = x match { case y: Bar => Some(Tuple(y.size, y.name)) case _ => None @@ -51,22 +51,22 @@ object Foo extends TestCase("Foo") with Assert { def doMatch5(b:Bar) = (b:Any) match { case FaaPreciseSome(n:String) => n } - override def runTest { + def run() { val b = new Bar - assertEquals(doMatch1(b),(50,"medium")) - assertEquals(doMatch2(b),null) - assertEquals(doMatch3(b),"medium") - assertEquals(doMatch4(b),"medium") - assertEquals(doMatch5(b),"medium") + assert(doMatch1(b) == (50,"medium")) + assert(doMatch2(b) == null) + assert(doMatch3(b) == "medium") + assert(doMatch4(b) == "medium") + assert(doMatch5(b) == "medium") implicit val bc: Int = 3 - assertEquals(4 match { + assert(7 == (4 match { case VarFoo(x) => x - }, 7) + })) } } // same, but now object is not top-level -object Mas extends TestCase("Mas") with Assert { +object Mas { object Gaz { def unapply(x: Any): Option[Product2[Int, String]] = x match { case y: Baz => Some(Tuple(y.size, y.name)) @@ -77,57 +77,46 @@ object Mas extends TestCase("Mas") with Assert { var size: Int = 60 var name: String = "too large" } - def runTest { + def run() { val b = new Baz - assertEquals(b match { + assert((60,"too large") == (b match { case Gaz(s:Int, n:String) => (s,n) - }, (60,"too large")) + })) } } -object LisSeqArr extends TestCase("LisSeqArr") with Assert { -// def foo[A](x:List[A]) {} - def runTest { - assertEquals((List(1,2,3): Any) match { case List(x,y,_*) => (x,y)}, (1,2)) - assertEquals((List(1,2,3): Any) match { case Seq(x,y,_*) => (x,y)}, (1,2)) - //assertEquals((Array(1,2,3): Any) match { case Seq(x,y,_*) => (x,y)}, (1,2)) - //assertEquals((Array(1,2,3): Any) match { case Array(x,y,_*) => {x,y}}, {1,2}) - - // just compile, feature request #1196 -// (List(1,2,3): Any) match { -// case a @ List(x,y,_*) => foo(a) -// } - +object LisSeqArr { + def run() { + assert((1,2) == ((List(1,2,3): Any) match { case List(x,y,_*) => (x,y)})) + assert((1,2) == ((List(1,2,3): Any) match { case Seq(x,y,_*) => (x,y)})) } } - -object StreamFoo extends TestCase("unapply for Streams") with Assert { - //val x:Stream[Int] = Stream.cons(1,x) - +object StreamFoo { def sum(stream: Stream[Int]): Int = stream match { case Stream.Empty => 0 case Stream.cons(hd, tl) => hd + sum(tl) } - override def runTest { + def run() { val str: Stream[Int] = List(1,2,3).toStream - assertEquals(sum(str), 6) + assert(6 == sum(str)) } } -object Test1256 extends TestCase("1256") { +object Test1256 { class Sync { def unapply(scrut: Any): Boolean = false } class Buffer { val Get = new Sync - val jp: PartialFunction[Any, Any] = { case Get() => } } - override def runTest { assertFalse((new Buffer).jp.isDefinedAt(42)) } + def run() { + assert(!(new Buffer).jp.isDefinedAt(42)) + } } diff --git a/test/files/run/unittest_collection.scala b/test/files/run/unittest_collection.scala index d45c23d4b5..822e2b0c98 100644 --- a/test/files/run/unittest_collection.scala +++ b/test/files/run/unittest_collection.scala @@ -1,103 +1,58 @@ - object Test { - import scala.testing.SUnit._ import scala.collection.mutable.{ArrayBuffer, Buffer, BufferProxy, ListBuffer} - trait BufferTest extends Assert { - def doTest(x:Buffer[String]) = { - // testing method += - x += "one" - assertEquals("retrieving 'one'", x(0), "one") - assertEquals("length A ", x.length, 1) - x += "two" - assertEquals("retrieving 'two'", x(1), "two") - assertEquals("length B ", x.length, 2) - - // testing method -= (removing last element) - x -= "two" - - assertEquals("length C ", x.length, 1) - - try { x(1); fail("no exception for removed element") } - catch { case i:IndexOutOfBoundsException => } - - try { x.remove(1); fail("no exception for removed element") } - catch { case i:IndexOutOfBoundsException => } - - x += "two2" - assertEquals("length D ", x.length, 2) - - // removing first element - x.remove(0) - assertEquals("length E ", x.length, 1) - - // toList - assertEquals("toList ", x.toList, List("two2")) - - // clear - x.clear - assertEquals("length F ", x.length, 0) - - // copyToBuffer - x += "a" - x += "b" - val dest = new ArrayBuffer[String] - x copyToBuffer dest - assertEquals("dest", List("a", "b"), dest.toList) - assertEquals("source", List("a", "b"), x.toList) + def main(args: Array[String]) { + test(collection.mutable.ArrayBuffer[String]()) + test(collection.mutable.ListBuffer[String]()) + class BBuf(z:ListBuffer[String]) extends BufferProxy[String] { + def self = z } + test(new BBuf(collection.mutable.ListBuffer[String]())) } - class TArrayBuffer extends TestCase("collection.mutable.ArrayBuffer") with Assert with BufferTest { - - var x: ArrayBuffer[String] = _ + def test(x: Buffer[String]) { + // testing method += + x += "one" + assert(x(0) == "one", "retrieving 'one'") + assert(x.length == 1, "length A") + x += "two" + assert(x(1) == "two", "retrieving 'two'") + assert(x.length == 2, "length B") - override def runTest = { setUp; doTest(x); tearDown } + // testing method -= (removing last element) + x -= "two" - override def setUp = { x = new scala.collection.mutable.ArrayBuffer } + assert(x.length == 1, "length C") - override def tearDown = { x.clear; x = null } - } + try { x(1); sys.error("no exception for removed element") } + catch { case i:IndexOutOfBoundsException => } - class TListBuffer extends TestCase("collection.mutable.ListBuffer") with Assert with BufferTest { + try { x.remove(1); sys.error("no exception for removed element") } + catch { case i:IndexOutOfBoundsException => } - var x: ListBuffer[String] = _ + x += "two2" + assert(x.length == 2, "length D") - override def runTest = { setUp; doTest(x); tearDown } + // removing first element + x.remove(0) + assert(x.length == 1, "length E") - override def setUp = { x = new scala.collection.mutable.ListBuffer } + // toList + assert(x.toList == List("two2"), "toList") - override def tearDown = { x.clear; x = null } + // clear + x.clear() + assert(x.length == 0, "length 0") + assert(x.isEmpty, "isEmpty") + // copyToBuffer + x += "a" + x += "b" + val dest = new ArrayBuffer[String] + x.copyToBuffer(dest) + assert(List("a", "b") == dest.toList, "dest") + assert(List("a", "b") == x.toList, "source") } - class TBufferProxy extends TestCase("collection.mutable.BufferProxy") with Assert with BufferTest { - - class BBuf(z:ListBuffer[String]) extends BufferProxy[String] { - def self = z - } - - var x: BufferProxy[String] = _ - - override def runTest = { setUp; doTest(x); tearDown } - - override def setUp = { x = new BBuf(new scala.collection.mutable.ListBuffer) } - - override def tearDown = { x.clear; x = null } - - } - - def main(args:Array[String]) = { - val ts = new TestSuite( - //new TArrayBuffer, - new TListBuffer//, - //new TBufferProxy - ) - val tr = new TestResult() - ts.run(tr) - for (failure <- tr.failures) { - Console.println(failure) - } - } } diff --git a/test/files/run/unittest_io.scala b/test/files/run/unittest_io.scala index 974dcff5b3..4d2869ec3b 100644 --- a/test/files/run/unittest_io.scala +++ b/test/files/run/unittest_io.scala @@ -1,42 +1,35 @@ -import testing.SUnit._ +object Test { -object Test extends TestConsoleMain { - def suite = new TestSuite(new UTF8Tests, new SourceTest) + def main(args: Array[String]) { + UTF8Tests.run() + SourceTest.run() + } - class UTF8Tests extends TestCase("UTF8Codec") { + object UTF8Tests { import io.UTF8Codec.encode - - def runTest { - assertEquals(new String( encode(0x004D), "utf8"), new String(Array(0x004D.asInstanceOf[Char]))) - assertEquals(new String( encode(0x0430), "utf8"), new String(Array(0x0430.asInstanceOf[Char]))) - assertEquals(new String( encode(0x4E8C), "utf8"), new String(Array(0x4E8C.asInstanceOf[Char]))) - assertEquals(new String(encode(0x10302), "utf8"), new String(Array(0xD800.asInstanceOf[Char], - 0xDF02.asInstanceOf[Char]))) - + def run() { + assert(new String( encode(0x004D), "utf8") == new String(Array(0x004D.asInstanceOf[Char]))) + assert(new String( encode(0x0430), "utf8") == new String(Array(0x0430.asInstanceOf[Char]))) + assert(new String( encode(0x4E8C), "utf8") == new String(Array(0x4E8C.asInstanceOf[Char]))) + assert(new String(encode(0x10302), "utf8") == new String(Array(0xD800.asInstanceOf[Char], + 0xDF02.asInstanceOf[Char]))) // a client val test = "{\"a\":\"\\u0022\"}" val Expected = ("a","\"") - assertTrue(scala.util.parsing.json.JSON.parse(test) match { + assert(scala.util.parsing.json.JSON.parse(test) match { case Some(List(Expected)) => true case z => Console.println(z); false }) } } - class SourceTest extends TestCase("Source") { - def runTest { - val s = "Here is a test string" + object SourceTest { + def run() { + val s = "Here is a test string" val f = io.Source.fromBytes(s.getBytes("utf-8")) val b = new collection.mutable.ArrayBuffer[Char]() f.copyToBuffer(b) - assertEquals(s, new String(b.toArray)) - - /* todo: same factories for BufferedSource and Source - val g = io.BufferedSource.fromBytes(s.getBytes("utf-8")) - val c = new collection.mutable.ArrayBuffer[Char]() - g.copyToBuffer(c) - assertEquals(s, new String(c.toArray)) - */ + assert(s == new String(b.toArray)) } } } |