diff options
author | Paul Phillips <paulp@improving.org> | 2011-05-19 20:06:19 +0000 |
---|---|---|
committer | Paul Phillips <paulp@improving.org> | 2011-05-19 20:06:19 +0000 |
commit | 4afa092314487c0095ff9fd5756d05340f6150b0 (patch) | |
tree | d3cf421e67192041f78858fe10735505f4891b3c /test/files/run | |
parent | 7595671ec3929aa4ac978826521300a900250214 (diff) | |
download | scala-4afa092314487c0095ff9fd5756d05340f6150b0.tar.gz scala-4afa092314487c0095ff9fd5756d05340f6150b0.tar.bz2 scala-4afa092314487c0095ff9fd5756d05340f6150b0.zip |
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.
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)) } } } |