summaryrefslogtreecommitdiff
path: root/test/files/run
diff options
context:
space:
mode:
Diffstat (limited to 'test/files/run')
-rw-r--r--test/files/run/lists-run.scala171
-rw-r--r--test/files/run/patmatnew.scala858
-rw-r--r--test/files/run/unapply.scala77
-rw-r--r--test/files/run/unittest_collection.scala123
-rw-r--r--test/files/run/unittest_io.scala41
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))
}
}
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-29 14:10:55 +0000