diff options
Diffstat (limited to 'test/files')
44 files changed, 1128 insertions, 82 deletions
diff --git a/test/files/jvm/actor-exceptions.scala b/test/files/jvm/actor-exceptions.scala index 77bf05c048..384226d777 100644 --- a/test/files/jvm/actor-exceptions.scala +++ b/test/files/jvm/actor-exceptions.scala @@ -13,12 +13,17 @@ case class MyOtherException(text: String) extends Exception { object Master extends Actor { trapExit = true def act() { + try { link(Slave) Slave.start() for (i <- 0 until 10) Slave ! A react { case Exit(from, reason) => } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } @@ -28,6 +33,7 @@ object Slave extends Actor { case MyException(text) => } def act() { + try { var cnt = 0 loop { react { @@ -39,6 +45,10 @@ object Slave extends Actor { } } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } diff --git a/test/files/jvm/actor-executor.scala b/test/files/jvm/actor-executor.scala index 435c666fff..b1f9caebdd 100644 --- a/test/files/jvm/actor-executor.scala +++ b/test/files/jvm/actor-executor.scala @@ -9,6 +9,7 @@ trait AdaptedActor extends Actor { object One extends AdaptedActor { def act() { + try { Two.start() var i = 0 loopWhile (i < 10000) { @@ -22,11 +23,16 @@ object One extends AdaptedActor { Test.executor.shutdown() } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } object Two extends AdaptedActor { def act() { + try { var i = 0 loopWhile (i < 10000) { i += 1 @@ -37,6 +43,10 @@ object Two extends AdaptedActor { One ! 'MsgForOne } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } diff --git a/test/files/jvm/actor-executor2.scala b/test/files/jvm/actor-executor2.scala index 9e99e167aa..da64a7fc43 100644 --- a/test/files/jvm/actor-executor2.scala +++ b/test/files/jvm/actor-executor2.scala @@ -4,6 +4,7 @@ import java.util.concurrent.Executors object One extends AdaptedActor { def act() { + try { Two.start() var i = 0 loopWhile (i < Test.NUM_MSG) { @@ -15,11 +16,16 @@ object One extends AdaptedActor { println("One: OK") } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } object Two extends AdaptedActor { def act() { + try { var i = 0 loopWhile (i < Test.NUM_MSG) { i += 1 @@ -30,6 +36,10 @@ object Two extends AdaptedActor { One ! 'MsgForOne } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } @@ -54,6 +64,7 @@ object Test { } def main(args: Array[String]) { + try { self.trapExit = true link(One) One.start() @@ -63,5 +74,9 @@ object Test { println("One exited") Test.executor.shutdown() } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } diff --git a/test/files/jvm/actor-executor3.scala b/test/files/jvm/actor-executor3.scala index bf060b8ac5..4fde2c6c5f 100644 --- a/test/files/jvm/actor-executor3.scala +++ b/test/files/jvm/actor-executor3.scala @@ -4,6 +4,7 @@ import java.util.concurrent.Executors object One extends AdaptedActor { def act() { + try { Two.start() var i = 0 loopWhile (i < Test.NUM_MSG) { @@ -15,11 +16,16 @@ object One extends AdaptedActor { println("One: OK") } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } object Two extends AdaptedActor { def act() { + try { var i = 0 loopWhile (i < Test.NUM_MSG) { i += 1 @@ -30,6 +36,10 @@ object Two extends AdaptedActor { One ! 'MsgForOne } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } diff --git a/test/files/jvm/actor-link-getstate.scala b/test/files/jvm/actor-link-getstate.scala index ec01757883..c4c33ef752 100644 --- a/test/files/jvm/actor-link-getstate.scala +++ b/test/files/jvm/actor-link-getstate.scala @@ -7,6 +7,7 @@ case class MyException(text: String) extends Exception(text) { object Slave extends Actor { def act() { + try { loop { react { case 'doWork => @@ -14,18 +15,27 @@ object Slave extends Actor { reply('done) } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } object Master extends Actor { override def toString = "Master" def act() { + try { link(Slave) Slave ! 'doWork react { case 'done => throw new MyException("Master crashed") } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } @@ -33,6 +43,7 @@ object Test { def main(args: Array[String]) { actor { + try { self.trapExit = true link(Slave) Slave.start() @@ -41,6 +52,10 @@ object Test { case Exit(from, reason) if (from == Slave) => Console.err.println(Slave.getState) } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } diff --git a/test/files/jvm/actor-looping.scala b/test/files/jvm/actor-looping.scala index 9599adbb2c..475d4754ce 100644 --- a/test/files/jvm/actor-looping.scala +++ b/test/files/jvm/actor-looping.scala @@ -6,6 +6,7 @@ object Test { def main(args: Array[String]) { val a = actor { + try { var cnt = 0 loop { react { @@ -20,6 +21,10 @@ object Test { } } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } for (i <- 0 until 10) a ! A diff --git a/test/files/jvm/actor-normal-exit.scala b/test/files/jvm/actor-normal-exit.scala index 40dc7b7da4..20863d5bb0 100644 --- a/test/files/jvm/actor-normal-exit.scala +++ b/test/files/jvm/actor-normal-exit.scala @@ -5,18 +5,28 @@ object Test { object Master extends Actor { trapExit = true def act() { + try { Slave.start() react { case Exit(from, reason) => println("slave exited for reason " + reason) } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } object Slave extends Actor { def act() { + try { link(Master) println("Done") + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } diff --git a/test/files/jvm/actor-termination.scala b/test/files/jvm/actor-termination.scala index 19dfaf8e17..d8e44a2797 100644 --- a/test/files/jvm/actor-termination.scala +++ b/test/files/jvm/actor-termination.scala @@ -5,9 +5,14 @@ import scala.actors.Actor object Test { def main(args: Array[String]) { Actor.actor { + try { println("I'm going to make you wait.") Thread.sleep(5000) println("Ok, I'm done.") + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } } diff --git a/test/files/jvm/actor-uncaught-exception.scala b/test/files/jvm/actor-uncaught-exception.scala index 9f64be26e1..9dbd36dd82 100644 --- a/test/files/jvm/actor-uncaught-exception.scala +++ b/test/files/jvm/actor-uncaught-exception.scala @@ -8,20 +8,32 @@ object Test { case object StartError extends Actor { def act() { + try { throw new MyException("I don't want to run!") + } catch { + case e: Throwable if (!e.isInstanceOf[scala.util.control.ControlThrowable] && + !e.isInstanceOf[MyException]) => + e.printStackTrace() + } } } case object MessageError extends Actor { def act() { + try { react { case _ => throw new MyException("No message for me!") } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } case object Supervisor extends Actor { def act() { + try { trapExit = true link(StartError) link(MessageError) @@ -37,6 +49,10 @@ object Test { exit() } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } diff --git a/test/files/jvm/actor-uncaught-exception2.scala b/test/files/jvm/actor-uncaught-exception2.scala index 973cfb370a..626ce5da92 100644 --- a/test/files/jvm/actor-uncaught-exception2.scala +++ b/test/files/jvm/actor-uncaught-exception2.scala @@ -8,20 +8,32 @@ object Test { case object StartError extends Actor { def act() { + try { throw new MyException("I don't want to run!") + } catch { + case e: Throwable if (!e.isInstanceOf[scala.util.control.ControlThrowable] && + !e.isInstanceOf[MyException]) => + e.printStackTrace() + } } } case object MessageError extends Actor { def act() { + try { react { case _ => throw new MyException("No message for me!") } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } case object Supervisor extends Actor { def act() { + try { trapExit = true link(StartError) link(MessageError) @@ -38,6 +50,10 @@ object Test { exit() } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } diff --git a/test/files/jvm/daemon-actor-termination.scala b/test/files/jvm/daemon-actor-termination.scala index 8e64749b1c..6ddfc3139d 100644 --- a/test/files/jvm/daemon-actor-termination.scala +++ b/test/files/jvm/daemon-actor-termination.scala @@ -5,6 +5,7 @@ object Test { class MyDaemon extends DaemonActor { def act() { + try { react { case 'hello => println("MSG1") @@ -14,6 +15,10 @@ object Test { println("done") } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } @@ -21,8 +26,13 @@ object Test { val daemon = new MyDaemon daemon.start() Actor.actor { + try { daemon !? 'hello println("MSG2") + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } } diff --git a/test/files/jvm/future-alarm.scala b/test/files/jvm/future-alarm.scala index 0dda492741..8ee902b5ea 100644 --- a/test/files/jvm/future-alarm.scala +++ b/test/files/jvm/future-alarm.scala @@ -2,6 +2,7 @@ import scala.actors.Futures object Test { def main(args: Array[String]) { + try { for (i <- 1 to 100000) { Futures.alarm(0) if (i % 10000 == 0) @@ -12,5 +13,9 @@ object Test { ft() println("OK") } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } diff --git a/test/files/jvm/future-awaitall-zero.scala b/test/files/jvm/future-awaitall-zero.scala index 125670d049..cd6ba172cc 100644 --- a/test/files/jvm/future-awaitall-zero.scala +++ b/test/files/jvm/future-awaitall-zero.scala @@ -3,6 +3,7 @@ import scala.actors.Actor._ object Test { def main(args: Array[String]) { + try { val ft1 = future { reactWithin(10000) { case _ => println("FAIL") } } @@ -13,5 +14,9 @@ object Test { val res = awaitAll(0, ft1, ft2) println("OK") + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } diff --git a/test/files/jvm/future-termination.scala b/test/files/jvm/future-termination.scala index c448a88aa7..688de60c3b 100644 --- a/test/files/jvm/future-termination.scala +++ b/test/files/jvm/future-termination.scala @@ -4,11 +4,16 @@ import scala.actors.Futures object Test { def main(args: Array[String]) { + try { val meaningOfLife = Futures.future { Thread.sleep(5000) // pretend this is a harder problem than it is println("I have the answer!") 42 } println("I can't wait that long, bye.") + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } diff --git a/test/files/jvm/reactor-exceptionOnSend.scala b/test/files/jvm/reactor-exceptionOnSend.scala index c89aab334b..3d9a042131 100644 --- a/test/files/jvm/reactor-exceptionOnSend.scala +++ b/test/files/jvm/reactor-exceptionOnSend.scala @@ -19,6 +19,7 @@ object A extends Reactor[Any] { var state = 0 def act() { + try { loop { react { case 'hello if guard() => @@ -26,14 +27,24 @@ object A extends Reactor[Any] { exit() } } + } catch { + case e: Throwable if (!e.isInstanceOf[scala.util.control.ControlThrowable] && + !e.isInstanceOf[MyException]) => + e.printStackTrace() + } } } object B extends Reactor[Any] { def act() { + try { A.start() A ! 'hello A ! 'hello + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } diff --git a/test/files/jvm/reactor-producer-consumer.scala b/test/files/jvm/reactor-producer-consumer.scala index 0d33043fc6..8a6b17c3ad 100644 --- a/test/files/jvm/reactor-producer-consumer.scala +++ b/test/files/jvm/reactor-producer-consumer.scala @@ -7,6 +7,7 @@ object Test { class UnboundedBuffer extends Reactor[Any] { def act() { + try { react { case Stop() => case Get(from) => @@ -17,11 +18,16 @@ object Test { act() } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } class Producer(buf: UnboundedBuffer, n: Int, delay: Long, parent: Reactor[Any]) extends Reactor[Any] { def act() { + try { var i = 0 while (i < n) { i += 1 @@ -29,6 +35,10 @@ object Test { buf ! Put(42) } parent ! Stop() + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } @@ -36,6 +46,7 @@ object Test { val step = n / 10 var i = 0 def act() { + try { if (i < n) { i += 1 if (delay > 0) Thread.sleep(delay) @@ -49,12 +60,17 @@ object Test { } else { parent ! Stop() } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } def main(args: Array[String]) { val parent = new Reactor[Any] { def act() { + try { val buffer = new UnboundedBuffer buffer.start() val producer = new Producer(buffer, 10000, 0, this) @@ -68,6 +84,10 @@ object Test { buffer ! Stop() } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } parent.start() diff --git a/test/files/jvm/reactor.scala b/test/files/jvm/reactor.scala index 12d5c7c221..dbc9a6bdda 100644 --- a/test/files/jvm/reactor.scala +++ b/test/files/jvm/reactor.scala @@ -21,6 +21,7 @@ object Test { class PingActor(count: Int, pong: Reactor[Any]) extends Reactor[Any] { def act() { + try { var pingsLeft = count - 1 pong ! Ping(this) loop { @@ -38,11 +39,16 @@ class PingActor(count: Int, pong: Reactor[Any]) extends Reactor[Any] { } } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } class PongActor extends Reactor[Any] { def act() { + try { var pongCount = 0 loop { react { @@ -56,5 +62,9 @@ class PongActor extends Reactor[Any] { exit() } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } diff --git a/test/files/jvm/replyablereactor.scala b/test/files/jvm/replyablereactor.scala index 896a0bf440..e1fabc98da 100644 --- a/test/files/jvm/replyablereactor.scala +++ b/test/files/jvm/replyablereactor.scala @@ -2,6 +2,7 @@ import scala.actors.ReplyReactor class MyActor extends ReplyReactor { def act() { + try { loop { react { case 'hello => @@ -10,6 +11,10 @@ class MyActor extends ReplyReactor { exit() } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } @@ -20,6 +25,7 @@ object Test { val b = new ReplyReactor { def act() { + try { react { case r: MyActor => var i = 0 @@ -37,6 +43,10 @@ object Test { } } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } b.start() diff --git a/test/files/jvm/replyablereactor2.scala b/test/files/jvm/replyablereactor2.scala index 57b7cfe201..da9e0e269e 100644 --- a/test/files/jvm/replyablereactor2.scala +++ b/test/files/jvm/replyablereactor2.scala @@ -3,6 +3,7 @@ import scala.actors.Actor._ class MyActor extends ReplyReactor { def act() { + try { loop { react { case 'hello => @@ -11,6 +12,10 @@ class MyActor extends ReplyReactor { exit() } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } @@ -21,6 +26,7 @@ object Test { val b = new Reactor[Any] { def act() { + try { react { case r: MyActor => var i = 0 @@ -36,6 +42,10 @@ object Test { } } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } b.start() diff --git a/test/files/jvm/replyablereactor3.scala b/test/files/jvm/replyablereactor3.scala index b33db811e2..2c26b8a176 100644 --- a/test/files/jvm/replyablereactor3.scala +++ b/test/files/jvm/replyablereactor3.scala @@ -3,6 +3,7 @@ import scala.actors.Actor._ class MyActor extends ReplyReactor { def act() { + try { loop { react { case 'hello => @@ -11,6 +12,10 @@ class MyActor extends ReplyReactor { exit() } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } @@ -21,6 +26,7 @@ object Test { val b = new Reactor[Any] { def act() { + try { react { case r: MyActor => var i = 0 @@ -35,6 +41,10 @@ object Test { } } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } b.start() diff --git a/test/files/jvm/replyablereactor4.scala b/test/files/jvm/replyablereactor4.scala index dc24f5e88d..7679a5adf8 100644 --- a/test/files/jvm/replyablereactor4.scala +++ b/test/files/jvm/replyablereactor4.scala @@ -3,6 +3,7 @@ import scala.actors.Actor._ class MyActor extends ReplyReactor { def act() { + try { loop { react { case 'hello => @@ -11,6 +12,10 @@ class MyActor extends ReplyReactor { exit() } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } @@ -21,6 +26,7 @@ object Test { val b = new Reactor[Any] { def act() { + try { react { case r: MyActor => var i = 0 @@ -35,6 +41,10 @@ object Test { } } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } b.start() diff --git a/test/files/jvm/replyreactor-react-sender.scala b/test/files/jvm/replyreactor-react-sender.scala index 1127dfd0a5..c9884295f6 100644 --- a/test/files/jvm/replyreactor-react-sender.scala +++ b/test/files/jvm/replyreactor-react-sender.scala @@ -10,6 +10,7 @@ object Test { val a = new ReplyReactor { def act() { + try { var i = 0 loopWhile (i < NUM) { i += 1 @@ -20,12 +21,17 @@ object Test { } andThen { b ! 'ok } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } a.start() b = new ReplyReactor { def act() { + try { for (_ <- 0 until NUM) a ! 'hello react { @@ -33,6 +39,10 @@ object Test { case 'ok => println("OK") case other => println(other) } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } b.start() diff --git a/test/files/jvm/replyreactor.scala b/test/files/jvm/replyreactor.scala index fb915cf3f9..0cecf29ec7 100644 --- a/test/files/jvm/replyreactor.scala +++ b/test/files/jvm/replyreactor.scala @@ -4,16 +4,22 @@ object Test { def main(args: Array[String]) { val a = new ReplyReactor { def act() { + try { react { case 'hello => sender ! 'hello } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } a.start() val b = new ReplyReactor { def act() { + try { react { case r: ReplyReactor => r ! 'hello @@ -22,6 +28,10 @@ object Test { println(any) } } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } b.start() diff --git a/test/files/jvm/scheduler-adapter.scala b/test/files/jvm/scheduler-adapter.scala index 79c901f91e..d6a8a446a0 100644 --- a/test/files/jvm/scheduler-adapter.scala +++ b/test/files/jvm/scheduler-adapter.scala @@ -7,22 +7,32 @@ trait AdaptedActor extends Actor { object One extends AdaptedActor { def act() { + try { Two.start() Two ! 'MsgForTwo react { case 'MsgForOne => println("One: received msg") } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } object Two extends AdaptedActor { def act() { + try { react { case 'MsgForTwo => println("Two: received msg") One ! 'MsgForOne } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } diff --git a/test/files/jvm/t1449.scala b/test/files/jvm/t1449.scala index 08c153afc0..3822cf7dd5 100644 --- a/test/files/jvm/t1449.scala +++ b/test/files/jvm/t1449.scala @@ -4,12 +4,22 @@ import scala.actors.Futures._ object Test { def main(args: Array[String]) { val a = actor { + try { react { case ft: Future[a] => println(ft()) } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } + try { val ft = future { 42 } a ! ft + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } diff --git a/test/files/jvm/t1600.scala b/test/files/jvm/t1600.scala index 1cdcee8547..79391b7e76 100644 --- a/test/files/jvm/t1600.scala +++ b/test/files/jvm/t1600.scala @@ -12,11 +12,11 @@ object Test { def elements = entries.map(_._1) val maps = Seq[Map[Foo, Int]](new mutable.HashMap, new mutable.LinkedHashMap, - new immutable.HashMap).map(_ ++ entries) + immutable.HashMap.empty).map(_ ++ entries) test[Map[Foo, Int]](maps, entries.size, assertMap _) val sets = Seq[Set[Foo]](new mutable.HashSet, new mutable.LinkedHashSet, - new immutable.HashSet).map(_ ++ elements) + immutable.HashSet.empty).map(_ ++ elements) test[Set[Foo]](sets, entries.size, assertSet _) } } @@ -31,7 +31,7 @@ object Test { assertFunction(deserializedCollection, expectedSize) assert(deserializedCollection.getClass == collection.getClass, - "collection class should remain the same after deserialization") + "collection class should remain the same after deserialization ("+deserializedCollection.getClass+" != "+collection.getClass+")") Foo.hashCodeModifier = 0 } } diff --git a/test/files/jvm/t1948.scala b/test/files/jvm/t1948.scala index fc1fedac1f..084c956398 100644 --- a/test/files/jvm/t1948.scala +++ b/test/files/jvm/t1948.scala @@ -4,9 +4,21 @@ import scala.actors.Actor._ object Test { def main (args: Array[String]) { - val actors = (1 to 1000).toList map { x => actor { loop { react { - case x: Array[Int] => reply ("OK"); exit }}}} + val actors = (1 to 1000).toList map { x => actor { + try { + loop { react { + case x: Array[Int] => reply ("OK"); exit }} + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } + } } + try { actors foreach { x => x !? new Array[Int] (1000000) } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } diff --git a/test/files/jvm/t2359.scala b/test/files/jvm/t2359.scala index 1b4d5e0a27..69c69d7b3b 100644 --- a/test/files/jvm/t2359.scala +++ b/test/files/jvm/t2359.scala @@ -3,19 +3,44 @@ import scala.actors.Futures._ object Test { def main(args: Array[String]) { val x = future { + try { System.out.println(1) future { + try { System.out.println(2) future { + try { System.out.println(3) future { + try { System.out.println(4) future { + try { System.out.println(5) + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } }() + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } }() + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } }() + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } }() + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } }() } } diff --git a/test/files/jvm/t2530.scala b/test/files/jvm/t2530.scala index 642fb05a5d..c2925a92d1 100644 --- a/test/files/jvm/t2530.scala +++ b/test/files/jvm/t2530.scala @@ -50,6 +50,7 @@ case class Matrix(numRows: Int, numCols: Int, values: Array[Double]) { val rows = for (j <- 0 until m) yield { Futures.future { + try { val b_j = new Array[Double](n) var k = 0 while (k < n) { // sadly, while loops are still faster than for loops @@ -69,13 +70,22 @@ case class Matrix(numRows: Int, numCols: Int, values: Array[Double]) { } //printf("future %d of %d completed.%n", j, m) j + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } // rows.foreach { x=> x() } // This appears to force sequential execution, so use: // timeout is 10 years; see http://lampsvn.epfl.ch/trac/scala/ticket/2515 - - val done = Futures.awaitAll(10*365*24*60*60*1000, rows.toArray : _*) // list to array, as varargs. + val done: List[Option[Any]] = try { + Futures.awaitAll(10*365*24*60*60*1000, rows.toArray : _*) // list to array, as varargs. + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + List() + } if (done.contains(None)) None diff --git a/test/files/jvm/t3102.scala b/test/files/jvm/t3102.scala index ea3e720eca..fbcf2e60e6 100644 --- a/test/files/jvm/t3102.scala +++ b/test/files/jvm/t3102.scala @@ -4,13 +4,19 @@ import Actor._ object Test { def main(args: Array[String]) { val a = actor { + try { react { case 'hello => reply(42) } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } val b = actor { + try { self.trapExit = true val ft = a !! 'hello println(ft()) @@ -21,6 +27,10 @@ object Test { case any => println(any) } + } catch { + case e: Throwable if !e.isInstanceOf[scala.util.control.ControlThrowable] => + e.printStackTrace() + } } } } diff --git a/test/files/run/Course-2002-10-msil.check b/test/files/run/Course-2002-10-msil.check new file mode 100644 index 0000000000..bbd9414370 --- /dev/null +++ b/test/files/run/Course-2002-10-msil.check @@ -0,0 +1,46 @@ +fib(0) = 0 +fib(1) = 1 +fib(2) = 1 +fib(3) = 2 +fib(4) = 3 +fib(5) = 5 +fib(6) = 8 +fib(7) = 13 +fib(8) = 21 +fib(9) = 34 +fib(10) = 55 +fib(11) = 89 +fib(12) = 144 +fib(13) = 233 +fib(14) = 377 +fib(15) = 610 +fib(16) = 987 +fib(17) = 1597 +fib(18) = 2584 +fib(19) = 4181 + +pi(0) = 4 , 3.16666666666667 , 4 +pi(1) = 2.66666666666667 , 3.13333333333333 , 3.16666666666667 +pi(2) = 3.46666666666667 , 3.1452380952381 , 3.1421052631579 +pi(3) = 2.8952380952381 , 3.13968253968254 , 3.141599357319 +pi(4) = 3.33968253968254 , 3.14271284271284 , 3.14159271403378 +pi(5) = 2.97604617604618 , 3.14088134088134 , 3.14159265397529 +pi(6) = 3.28373848373848 , 3.14207181707182 , 3.14159265359118 +pi(7) = 3.01707181707182 , 3.14125482360776 , 3.14159265358978 +pi(8) = 3.25236593471888 , 3.1418396189294 , 3.14159265358979 +pi(9) = 3.0418396189294 , 3.1414067184965 , 3.14159265358979 +pi = 3.14159265358979 , 3.14159265358979 , 3.14159265358979 + +ln(0) = 1 , 0.7 , 1 +ln(1) = 0.5 , 0.69047619047619 , 0.7 +ln(2) = 0.833333333333333 , 0.694444444444444 , 0.69327731092437 +ln(3) = 0.583333333333333 , 0.692424242424242 , 0.693148869332925 +ln(4) = 0.783333333333333 , 0.693589743589744 , 0.693147196073549 +ln(5) = 0.616666666666667 , 0.692857142857143 , 0.693147180663564 +ln(6) = 0.759523809523809 , 0.693347338935574 , 0.693147180560404 +ln(7) = 0.634523809523809 , 0.693003341687552 , 0.693147180559944 +ln(8) = 0.745634920634921 , 0.693253968253968 , 0.693147180559943 +ln(9) = 0.645634920634921 , 0.693065750674446 , 0.693147180559945 +ln = 0.693147180559945 , 0.693147180559945 , 0.693147180559945 + +prime numbers: 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 diff --git a/test/files/run/Course-2002-10.check b/test/files/run/Course-2002-10.check new file mode 100644 index 0000000000..207b671f05 --- /dev/null +++ b/test/files/run/Course-2002-10.check @@ -0,0 +1,46 @@ +fib(0) = 0 +fib(1) = 1 +fib(2) = 1 +fib(3) = 2 +fib(4) = 3 +fib(5) = 5 +fib(6) = 8 +fib(7) = 13 +fib(8) = 21 +fib(9) = 34 +fib(10) = 55 +fib(11) = 89 +fib(12) = 144 +fib(13) = 233 +fib(14) = 377 +fib(15) = 610 +fib(16) = 987 +fib(17) = 1597 +fib(18) = 2584 +fib(19) = 4181 + +pi(0) = 4.0 , 3.166666666666667 , 4.0 +pi(1) = 2.666666666666667 , 3.1333333333333337, 3.166666666666667 +pi(2) = 3.466666666666667 , 3.1452380952380956, 3.142105263157895 +pi(3) = 2.8952380952380956, 3.1396825396825396, 3.1415993573190044 +pi(4) = 3.33968253968254 , 3.142712842712843 , 3.141592714033778 +pi(5) = 2.976046176046176 , 3.140881340881341 , 3.1415926539752923 +pi(6) = 3.283738483738484 , 3.142071817071817 , 3.141592653591176 +pi(7) = 3.017071817071817 , 3.1412548236077646, 3.141592653589777 +pi(8) = 3.252365934718876 , 3.1418396189294024, 3.141592653589794 +pi(9) = 3.0418396189294024, 3.141406718496502 , 3.1415926535897936 +pi = 3.141592653589793 , 3.141592653589793 , 3.141592653589793 + +ln(0) = 1.0 , 0.7 , 1.0 +ln(1) = 0.5 , 0.6904761904761905, 0.7 +ln(2) = 0.8333333333333333, 0.6944444444444444, 0.6932773109243697 +ln(3) = 0.5833333333333333, 0.6924242424242424, 0.6931488693329254 +ln(4) = 0.7833333333333333, 0.6935897435897436, 0.6931471960735491 +ln(5) = 0.6166666666666667, 0.6928571428571428, 0.6931471806635636 +ln(6) = 0.7595238095238095, 0.6933473389355742, 0.6931471805604038 +ln(7) = 0.6345238095238095, 0.6930033416875522, 0.6931471805599444 +ln(8) = 0.7456349206349207, 0.6932539682539682, 0.6931471805599426 +ln(9) = 0.6456349206349206, 0.6930657506744463, 0.6931471805599453 +ln = 0.6931471805599453, 0.6931471805599453, 0.6931471805599453 + +prime numbers: 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 diff --git a/test/files/run/Course-2002-10.scala b/test/files/run/Course-2002-10.scala new file mode 100644 index 0000000000..e978bc8258 --- /dev/null +++ b/test/files/run/Course-2002-10.scala @@ -0,0 +1,135 @@ +//############################################################################ +// Programmation IV - 2002 - Week 10 +//############################################################################ + +import Math.{Pi, log} + +object M0 { + + def addStream (s1: Stream[Int], s2: Stream[Int]): Stream[Int] = + Stream.cons(s1.head + s2.head, addStream(s1.tail, s2.tail)); + + val fib: Stream[Int] = + Stream.cons(0, Stream.cons(1, addStream(this.fib, this.fib.tail))); + + def test = { + var i = 0; + fib.take(20).foreach(n => {Console.println("fib("+i+") = "+n); i=i+1}); + Console.println; + } +} + +//############################################################################ + +object M1 { + + def scale(x: Double, s: Stream[Double]): Stream[Double] = + s map { e: Double => e*x } + + def partialSums(s: Stream[Double]): Stream[Double] = + Stream.cons(s.head, partialSums(s.tail) map (x => x + s.head)); + + def euler(s: Stream[Double]): Stream[Double] = { + val nm1 = s apply 0; + val n = s apply 1; + val np1 = s apply 2; + Stream.cons(np1 - ((np1 - n)*(np1 - n) / (nm1 - 2*n + np1)),euler(s.tail)) + }; + + def better(s: Stream[Double], transform: Stream[Double] => Stream[Double]) + : Stream[Stream[Double]] = + Stream.cons(s, better(transform(s), transform)); + + def veryGood(s: Stream[Double], transform: Stream[Double] => Stream[Double]) + : Stream[Double] = + better(s, transform) map (x => x.head); + + def lnSummands(n: Double): Stream[Double] = + Stream.cons(1.0 / n, lnSummands(n + 1.0) map { x: Double => -x }) + + var ln0 = partialSums(lnSummands(1.0)); + var ln1 = euler(ln0); + var ln2 = veryGood(ln0, euler); + + def piSummands(n: Double): Stream[Double] = + Stream.cons(1.0 / n, piSummands(n + 2.0) map { x: Double => -x }) + + var pi0 = scale(4.0, partialSums(piSummands(1.0))); + var pi1 = euler(pi0); + var pi2 = veryGood(pi0, euler); + + def pad(s: String, n: Int): String = + if (n <= 0) s.substring(0, s.length() + n) + else pad(s + " ", n - 1); + def str(d: Double) = { val s = d.toString(); pad(s, 18 - s.length()) }; + + def test = { + var i = 0; + while (i < 10) { + Console.print("pi("+i+") = "); + Console.print(str(pi0.apply(i)) + ", "); + Console.print(str(pi1.apply(i)) + ", "); + Console.print(str(pi2.apply(i)) + "\n"); + i = i + 1; + } + Console.print("pi = "); + Console.print(str(Pi) + ", "); + Console.print(str(Pi) + ", "); + Console.print(str(Pi) + "\n"); + Console.println; + i = 0; + while (i < 10) { + Console.print("ln("+i+") = "); + Console.print(str(ln0.apply(i)) + ", "); + Console.print(str(ln1.apply(i)) + ", "); + Console.print(str(ln2.apply(i)) + "\n"); + i = i + 1; + } + Console.print("ln = "); + Console.print(str(log(2)) + ", "); + Console.print(str(log(2)) + ", "); + Console.print(str(log(2)) + "\n"); + Console.println; + } +} + +//############################################################################ + +object M2 { + + class IntIterator(start: Int) extends Iterator[Int] { + var current: Int = start; + def hasNext = true; + def next = { current = current + 1; current - 1 }; + } + + class PrimeIterator() extends Iterator[Int] { + var current: Iterator[Int] = new IntIterator(2); + def hasNext = true; + def next = { + val p = current.next; + current = current filter { x => !((x % p) == 0) }; + p + } + } + + def test = { + val i = (new PrimeIterator()).take(30); + Console.print("prime numbers:"); + while (i.hasNext) { Console.print(" " + i.next); } + Console.println; + } +} + +//############################################################################ + +object Test { + def main(args: Array[String]): Unit = { + M0.test; + M1.test; + M2.test; + () + } +} + +//############################################################################ diff --git a/test/files/run/Course-2002-13.check b/test/files/run/Course-2002-13.check new file mode 100644 index 0000000000..7664f70576 --- /dev/null +++ b/test/files/run/Course-2002-13.check @@ -0,0 +1,14 @@ +List(S = jean, V = mange, A = le, D = grand, N = table) +List(S = jean, V = mange, A = le, D = grand, N = cheval) + +List(S = jean, V = mange, A = le, D = grand, N = cheval) +List(S = jean, V = mange, A = la, D = belle, N = table) + +List(S = jean, V = mange, A = le, D = nil, N = cheval) +List(S = jean, V = mange, A = le, D = cons(grand,nil), N = cheval) +List(S = jean, V = mange, A = le, D = cons(grand,cons(grand,nil)), N = cheval) +List(S = jean, V = mange, A = la, D = nil, N = table) +yes +yes +no + diff --git a/test/files/run/Course-2002-13.scala b/test/files/run/Course-2002-13.scala new file mode 100644 index 0000000000..c016d41a90 --- /dev/null +++ b/test/files/run/Course-2002-13.scala @@ -0,0 +1,323 @@ +//############################################################################ +// Programmation IV - 2002 - Week 13 +//############################################################################ + +class Tokenizer(s: String, delimiters: String) extends Iterator[String] { + + private var i = 0; + + def isDelimiter(ch: Char) = { + var i = 0; + while (i < delimiters.length() && delimiters.charAt(i) != ch) { i = i + 1 } + i < delimiters.length() + } + + def hasNext: Boolean = { + while (i < s.length() && s.charAt(i) <= ' ') { i = i + 1 } + i < s.length() + } + + def next: String = + if (hasNext) { + val start = i; + var ch = s.charAt(i); i = i + 1; + if (isDelimiter(ch)) ch.toString() + else { + while (i < s.length() && + s.charAt(i) > ' ' && + !isDelimiter(s.charAt(i))){ i = i + 1 } + s.substring(start, i) + } + } else ""; + +} + +object Terms { + + val debug = false; + + trait Term { + def map(s: Subst): Term; + def tyvars: List[String]; + } + + case class Binding(name: String, term: Term) { + term match { case Var(n) if (name == n) => error("bad binding") case _ => () } + override def toString() = name + " = " + term; + } + + type Subst = List[Binding]; + + def lookup(s: Subst, name: String): Option[Term] = s match { + case List() => None + case b :: s1 => if (name == b.name) Some(b.term) else lookup(s1, name) + } + + case class Var(a: String) extends Term { + override def toString() = a; + def map(s: Subst): Term = lookup(s, a) match { + case Some(b) => b map s + case None => this; + } + def tyvars = List(a); + } + + case class Con(a: String, ts: List[Term]) extends Term { + override def toString() = + a + (if (ts.isEmpty) "" else ts.mkString("(", ",", ")")); + def map(s: Subst): Term = Con(a, ts map (t => t map s)); + def tyvars = (ts flatMap (t => t.tyvars)).distinct; + } + + private var count = 0; + def newVar(prefix: String) = { count = count + 1; Var(prefix + count) } + + val NoTerm = Con("<none>", List()); + + def unify1(x: Term, y: Term, s: Subst): Option[Subst] = Pair(x, y) match { + case Pair(Var(a), Var(b)) if (a == b) => + Some(s) + case Pair(Var(a), _) => lookup(s, a) match { + case Some(x1) => unify(x1, y, s) + case None => if (y.tyvars contains a) None else Some(Binding(a, y) :: s) + } + case Pair(_, Var(b)) => lookup(s, b) match { + case Some(y1) => unify(x, y1, s) + case None => if (x.tyvars contains b) None else Some(Binding(b, x) :: s) + } + case Pair(Con(a, xs), Con(b, ys)) if (a == b) => + unify(xs, ys, s) + case _ => None + } + + def unify(x: Term, y: Term, s: Subst): Option[Subst] = { + val ss = unify1(x, y, s); + if (debug) Console.println("unify " + x + " with " + y + " = " + ss); + ss + } + + def unify(xs: List[Term], ys: List[Term], s: Subst): Option[Subst] = Pair(xs, ys) match { + case Pair(List(), List()) => Some(s) + case Pair(x :: xs1, y :: ys1) => + unify(x, y, s) match { + case Some(s1) => unify(xs1, ys1, s1) + case None => None + } + case _ => None + } +} + +import Terms._; + +object Programs { + + case class Clause(lhs: Term, rhs: List[Term]) { + def tyvars = + (lhs.tyvars ::: (rhs flatMap (t => t.tyvars))).distinct; + def newInstance = { + var s: Subst = List(); + for (val a <- tyvars) { s = Binding(a, newVar(a)) :: s } + Clause(lhs map s, rhs map (t => t map s)) + } + override def toString() = + lhs.toString() + " :- " + rhs.mkString("", ",", "") + "."; + } + + def list2stream[a](xs: List[a]): Stream[a] = xs match { + case List() => Stream.empty + case x :: xs1 => Stream.cons(x, list2stream(xs1)) + } + def option2stream[a](xo: Option[a]): Stream[a] = xo match { + case None => Stream.empty + case Some(x) => Stream.cons(x, Stream.empty) + } + + def solve(query: List[Term], clauses: List[Clause]): Stream[Subst] = { + + def solve2(query: List[Term], s: Subst): Stream[Subst] = query match { + case List() => + Stream.cons(s, Stream.empty) + case Con("not", qs) :: query1 => + if (solve1(qs, s).isEmpty) Stream.cons(s, Stream.empty) + else Stream.empty + case q :: query1 => + for (val clause <- list2stream(clauses); + val s1 <- tryClause(clause.newInstance, q, s); + val s2 <- solve1(query1, s1)) yield s2 + } + + def solve1(query: List[Term], s: Subst): Stream[Subst] = { + val ss = solve2(query, s); + if (debug) Console.println("solved " + query + " = " + ss); + ss + } + + def tryClause(c: Clause, q: Term, s: Subst): Stream[Subst] = { + if (debug) Console.println("trying " + c); + for (val s1 <- option2stream(unify(q, c.lhs, s)); + val s2 <- solve1(c.rhs, s1)) yield s2; + } + + solve1(query, List()) + } +} + +import Programs._; + +class Parser(s: String) { + val it = new Tokenizer(s, "(),.?"); + + var token: String = it.next; + + def syntaxError(msg: String): Unit = error(msg + ", but " + token + " found"); + + def rep[a](p: => a): List[a] = { + val t = p; + if (token == ",") { token = it.next; t :: rep(p) } else List(t) + } + + def constructor: Term = { + val a = token; + token = it.next; + Con(a, + if (token equals "(") { + token = it.next; + val ts: List[Term] = if (token equals ")") List() else rep(term); + if (token equals ")") token = it.next else syntaxError("`)' expected"); + ts + } else List()) + } + + def term: Term = { + val ch = token.charAt(0); + if ('A' <= ch && ch <= 'Z') { val a = token; token = it.next; Var(a) } + else if (it.isDelimiter(ch)) { syntaxError("term expected"); null } + else constructor + } + + def line: Clause = { + val result = + if (token equals "?") { + token = it.next; + Clause(NoTerm, rep(constructor)); + } else { + Clause( + constructor, + if (token equals ":-") { token = it.next; rep(constructor) } else List()) + } + if (token equals ".") token = it.next else syntaxError("`.' expected"); + result + } + + def all: List[Clause] = if (token equals "") List() else line :: all; +} + +object Prolog { + + def processor: String => Unit = { + var program: List[Clause] = List(); + var solutions: Stream[Subst] = Stream.empty; + var tvs: List[String] = List(); + { input => + new Parser(input).all foreach { c => + if (c.lhs == NoTerm) { + c.rhs match { + case List(Con("more", List())) => + solutions = solutions.tail; + case _ => + solutions = solve(c.rhs, program); + tvs = c.tyvars; + } + if (solutions.isEmpty) { + Console.println("no") + } else { + val s: Subst = solutions.head + .filter(b => tvs contains b.name) + .map(b => Binding(b.name, b.term map solutions.head)) + .reverse; + if (s.isEmpty) Console.println("yes") + else Console.println(s); + } + } else { + program = program ::: List(c); + } + } + } + } + + def process(code: String) = processor(code); +} + +//############################################################################ + +object Test { + def main(args: Array[String]): Unit = { + Prolog.process( + "sujet(jean).\n" + + "sujet(marie).\n" + + "verbe(mange).\n" + + "verbe(dort).\n" + + "article(le).\n" + + "article(la).\n" + + "adjectif(grand).\n" + + "adjectif(belle).\n" + + "nom(table).\n" + + "nom(cheval).\n" + + + "complement(A,D,N) :- article(A), adjectif(D), nom(N).\n" + + "phrase(S,V,A,D,N) :- sujet(S), verbe(V), complement(A,D,N).\n" + + + "?phrase(S,V,A,D,N).\n" + "?more.\n" + ); + Console.println; + + Prolog.process( + "sujet(jean).\n" + + "sujet(marie).\n" + + "verbe(mange).\n" + + "verbe(dort).\n" + + "article(le,m).\n" + + "article(la,f).\n" + + "adjectif(grand,m).\n" + + "adjectif(belle,f).\n" + + "nom(table,f).\n" + + "nom(cheval,m).\n" + + + "complement(A,D,N) :- article(A,G), adjectif(D,G), nom(N,G).\n" + + "phrase(S,V,A,D,N) :- sujet(S), verbe(V), complement(A,D,N).\n" + + + "?phrase(S,V,A,D,N).\n" + "?more.\n" + ); + Console.println; + + Prolog.process( + "sujet(jean).\n" + + "sujet(marie).\n" + + "verbe(mange).\n" + + "verbe(dort).\n" + + "article(le,m).\n" + + "article(la,f).\n" + + "adjectif(grand,m).\n" + + "adjectif(belle,f).\n" + + "nom(table,f).\n" + + "nom(cheval,m).\n" + + + "adjectifs(nil,G).\n" + + "adjectifs(cons(A1,nil),G) :- adjectif(A1,G).\n" + + "adjectifs(cons(A1,cons(A2,nil)),G) :- adjectif(A1,G),adjectif(A2,G).\n"+ + "complement(A,D,N) :- article(A,G), adjectifs(D,G), nom(N,G).\n" + + "phrase(S,V,A,D,N) :- sujet(S), verbe(V), complement(A,D,N).\n" + + + "?phrase(S,V,A,D,N).\n" + "?more.\n" + "?more.\n" + "?more.\n" + + + "?phrase(jean,mange,le,nil,cheval).\n" + + "?phrase(jean,mange,le,cons(grand,nil),cheval).\n" + + "?phrase(jean,mange,le,cons(grand,nil),table).\n" + ); + Console.println; + + () + } +} + +//############################################################################ diff --git a/test/files/run/json.scala b/test/files/run/json.scala.disabled index ec0bad7ebe..2e7ee4aa4d 100644 --- a/test/files/run/json.scala +++ b/test/files/run/json.scala.disabled @@ -8,7 +8,7 @@ object Test extends Application { printJSON("{\"name\": \"va1ue\"}") // ticket #136 printJSON("{\"name\": { \"name1\": \"va1ue1\", \"name2\": \"va1ue2\" } }") printJSON("{\"name\": \"\\u0022\"}") - printJSON("{\"age\": 0}") + printJSON("{\"age\": 0}") println // from http://en.wikipedia.org/wiki/JSON @@ -63,7 +63,7 @@ object Test extends Application { // from http://json.org/example.html val sample3 = """ {"web-app": { - "servlet": [ + "servlet": [ { "servlet-name": "cofaxCDS", "servlet-class": "org.cofax.cds.CDSServlet", @@ -119,7 +119,7 @@ object Test extends Application { { "servlet-name": "cofaxAdmin", "servlet-class": "org.cofax.cds.AdminServlet"}, - + { "servlet-name": "fileServlet", "servlet-class": "org.cofax.cds.FileServlet"}, @@ -146,7 +146,7 @@ object Test extends Application { "cofaxAdmin": "/admin/*", "fileServlet": "/static/*", "cofaxTools": "/tools/*"}, - + "taglib": { "taglib-uri": "cofax.tld", "taglib-location": "/WEB-INF/tlds/cofax.tld"} diff --git a/test/files/run/numbereq.scala b/test/files/run/numbereq.scala new file mode 100644 index 0000000000..52f32cc52a --- /dev/null +++ b/test/files/run/numbereq.scala @@ -0,0 +1,41 @@ +object Test { + def mkNumbers(x: Int): List[AnyRef] = { + val base = List( + BigDecimal(x), + BigInt(x), + new java.lang.Double(x.toDouble), + new java.lang.Float(x.toFloat), + new java.lang.Long(x.toLong), + new java.lang.Integer(x) + ) + val extras = List( + if (x >= Short.MinValue && x <= Short.MaxValue) List(new java.lang.Short(x.toShort)) else Nil, + if (x >= Byte.MinValue && x <= Byte.MaxValue) List(new java.lang.Byte(x.toByte)) else Nil, + if (x >= Char.MinValue && x <= Char.MaxValue) List(new java.lang.Character(x.toChar)) else Nil + ).flatten + + base ::: extras + } + + + def main(args: Array[String]): Unit = { + val ints = (0 to 15).toList map (Short.MinValue >> _) + val ints2 = ints map (x => -x) + val ints3 = ints map (_ + 1) + val ints4 = ints2 map (_ - 1) + + val setneg1 = ints map mkNumbers + val setneg2 = ints3 map mkNumbers + val setpos1 = ints2 map mkNumbers + val setpos2 = ints4 map mkNumbers + val zero = mkNumbers(0) + + val sets = setneg1 ++ setneg2 ++ List(zero) ++ setpos1 ++ setpos2 + + for (set <- sets ; x <- set ; y <- set) { + println("'%s' == '%s' (%s == %s) (%s == %s)".format(x, y, x.hashCode, y.hashCode, x.##, y.##)) + assert(x == y, "%s/%s != %s/%s".format(x, x.getClass, y, y.getClass)) + assert(x.## == y.##, "%s != %s".format(x.getClass, y.getClass)) + } + } +}
\ No newline at end of file diff --git a/test/files/run/spec-matrix.check b/test/files/run/spec-matrix.check deleted file mode 100644 index 72e8ffc0db..0000000000 --- a/test/files/run/spec-matrix.check +++ /dev/null @@ -1 +0,0 @@ -* diff --git a/test/files/run/spec-matrix.scala b/test/files/run/spec-matrix.scala deleted file mode 100644 index 81e3eaf212..0000000000 --- a/test/files/run/spec-matrix.scala +++ /dev/null @@ -1,70 +0,0 @@ -/** Test matrix multiplication with specialization. - */ - -class Matrix[@specialized A: ClassManifest](val rows: Int, val cols: Int) { - private val arr: Array[Array[A]] = new Array[Array[A]](rows, cols) - - def apply(i: Int, j: Int): A = { - if (i < 0 || i >= rows || j < 0 || j >= cols) - throw new NoSuchElementException("Indexes out of bounds: " + (i, j)) - - arr(i)(j) - } - - def update(i: Int, j: Int, e: A) { - arr(i)(j) = e - } - - def rowsIterator: Iterator[Array[A]] = new Iterator[Array[A]] { - var idx = 0; - def hasNext = idx < rows - def next = { - idx += 1 - arr(idx - 1) - } - } -} - -object Test { - def main(args: Array[String]) { - val m = randomMatrix(200, 100) - val n = randomMatrix(100, 200) - - mult(m, n) - println("*") - } - - def randomMatrix(n: Int, m: Int) = { - val r = new util.Random(10) - val x = new Matrix[Int](n, m) - for (i <- 0 until n; j <- 0 until m) - x(i, j) = r.nextInt - x - } - - - def multManifest[@specialized(Int) T](m: Matrix[T], n: Matrix[T])(implicit cm: ClassManifest[T], num: Numeric[T]) { - val p = new Matrix[T](m.rows, n.cols) - import num._ - - for (i <- 0 until m.rows) - for (j <- 0 until n.cols) { - var sum = num.zero - for (k <- 0 until n.rows) - sum += m(i, k) * n(k, j) - p(i, j) = sum - } - } - - def mult(m: Matrix[Int], n: Matrix[Int]) { - val p = new Matrix[Int](m.rows, n.cols) - - for (i <- 0 until m.rows) - for (j <- 0 until n.cols) { - var sum = 0 - for (k <- 0 until n.rows) - sum += m(i, k) * n(k, j) - p(i, j) = sum - } - } -} diff --git a/test/files/run/streamWithFilter.check b/test/files/run/streamWithFilter.check new file mode 100644 index 0000000000..6b0e91a147 --- /dev/null +++ b/test/files/run/streamWithFilter.check @@ -0,0 +1,5 @@ +15 +30 +45 +60 +75 diff --git a/test/files/run/streamWithFilter.scala b/test/files/run/streamWithFilter.scala new file mode 100644 index 0000000000..cb919d4f55 --- /dev/null +++ b/test/files/run/streamWithFilter.scala @@ -0,0 +1,11 @@ +object Test { + val nums = Stream.from(1) + def isFizz(x: Int) = x % 3 == 0 + def isBuzz(x: Int) = x % 5 == 0 + // next line will run forever if withFilter isn't doing its thing. + val fizzbuzzes = for (n <- nums ; if isFizz(n) ; if isBuzz(n)) yield n + + def main(args: Array[String]): Unit = { + fizzbuzzes take 5 foreach println + } +} diff --git a/test/files/run/t3241.check b/test/files/run/t3241.check new file mode 100644 index 0000000000..348ebd9491 --- /dev/null +++ b/test/files/run/t3241.check @@ -0,0 +1 @@ +done
\ No newline at end of file diff --git a/test/files/run/t3241.scala b/test/files/run/t3241.scala new file mode 100644 index 0000000000..40097a046f --- /dev/null +++ b/test/files/run/t3241.scala @@ -0,0 +1,23 @@ +object Test { + + def main(args : Array[String]) : Unit = { + recurse(Map(1->1, 2->2, 3->3, 4->4, 5->5, 6->6, 7->7)) + recurse(Set(1,2,3,4,5,6,7)) + println("done") + } + + def recurse(map: collection.immutable.Map[Int, Int]): Unit = { + if (!map.isEmpty) { + val x = map.keys.head + recurse(map - x) + } + } + + def recurse(set: collection.immutable.Set[Int]): Unit = { + if (!set.isEmpty) { + val x = set.toStream.head + recurse(set - x) + } + } + +} diff --git a/test/files/scalacheck/redblack.scala b/test/files/scalacheck/redblack.scala new file mode 100644 index 0000000000..0334c1218d --- /dev/null +++ b/test/files/scalacheck/redblack.scala @@ -0,0 +1,157 @@ +import org.scalacheck._ +import Prop._ +import Gen._ + +/* +Properties of a Red & Black Tree: + +A node is either red or black. +The root is black. (This rule is used in some definitions and not others. Since the +root can always be changed from red to black but not necessarily vice-versa this +rule has little effect on analysis.) +All leaves are black. +Both children of every red node are black. +Every simple path from a given node to any of its descendant leaves contains the same number of black nodes. +*/ + +abstract class RedBlackTest extends Properties("RedBlack") { + object RedBlackTest extends scala.collection.immutable.RedBlack[Int] { + def isSmaller(x: Int, y: Int) = x < y + } + + import RedBlackTest._ + + def rootIsBlack[A](t: Tree[A]) = t.isBlack + + def areAllLeavesBlack[A](t: Tree[A]): Boolean = t match { + case Empty => t.isBlack + case ne: NonEmpty[_] => List(ne.left, ne.right) forall areAllLeavesBlack + } + + def areRedNodeChildrenBlack[A](t: Tree[A]): Boolean = t match { + case RedTree(_, _, left, right) => List(left, right) forall (t => t.isBlack && areRedNodeChildrenBlack(t)) + case BlackTree(_, _, left, right) => List(left, right) forall areRedNodeChildrenBlack + case Empty => true + } + + def blackNodesToLeaves[A](t: Tree[A]): List[Int] = t match { + case Empty => List(1) + case BlackTree(_, _, left, right) => List(left, right) flatMap blackNodesToLeaves map (_ + 1) + case RedTree(_, _, left, right) => List(left, right) flatMap blackNodesToLeaves + } + + def areBlackNodesToLeavesEqual[A](t: Tree[A]): Boolean = t match { + case Empty => true + case ne: NonEmpty[_] => + ( + blackNodesToLeaves(ne).removeDuplicates.size == 1 + && areBlackNodesToLeavesEqual(ne.left) + && areBlackNodesToLeavesEqual(ne.right) + ) + } + + def orderIsPreserved[A](t: Tree[A]): Boolean = t match { + case Empty => true + case ne: NonEmpty[_] => + ( + (ne.left.iterator map (_._1) forall (isSmaller(_, ne.key))) + && (ne.right.iterator map (_._1) forall (isSmaller(ne.key, _))) + && (List(ne.left, ne.right) forall orderIsPreserved) + ) + } + + def setup(l: List[Int], invariant: Tree[Unit] => Boolean): (Boolean, Tree[Unit]) + + def listNoRepetitions(size: Int) = for { + s <- Gen.choose(1, size) + l <- Gen.listOfN(size, Gen.choose(0, Int.MaxValue)) suchThat (l => l.size == l.removeDuplicates.size) + } yield l + def listFewRepetitions(size: Int) = for { + s <- Gen.choose(1, size) + l <- Gen.listOfN(s, Gen.choose(0, size * 4)) suchThat (l => l.size != l.removeDuplicates.size) + } yield l + def listManyRepetitions(size: Int) = for { + s <- Gen.choose(1, size) + l <- Gen.listOfN(s, Gen.choose(0, size)) suchThat (l => l.size != l.removeDuplicates.size) + } yield l + def listEvenRepetitions(size: Int) = listFewRepetitions(size) map (x => + scala.util.Random.shuffle(x zip x flatMap { case (a, b) => List(a, b) }) + ) + + // Arbitrarily weighted list distribution types + val seqType: Gen[Int => Gen[List[Int]]] + + def myGen(sized: Int) = for { + size <- Gen.choose(0, sized) + seq <- seqType + list <- seq(size) + } yield list + + property("root is black") = forAll(myGen(10)) { l => + setup(l, rootIsBlack)._1 :| setup(l, rootIsBlack)._2.toString + } + property("all leaves are black") = forAll(myGen(50)) { l => + setup(l, areAllLeavesBlack)._1 :| setup(l, areAllLeavesBlack)._2.toString + } + property("children of red nodes are black") = forAll(myGen(50)) { l => + setup(l, areRedNodeChildrenBlack)._1 :| setup(l, areRedNodeChildrenBlack)._2.toString + } + property("Every path from a node to its descendant leaves contains the same number of black nodes") = forAll(myGen(50)) { l => + setup(l, areBlackNodesToLeavesEqual)._1 :| setup(l, areBlackNodesToLeavesEqual)._2.toString + } + property("Ordering of keys is preserved") = forAll(myGen(50)) { l => + setup(l, orderIsPreserved)._1 :| setup(l, orderIsPreserved)._2.toString + } +} + +object TestInsertion extends RedBlackTest { + import RedBlackTest._ + override val seqType = Gen.frequency( + (1, listNoRepetitions _), + (1, listManyRepetitions _) + ) + + property("update adds elements") = forAll(myGen(50)) { l => + val tree = l.foldLeft(Empty: Tree[Unit])((acc, n) => acc update (n, ())) + forAll(Gen.pick(1, l)) ( n => !(tree lookup n.head isEmpty) :| "Tree: "+tree+" N: "+n.head ) + } + + override def setup(l: List[Int], invariant: Tree[Unit] => Boolean) = l.foldLeft((true, Empty: Tree[Unit])) { + case ((true, acc), n) => + val newRoot = acc update (n, ()) + (invariant(newRoot), newRoot) + case (failed, _) => failed + } +} + +object TestDeletion extends RedBlackTest { + import RedBlackTest._ + override val seqType = Gen.frequency( + (2, listFewRepetitions _), + (3, listManyRepetitions _), + (1, listEvenRepetitions _) + ) + + property("delete removes elements") = forAll(myGen(50)) { l => + val tree = l.foldLeft(Empty: Tree[Unit])((acc, n) => acc update (n, ())) + forAll(Gen.choose(1, l.size)) { numberOfElementsToRemove => + forAll(Gen.pick(numberOfElementsToRemove, l)) { elementsToRemove => + val newTree = elementsToRemove.foldLeft(tree)((acc, n) => acc delete n) + (elementsToRemove forall (n => newTree lookup n isEmpty)) :| "Tree: "+tree+"New Tree: "+newTree+" Elements to Remove: "+elementsToRemove + } + } + } + + override def setup(l: List[Int], invariant: Tree[Unit] => Boolean) = l.foldLeft((true, Empty: Tree[Unit])) { + case ((true, acc), n) => + val newRoot = if (acc lookup n isEmpty) acc update (n, ()) else acc delete n + (invariant(newRoot), newRoot) + case (failed, _) => failed + } +} + +object Test extends Properties("RedBlack") { + include(TestInsertion) + include(TestDeletion) +} + |