test4;    test5;    test6;    test7;    test8;  }}object testWS {  import values._ ;  import scala.testing.UnitTest._ ;        /* strings:            "blabla" == [ "bla";"bla" ] == [ 'b';'l';'a';'b';'l';'a' ]            [ "blabla";'x';'y'? ] == [ ('b';'l';'a';'b';'l';'a'); 'x'; 'y'? ]        */        /*            def isIdentifierStart(c:char) ;            case [ ... ; _isIdentifierStart_ ; ... ]            calls method is..., needs to have type (elementType)Boolean                        translated to pattern                             [ ... ; Apply(is..., Tree.Empty) ; ... ]         */         /* for tree automata:         [ t0; t1; ...; tn ]  with ti = labeli ( argsi )        gets translated to        [ _isTree$0_ ; _isTree$1_ ; ... ; _isTree$n_ ]        where isTree$i( t ) = t.is[ labeli ] ... (algebraic matcher)        special case: sequences        [ ...; seq ; ... ] where seq = [ ... ]        gets translated to        [ ...; _seq$0_ ; ...] with seq$0( s ) = t.is[ Sequence ] and                                                 seq$0match( s.newIterator )        subroutines return           1) d'abord true or false,          2) later ( true|false, environment )                       assume order on variables, enviroment is a tuple/sequence        */    def doit1(e: List[Char]):Int = e match {                case List( 'a', 'b', 'c' )        => 100                case List( ('a', 'b','c')? )      => 1004                case List( ('a', 'a','a')? )      => 50                case List( ('a'|'b')*,('a'|'b') ) => 700                case _                        => 321        };        def test1: Unit = {    Console.println("testWS");    assertEquals( doit1( s0 ), 1004);    assertEquals( doit1( s1 ),  100);    assertEquals( doit1( s2 ),  321);    assertEquals( doit1( s3 ),  50);    assertEquals( doit1( s4 ), 321);    assertEquals( doit1( s5 ), 700);    assertEquals( doit1( s6 ), 700);  }  def main(args: Array[String]): Unit = {    test1;  }}object testWT  {  import values._ ;  import scala.testing.UnitTest._ ;  def doit1(e: List[Char]): Int = e match {    case List('a', _, _) => 100    case List(_ *)       => 321    case _               => 20022 // this never happens  }  def test1: Unit = {    Console.println("testWT");    assertEquals( doit1( s0 ),321);    assertEquals( doit1( s1 ),100);    assertEquals( doit1( s2 ),321);    assertEquals( doit1( s3 ),100);    assertEquals( doit1( s4 ),321);    assertEquals( doit1( s5 ),321);    assertEquals( doit1( s6 ),321)  }  def main(args: Array[String]): Unit = {    test1;  }}object testWV {  import values._ ;  import scala.testing.UnitTest._ ;          class testClass;  case class testA( arg:List[Char] ) extends testClass;  def doit1(e: testClass):Int = e match {    case testA(List( 'a', 'b', 'c' ))        => 100    case testA(List( ('a', 'b','c')? ))      => 1004    case testA(List( ('a', 'a','a')? ))      => 50    case testA(List( ('a'|'b')*,('a'|'b') )) => 700    case testA( _ )                          => 321  }  def test1: Unit = {    Console.println("testWV");    assertEquals(doit1(testA(s0)), 1004);    assertEquals(doit1(testA(s1)),  100);    assertEquals(doit1(testA(s2)),  321);    assertEquals(doit1(testA(s3)),   50);    assertEquals(doit1(testA(s4)),  321);    assertEquals(doit1(testA(s5)),  700);    assertEquals(doit1(testA(s6)),  700);  }  def main(args: Array[String]) = {    test1  }}/*object testWW {        import values._ ;        import scala.testing.UnitTest._ ;                class testClass;        case class testA( arg:List[Char] ) extends testClass;        def doit1(e: List[testClass]):Int = e match {                        case List( testA(List()), testA( List( 'a', 'b' )) )        => 100                case _                                                      => 321        };              def test1:Unit = {                val x1 = List( testA(s0) );                Console.println("testWW");                assertEquals( doit1( x1 ), 321 );                val x2 = List( testA(Nil), testA('a'::'b'::Nil) );                                                                  assertEquals( doit1( x2 ), 100 );        }        def main( args:Array[String] ) = {                test1;        }}*/object testMZ {        import scala.testing.UnitTest.assertEquals ;  class Expr;  case class One(xs: List[Expr]) extends Expr;  case class Two() extends Expr;  def testFoo(xs: List[Expr]) = xs match { //bug#132    case List(Two()?,a,Two()?) => "a = " + a;    case List(Two()*,b,Two()*) => "b = " + b;    case List(_*) => "no match";  }  case class OneN();  def bind(xs: List[Any]):String = xs match { // bug#133b    case List(x@(OneN()*), y@(OneN())) => "case";    case _ => "default";  }  case class On();  case class Tw();  def testBar(xs: List[Any]) = xs match { // bug#180    case List(((On(), Tw())* | (On(), On())), On()) => "caseBar"    case _ => "default";  }  def mat195(x:Expr) = x match { // bug#195	    case One(x@List(_*)) =>    	"x = " + x;	case _ =>"default";  }  def mat196(xs: List[Any]) = xs match { // bug#196	    case List(b@(()|())) =>    	"case, b = " + b;	case _ =>"default";  }  def mat398(xs:List[Any]) = xs match { // bug#398    case List(1) => "one"    case x::xs   => "two"  }  def mat406() = {    class Type;    case class A() extends Type;    case class B() extends Type;    case class C() extends Type;        def foo(x: Type, y: Type): String = Pair(x, y) match {      case Pair(A(), A())       | Pair(A(), B())       | Pair(B(), A())       | Pair(B(), B()) => "3"      case Pair(C(), C()) => "4"      case Pair(A(), _)      | Pair(B(), _) => "7"      case _ => "8"    }        foo(A(), C())  }  def mat441() = {    val tata = 1;    val titi = 0.8 + Math.random();    try {      tata match {        case 1 if (titi < 0.5) => "a"        case 0 | 1             => "b"      }    } catch {      case _ => "c"    }  }  /* this will crash  def matSymbolCloning = {    2 match {      case 3 | 4 =>        class Foo extends scala.xml.Atom[Int](3) {          def bar = 7;        }        null    }  }  */  def main:Unit = {                  Console.println("testMZ - bugs #132 #133b #180 #195 #196 #398 #406 #441");    assertEquals(testFoo( List(Two(),Two(),Two(),Two()) ),"b = Two");    assertEquals(testFoo( List(Two(),Two(),Two()) ),"a = Two");    assertEquals(testFoo( List(Two(),Two()) ),"a = Two");    assertEquals(testFoo( List(Two()) ),"a = Two");    assertEquals(testFoo( List() ),"no match");    assertEquals(bind( List(OneN(),OneN()) ),"case");    assertEquals(testBar( List() ),"default");    assertEquals(testBar( List(On()) ),"caseBar");    assertEquals(testBar( List(On(), On())), "default");    assertEquals(testBar( List(On(), On(), On()) ),"caseBar");    assertEquals(testBar( List(On(), On(), On(), On()) ),"default");    assertEquals(testBar( List(On(), On(), On(), On(), On()) ),"default");    assertEquals(mat195( One(List(Two(),Two())) ),"x = List(Two,Two)");    assertEquals(mat195( One(List()) ),"x = List()");    assertEquals(mat195( Two() ),"default");    assertEquals(mat196( List(1) ),"default");    assertEquals(mat196( List() ),"case, b = List()");    assertEquals(mat398( List(2) ),"two");    assertEquals(mat398( List(2) ),"two");    assertEquals(mat406(), "7");    assertEquals(mat441(), "b");    ()  }  }/*object testNN { import scala.testing.UnitTest._ ;  abstract class K;  case class F(x:K*) extends K;  case class G() extends K;  def mtch(k:K):boolean = k match {      case F(F(G()*),G(),F(G()*)) => true;      case _ => false;  }  def main:Unit = {    Console.println("testNN");    assertEquals(mtch( F(F(G()),G(),F(G()))), true);    assertEquals(mtch( F(F(),G(),F(G(),G(),G(),G())) ), true);        assertEquals(mtch( G() ), false);        assertEquals(mtch( F(G()) ), false);      }}*/object testNO {   // this does not need to be run, only compiled  trait Operator;  case class Increment() extends Operator;  case class Decrement() extends Operator;    trait Expression {    def eval = this match {      case Operation (v: Value, o: Increment) => v      case Operation (v: Value, d: Decrement) => v    }  }    case class Value() extends Expression;  case class Operation (e: Expression, o: Operator) extends Expression;}/** see comments in scala.tools.scalac.transformer.matching.PatternMatcher::isSeqApply 2005-02-17 *//*object testBugSequenceApply {  val x = List(1,2,3);  case class ThreeBars extends Seq[Int] {    override def length = 3;    def elements = x.elements;    def apply(i:Int) = x.apply(i);  }  // this works  def main:Unit = {      Console.print("testBugSequenceApply ");    val z: Seq[Int] = new ThreeBars();    Console.print(z match {      case Seq(1,2,3) => "hello" // but ThreeBars is a case class...    });        Console.print(ThreeBars() match {      case Seq(1,2,3) => " hello" // but ThreeBars is a case class...    });  }}*/