From 3272a4bfb30240e0d83befe1cfed0a0fd2584edd Mon Sep 17 00:00:00 2001 From: Philipp Haller Date: Fri, 1 Feb 2008 15:36:23 +0000 Subject: Moved 'patmatnew' from 'run' to 'pos' --- test/files/run/patmatnew.check | 2 - test/files/run/patmatnew.scala | 828 ----------------------------------------- 2 files changed, 830 deletions(-) delete mode 100644 test/files/run/patmatnew.check delete mode 100644 test/files/run/patmatnew.scala (limited to 'test/files/run') diff --git a/test/files/run/patmatnew.check b/test/files/run/patmatnew.check deleted file mode 100644 index 0747cddefb..0000000000 --- a/test/files/run/patmatnew.check +++ /dev/null @@ -1,2 +0,0 @@ -warning: there were unchecked warnings; re-run with -unchecked for details -one warning found diff --git a/test/files/run/patmatnew.scala b/test/files/run/patmatnew.scala deleted file mode 100644 index 51c823f7ac..0000000000 --- a/test/files/run/patmatnew.scala +++ /dev/null @@ -1,828 +0,0 @@ -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 Pair(x :: xs1, y :: ys1) => Pair(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 - ) - - class Foo(j:Int) { - case class Bar(i:Int) - } - class SimpleUnapply extends TestCase("simpleUnapply") { - override def runTest() { // from sortedmap, old version - List((1,2)).head match { - case kv @ Pair(key, _) => kv.toString + " " + key.toString - } - - - } - } - - object SeqUnapply extends TestCase("seqUnapply") { - case class SFB(i:int,xs:List[Int]) - override def runTest() { - List(1,2) match { - case List(1) => assert(false, "wrong case") - case List(1,2,xs @ _*) => assert(xs.isEmpty, "not empty") - case Nil => assert(false, "wrong case") - } - 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) ; - } - } - } - - class TestSimpleIntSwitch extends TestCase("SimpleIntSwitch") { - override def runTest() = { - assertEquals("s1", 1, 1 match { - case 3 => 3 - case 2 => 2 - case 1 => 1 - case 0 => 0 - }) - assertEquals("s2", 1, 1 match { - case 1 => 1 - case _ => 0 - }) - assertEquals("s2boxed", 1, (1:Any) match { - case 1 => 1 - case _ => 0 - }) - assertEquals("s3", 1, ("hello") match { - case s:String => 1 - //case _ => 0 // unreachable! - }) - val xyz: (int, String, boolean) = (1, "abc", true); - assertEquals("s4", 1, xyz._1 match { - case 1 => 1 - case _ => 0 - }) - } - } - class Test717 extends TestCase("#717 test path of case classes") { - 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 - } - assertTrue("ok", res); - } - } - - object TestGuards extends TestCase("multiple guards for same pattern") with Shmeez { - val tree:Tree = Beez(2) - override def runTest = { - 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 { - case Beez(x) if x == 3 => true - case Beez(x) if x == 2 => false - } - assertTrue("ok", ret); - } - } - - object TestEqualsPatternOpt extends TestCase("test EqualsPatternClass in combination with MixTypes opt, bug #1276") { - val NoContext = new Object - override def runTest { - 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)") { - 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 - } - override def runTest() { - val list1 = List() - assertEquals(doMatch(list1), "ok") - val list2 = List("1","2","3") - assertEquals(doMatch(list2), "ok") - val list3 = List("1","2","3") - assertEquals(doMatch2(list3), List("2","3")) - } - } - - - object TestSequence02 extends TestCase("due (all ignoring patterns on Seq)") { - def doMatch(l: Seq[String]): String = l match { - case Seq(_*) => "ok" - } - override def runTest() { - val list1 = List() - assertEquals(doMatch(list1), "ok") - val list2 = List("1", "2", "3") - assertEquals(doMatch(list2), "ok") - val array3 = Array[String]() - assertEquals(doMatch(array3), "ok") - val array4 = Array[String]("ga", "gu") - assertEquals(doMatch(array4), "ok") - } - } - - object TestSequence03 extends TestCase("tre (right-ignoring patterns on List, defaults)") { - def doMatch(xs: List[String]): String = xs match { - case List(_,_,_,_*) => "ok" - case _ => "not ok" - } - override def runTest() { - val list1 = List() - assertEquals(doMatch(list1), "not ok") - val list2 = List("1","2","3") - assertEquals(doMatch(list2), "ok") - 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)") { - case class Foo(i: Int, chars: Char*) - - override def runTest() = { - val a = Foo(0, 'a') match { - case Foo(i, c, chars @ _*) => c - case _ => null - } - assertEquals(a, 'a') - - val b = Foo(0, 'a') match { - case Foo(i, chars @ _*) => 'b' - case _ => null - } - assertEquals(b, 'b') - } - } - - object TestSequence05 extends TestCase("cinque (sealed case class with ignoring seq patterns)") { - sealed abstract class Con; - - case class Foo() extends Con - case class Bar(xs:Con*) extends Con - - override def runTest() { - 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() ) - } - } - - object TestSequence06 extends TestCase("sei (not regular) fancy guards / bug#644 ") { - - case class A(i: Any) - - def doMatch(x: Any, bla: int) = x match { - 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) - } - - } - - object TestSequence07 extends TestCase("sette List of chars") { - def doMatch1(xs: List[char]) = xs match { - 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 - //} - 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() { - val xs = List(2, 3) - val ys = List(1, 2, 3) match { - case x :: `xs` => xs - case _ => Nil - } - assertEquals(xs, ys) - } - } - - - object TestStream extends TestCase("unapply for Streams") { - def sum(stream: Stream[int]): int = - stream match { - case Stream.empty => 0 - case Stream.cons(hd, tl) => hd + sum(tl) - } - - val str: Stream[int] = Stream.fromIterator(List(1,2,3).elements) - - def runTest() = assertEquals(sum(str), 6) - } - - class Test1163_Order extends TestCase("bug#1163 order of temps must be preserved") { - abstract class Function - case class Var(n: String) extends Function - case class Const(v: double) extends Function - - def f(): (Function, Function) = { - (Var("x"): Function, Var("y"): Function) match { - case (Const(v), Const(w)) => throw new Error - case (leftOne, Var("z")) => throw new Error - case (leftTwo, rightTwo) => (leftTwo, rightTwo) // was giving "y","x" - } - } - - def flips(l: List[int]): int = (l: @unchecked) match { - case 1 :: ls => 0 - case n :: ls => flips((l take n reverse) ::: (l drop n)) + 1 - } - - def runTest() = assertEquals("both", (Var("x"),Var("y")), f) - } - - class TestUnbox extends TestCase("unbox") { - override def runTest() { - val xyz: (int, String, boolean) = (1, "abc", true) - xyz._1 match { - case 1 => "OK" - case 2 => assert(false); "KO" - case 3 => assert(false); "KO" - } - } - } - - 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; - } - } - - 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; - } - } - } - - - 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) - } - } - - object Foo1258 { - case object baz - def foo(bar : AnyRef) = { - val Baz = baz - bar match { - case Baz => () - } - } - } - - 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 = { - "baz" match { - case Foo1(x) => - Foo1.p(x) - } - } - } - - - // 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 - case _ => 4 - } - - def g1[A](z:Option[List[A]]) = z match { - case Some(Nil) => true - case Some(x::Nil) => true - case _ => 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 - case _ => 4 - } - - def j = (List[Int](), List[Int](1)) match { - case (Nil, _) => 'a' - case (_, Nil) => 'b' - case (h1 :: t1, h2 :: t2) => 'c' - } - - def k (x:AnyRef) = x match { - case null => 1 - case _ => 2 - } - - val FooBar = 42 - def lala() = 42 match { - case FooBar => true - } - - object Bug1270 { // unapply13 - - class Sync { - def apply(x: Int): Int = 42 - def unapply(scrut: Any): Option[Int] = None - } - - class Buffer { - object Get extends Sync - - var ps: PartialFunction[Any, Any] = { - 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 - } - } - } - - 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 - - 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 should have proper arg.tpe (Int in this case) - } - } - - println((new Buffer).jp.isDefinedAt(40)) - println((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 - } - - 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 - } - z.isDefinedAt(42) - s.isDefinedAt(42) - // just load the thing, to see if the classes are found - - (None:Option[Boolean] @unchecked) match { - case x if x.map(x => x).isEmpty => - } - } - } - - // bug#457 - - object Bug457 extends TestCase("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) - ) - result - else - throw new MatchError("crazybox.scala, line 9") - }} - - override def runTest { - method1(); - method2(); - } - } - - // bug#508 - - object Bug508 extends TestCase("aladdin #508") { - case class Operator(x: Int); - val EQ = new Operator(2); - - def analyze(x: Pair[Operator, Int]) = x match { - case Pair(EQ, 0) => "0" - case Pair(EQ, 1) => "1" - case Pair(EQ, 2) => "2" - } - override def runTest { - val x = Pair(EQ, 0); - assertEquals("0", analyze(x)); // should print "0" - val y = Pair(EQ, 1); - assertEquals("1", analyze(y)); // should print "1" - val z = Pair(EQ, 2); - assertEquals("2", analyze(z)); // should print "2" - } - } - - // bug#789 - - object Bug789 extends TestCase("aladdin #789") { // don't do this at home - - trait Impl - - trait SizeImpl extends Impl { def size = 42 } - - trait ColorImpl extends Impl { def color = "red" } - - 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 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 { - // make up some class that has a size - class MyNode extends SizeImpl - assertEquals("!size 42", info(new MyNode)) - assertEquals("!size 42", info2(new MyNode)) - } - } - - // bug#995 - - object Bug995 extends TestCase("aladdin #995") { - 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("Seq", 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 - })} - } - - // bug#1094 (contribution #461) - - object Bug1094 extends TestCase("aladdin #1094") { - def foo(ps: String*) = "Foo" - case class X(p: String, ps: String*) - def bar = - X("a", "b") match { - case X(p, ps @ _*) => foo(ps : _*) - } - override def runTest { assertEquals("Foo", bar) } - } - - // #2 - - class Outer_2 { - case class Foo(x: int, y: int) { - override def equals(other: Any) = other match { - case Outer_2.this.Foo(`x`, `y`) => true - case _ => false - } - } - } - - 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 - }) - }} - -// #11 - - class MyException1 extends Exception - - // Commenting out the following line and uncommenting the second line - // will cause the test to succeed. - trait SpecialException extends MyException1 - // trait SpecialException - - class MyException2 extends MyException1 with SpecialException - - object Ticket11 extends TestCase("#11") { - override def runTest { - 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]) - } - } - } - } - } - - // #37 - - object Ticket37 extends TestCase("#37") { - def foo() {} - val (a,b) = { foo(); (2,3) } - override def runTest { assertEquals(this.a, 2) } - } - - // #44 - - trait _X { - case class _Foo(); - object _Bar { - def unapply(foo: _Foo):Boolean = true; - } - } - object Y extends _X { - val foo = _Foo() - foo match { - case _Bar() => - 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]) => {}; - } - } - } - - 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 - } - } - } -} - - -- cgit v1.2.3