diff options
Diffstat (limited to 'test')
68 files changed, 1132 insertions, 122 deletions
diff --git a/test/files/continuations-neg/t5314-missing-result-type.check b/test/files/continuations-neg/t5314-missing-result-type.check new file mode 100644 index 0000000000..341e580cf3 --- /dev/null +++ b/test/files/continuations-neg/t5314-missing-result-type.check @@ -0,0 +1,4 @@ +t5314-missing-result-type.scala:6: error: method bar has return statement; needs result type + def bar(x:Int) = return foo(x) + ^ +one error found diff --git a/test/files/continuations-neg/t5314-missing-result-type.scala b/test/files/continuations-neg/t5314-missing-result-type.scala new file mode 100644 index 0000000000..d7c5043a86 --- /dev/null +++ b/test/files/continuations-neg/t5314-missing-result-type.scala @@ -0,0 +1,13 @@ +import scala.util.continuations._ + +object Test extends App { + def foo(x:Int): Int @cps[Int] = x + + def bar(x:Int) = return foo(x) + + reset { + val res = bar(8) + println(res) + res + } +} diff --git a/test/files/continuations-neg/t5314-npe.check b/test/files/continuations-neg/t5314-npe.check new file mode 100644 index 0000000000..b5f024aa89 --- /dev/null +++ b/test/files/continuations-neg/t5314-npe.check @@ -0,0 +1,4 @@ +t5314-npe.scala:2: error: method bar has return statement; needs result type + def bar(x:Int) = { return x; x } // NPE + ^ +one error found diff --git a/test/files/continuations-neg/t5314-npe.scala b/test/files/continuations-neg/t5314-npe.scala new file mode 100644 index 0000000000..2b5966e07c --- /dev/null +++ b/test/files/continuations-neg/t5314-npe.scala @@ -0,0 +1,3 @@ +object Test extends App { + def bar(x:Int) = { return x; x } // NPE +} diff --git a/test/files/continuations-neg/t5314-return-reset.check b/test/files/continuations-neg/t5314-return-reset.check new file mode 100644 index 0000000000..4c817ae14d --- /dev/null +++ b/test/files/continuations-neg/t5314-return-reset.check @@ -0,0 +1,4 @@ +t5314-return-reset.scala:14: error: return expression not allowed, since method calls CPS method + if (rnd.nextInt(100) > 50) return 5 // not allowed, since method is calling `reset` + ^ +one error found diff --git a/test/files/continuations-neg/t5314-return-reset.scala b/test/files/continuations-neg/t5314-return-reset.scala new file mode 100644 index 0000000000..df9d58e4cb --- /dev/null +++ b/test/files/continuations-neg/t5314-return-reset.scala @@ -0,0 +1,21 @@ +import scala.util.continuations._ +import scala.util.Random + +object Test extends App { + val rnd = new Random + + def foo(x: Int): Int @cps[Int] = shift { k => k(x) } + + def bar(x: Int): Int @cps[Int] = return foo(x) + + def caller(): Int = { + val v: Int = reset { + val res: Int = bar(8) + if (rnd.nextInt(100) > 50) return 5 // not allowed, since method is calling `reset` + 42 + } + v + } + + caller() +} diff --git a/test/files/continuations-neg/t5314-type-error.check b/test/files/continuations-neg/t5314-type-error.check new file mode 100644 index 0000000000..1f4e46a7f2 --- /dev/null +++ b/test/files/continuations-neg/t5314-type-error.check @@ -0,0 +1,6 @@ +t5314-type-error.scala:7: error: type mismatch; + found : Int @util.continuations.cps[Int] + required: Int @util.continuations.cps[String] + def bar(x:Int): Int @cps[String] = return foo(x) + ^ +one error found diff --git a/test/files/continuations-neg/t5314-type-error.scala b/test/files/continuations-neg/t5314-type-error.scala new file mode 100644 index 0000000000..e36ce6c203 --- /dev/null +++ b/test/files/continuations-neg/t5314-type-error.scala @@ -0,0 +1,17 @@ +import scala.util.continuations._ + +object Test extends App { + def foo(x:Int): Int @cps[Int] = shift { k => k(x) } + + // should be a type error + def bar(x:Int): Int @cps[String] = return foo(x) + + def caller(): Unit = { + val v: String = reset { + val res: Int = bar(8) + "hello" + } + } + + caller() +} diff --git a/test/files/continuations-run/t5314-2.check b/test/files/continuations-run/t5314-2.check new file mode 100644 index 0000000000..35b3c93780 --- /dev/null +++ b/test/files/continuations-run/t5314-2.check @@ -0,0 +1,5 @@ +8 +hi +8 +from try +8 diff --git a/test/files/continuations-run/t5314-2.scala b/test/files/continuations-run/t5314-2.scala new file mode 100644 index 0000000000..8a896dec2c --- /dev/null +++ b/test/files/continuations-run/t5314-2.scala @@ -0,0 +1,44 @@ +import scala.util.continuations._ + +class ReturnRepro { + def s1: Int @cps[Any] = shift { k => k(5) } + def caller = reset { println(p(3)) } + def caller2 = reset { println(p2(3)) } + def caller3 = reset { println(p3(3)) } + + def p(i: Int): Int @cps[Any] = { + val v= s1 + 3 + return v + } + + def p2(i: Int): Int @cps[Any] = { + val v = s1 + 3 + if (v > 0) { + println("hi") + return v + } else { + println("hi") + return 8 + } + } + + def p3(i: Int): Int @cps[Any] = { + val v = s1 + 3 + try { + println("from try") + return v + } catch { + case e: Exception => + println("from catch") + return 7 + } + } + +} + +object Test extends App { + val repro = new ReturnRepro + repro.caller + repro.caller2 + repro.caller3 +} diff --git a/test/files/continuations-run/t5314-3.check b/test/files/continuations-run/t5314-3.check new file mode 100644 index 0000000000..71489f097c --- /dev/null +++ b/test/files/continuations-run/t5314-3.check @@ -0,0 +1,4 @@ +enter return expr +8 +hi +8 diff --git a/test/files/continuations-run/t5314-3.scala b/test/files/continuations-run/t5314-3.scala new file mode 100644 index 0000000000..62c547f5a2 --- /dev/null +++ b/test/files/continuations-run/t5314-3.scala @@ -0,0 +1,27 @@ +import scala.util.continuations._ + +class ReturnRepro { + def s1: Int @cpsParam[Any, Unit] = shift { k => k(5) } + def caller = reset { println(p(3)) } + def caller2 = reset { println(p2(3)) } + + def p(i: Int): Int @cpsParam[Unit, Any] = { + val v= s1 + 3 + return { println("enter return expr"); v } + } + + def p2(i: Int): Int @cpsParam[Unit, Any] = { + val v = s1 + 3 + if (v > 0) { + return { println("hi"); v } + } else { + return { println("hi"); 8 } + } + } +} + +object Test extends App { + val repro = new ReturnRepro + repro.caller + repro.caller2 +} diff --git a/test/files/continuations-run/t5314-with-if.check b/test/files/continuations-run/t5314-with-if.check new file mode 100644 index 0000000000..7f8f011eb7 --- /dev/null +++ b/test/files/continuations-run/t5314-with-if.check @@ -0,0 +1 @@ +7 diff --git a/test/files/continuations-run/t5314-with-if.scala b/test/files/continuations-run/t5314-with-if.scala new file mode 100644 index 0000000000..5840199a3c --- /dev/null +++ b/test/files/continuations-run/t5314-with-if.scala @@ -0,0 +1,17 @@ +import scala.util.continuations._ + +object Test extends App { + + def foo(x:Int): Int @cps[Int] = 7 + + def bar(x:Int): Int @cps[Int] = { + val v = foo(x) + if (v > 0) + return v + else + return 10 + } + + println(reset { bar(10) }) + +} diff --git a/test/files/continuations-run/t5314.check b/test/files/continuations-run/t5314.check new file mode 100644 index 0000000000..4b35d8e6d0 --- /dev/null +++ b/test/files/continuations-run/t5314.check @@ -0,0 +1,8 @@ +7 +7 +7 +8 +8 +hi +8 +8 diff --git a/test/files/continuations-run/t5314.scala b/test/files/continuations-run/t5314.scala new file mode 100644 index 0000000000..d611016ce4 --- /dev/null +++ b/test/files/continuations-run/t5314.scala @@ -0,0 +1,52 @@ +import scala.util.continuations._ + +class ReturnRepro { + def s1: Int @cpsParam[Any, Unit] = shift { k => k(5) } + def caller = reset { println(p(3)) } + def caller2 = reset { println(p2(3)) } + + def p(i: Int): Int @cpsParam[Unit, Any] = { + val v= s1 + 3 + return v + } + + def p2(i: Int): Int @cpsParam[Unit, Any] = { + val v = s1 + 3 + if (v > 0) { + println("hi") + return v + } else { + println("hi") + return 8 + } + } +} + +object Test extends App { + def foo(x:Int): Int @cps[Int] = shift { k => k(x) } + + def bar(x:Int): Int @cps[Int] = return foo(x) + + def nocps(x: Int): Int = { return x; x } + + def foo2(x:Int): Int @cps[Int] = 7 + def bar2(x:Int): Int @cps[Int] = { foo2(x); return 7 } + def bar3(x:Int): Int @cps[Int] = { foo2(x); if (x == 7) return 7 else return foo2(x) } + def bar4(x:Int): Int @cps[Int] = { foo2(x); if (x == 7) return 7 else foo2(x) } + def bar5(x:Int): Int @cps[Int] = { foo2(x); if (x == 7) return 7 else 8 } + println(reset { bar2(10) }) + println(reset { bar3(10) }) + println(reset { bar4(10) }) + println(reset { bar5(10) }) + + /* original test case */ + val repro = new ReturnRepro + repro.caller + repro.caller2 + + reset { + val res = bar(8) + println(res) + res + } +} diff --git a/test/files/jvm/actmig-PinS.scala b/test/files/jvm/actmig-PinS.scala index 30307f3737..3f07fab12e 100644 --- a/test/files/jvm/actmig-PinS.scala +++ b/test/files/jvm/actmig-PinS.scala @@ -1,3 +1,7 @@ +/** + * NOTE: Code snippets from this test are included in the Actor Migration Guide. In case you change + * code in these tests prior to the 2.10.0 release please send the notification to @vjovanov. + */ import scala.actors._ import scala.concurrent.duration._ import scala.concurrent.{ Promise, Await } diff --git a/test/files/jvm/actmig-PinS_1.scala b/test/files/jvm/actmig-PinS_1.scala index 640684f728..876688ca75 100644 --- a/test/files/jvm/actmig-PinS_1.scala +++ b/test/files/jvm/actmig-PinS_1.scala @@ -1,4 +1,9 @@ +/** + * NOTE: Code snippets from this test are included in the Actor Migration Guide. In case you change + * code in these tests prior to the 2.10.0 release please send the notification to @vjovanov. + */ import scala.actors._ +import scala.actors.migration._ import scala.concurrent.duration._ import scala.concurrent.{ Promise, Await } diff --git a/test/files/jvm/actmig-PinS_2.scala b/test/files/jvm/actmig-PinS_2.scala index 761df6b5a7..7d12578f71 100644 --- a/test/files/jvm/actmig-PinS_2.scala +++ b/test/files/jvm/actmig-PinS_2.scala @@ -1,4 +1,9 @@ -import scala.actors.{ MigrationSystem, StashingActor, ActorRef, Props, Exit } +/** + * NOTE: Code snippets from this test are included in the Actor Migration Guide. In case you change + * code in these tests prior to the 2.10.0 release please send the notification to @vjovanov. + */ +import scala.actors._ +import scala.actors.migration._ import scala.concurrent.duration._ import scala.concurrent.{ Promise, Await } diff --git a/test/files/jvm/actmig-PinS_3.scala b/test/files/jvm/actmig-PinS_3.scala index de9788724d..c2943008b0 100644 --- a/test/files/jvm/actmig-PinS_3.scala +++ b/test/files/jvm/actmig-PinS_3.scala @@ -1,4 +1,9 @@ -import scala.actors.{ MigrationSystem, StashingActor, ActorRef, Terminated, Props } +/** + * NOTE: Code snippets from this test are included in the Actor Migration Guide. In case you change + * code in these tests prior to the 2.10.0 release please send the notification to @vjovanov. + */ +import scala.actors._ +import scala.actors.migration._ import scala.concurrent.duration._ import scala.concurrent.{ Promise, Await } @@ -158,4 +163,4 @@ object Test extends App { stash(m) } }, "default-stash-dispatcher")) -}
\ No newline at end of file +} diff --git a/test/files/jvm/actmig-hierarchy.scala b/test/files/jvm/actmig-hierarchy.scala new file mode 100644 index 0000000000..17a44fda7a --- /dev/null +++ b/test/files/jvm/actmig-hierarchy.scala @@ -0,0 +1,47 @@ +/** + * NOTE: Code snippets from this test are included in the Actor Migration Guide. In case you change + * code in these tests prior to the 2.10.0 release please send the notification to @vjovanov. + */ +import scala.actors._ + + +class ReactorActor extends Reactor[String] { + def act() { + var cond = true + loopWhile(cond) { + react { + case x if x == "hello1" => println("hello") + case "exit" => cond = false + } + } + } +} + +class ReplyActor extends ReplyReactor { + def act() { + var cond = true + loopWhile(cond) { + react { + case "hello" => println("hello") + case "exit" => cond = false; + } + } + } +} + + +object Test { + + def main(args: Array[String]) { + val reactorActor = new ReactorActor + val replyActor = new ReplyActor + reactorActor.start() + replyActor.start() + + reactorActor ! "hello1" + replyActor ! "hello" + + reactorActor ! "exit" + replyActor ! "exit" + } +}
\ No newline at end of file diff --git a/test/files/jvm/actmig-hierarchy_1.scala b/test/files/jvm/actmig-hierarchy_1.scala new file mode 100644 index 0000000000..14f03c9d48 --- /dev/null +++ b/test/files/jvm/actmig-hierarchy_1.scala @@ -0,0 +1,45 @@ +/** + * NOTE: Code snippets from this test are included in the Actor Migration Guide. In case you change + * code in these tests prior to the 2.10.0 release please send the notification to @vjovanov. + */ +import scala.actors._ + +class ReactorActor extends Actor { + def act() { + var cond = true + loopWhile(cond) { + react { + case x: String if x == "hello1" => println("hello") + case "exit" => cond = false + } + } + } +} + +class ReplyActor extends Actor { + def act() { + var cond = true + loopWhile(cond) { + react { + case "hello" => println("hello") + case "exit" => cond = false; + } + } + } +} + +object Test { + + def main(args: Array[String]) { + val reactorActor = new ReactorActor + val replyActor = new ReplyActor + reactorActor.start() + replyActor.start() + + reactorActor ! "hello1" + replyActor ! "hello" + + reactorActor ! "exit" + replyActor ! "exit" + } +}
\ No newline at end of file diff --git a/test/files/jvm/actmig-instantiation.scala b/test/files/jvm/actmig-instantiation.scala new file mode 100644 index 0000000000..d54dff9558 --- /dev/null +++ b/test/files/jvm/actmig-instantiation.scala @@ -0,0 +1,96 @@ +/** + * NOTE: Code snippets from this test are included in the Actor Migration Guide. In case you change + * code in these tests prior to the 2.10.0 release please send the notification to @vjovanov. + */ +import scala.actors.migration.MigrationSystem._ +import scala.actors.migration._ +import scala.actors.Actor._ +import scala.actors._ +import java.util.concurrent.{ TimeUnit, CountDownLatch } +import scala.collection.mutable.ArrayBuffer + +class TestStashingActor extends StashingActor { + + def receive = { case v: Int => Test.append(v); Test.latch.countDown() } + +} + +object Test { + val NUMBER_OF_TESTS = 5 + + // used for sorting non-deterministic output + val buff = ArrayBuffer[Int](0) + val latch = new CountDownLatch(NUMBER_OF_TESTS) + val toStop = ArrayBuffer[ActorRef]() + + def append(v: Int) = synchronized { + buff += v + } + + def main(args: Array[String]) = { + // plain scala actor + val a1 = actor { + react { case v: Int => Test.append(v); Test.latch.countDown() } + } + a1 ! 100 + + // simple instantiation + val a2 = MigrationSystem.actorOf(Props(() => new TestStashingActor, "akka.actor.default-stash-dispatcher")) + a2 ! 200 + toStop += a2 + + // actor of with scala actor + val a3 = MigrationSystem.actorOf(Props(() => actor { + react { case v: Int => Test.append(v); Test.latch.countDown() } + }, "akka.actor.default-stash-dispatcher")) + a3 ! 300 + + // using the manifest + val a4 = MigrationSystem.actorOf(Props(() => new TestStashingActor, "akka.actor.default-stash-dispatcher")) + a4 ! 400 + toStop += a4 + + // deterministic part of a test + // creation without actorOf + try { + val a3 = new TestStashingActor + a3 ! -1 + } catch { + case e => println("OK error: " + e) + } + + // actorOf double creation + try { + val a3 = MigrationSystem.actorOf(Props(() => { + new TestStashingActor + new TestStashingActor + }, "akka.actor.default-stash-dispatcher")) + a3 ! -1 + } catch { + case e => println("OK error: " + e) + } + + // actorOf nesting + try { + val a5 = MigrationSystem.actorOf(Props(() => { + val a6 = MigrationSystem.actorOf(Props(() => new TestStashingActor, "akka.actor.default-stash-dispatcher")) + toStop += a6 + new TestStashingActor + }, "akka.actor.default-stash-dispatcher")) + + a5 ! 500 + toStop += a5 + } catch { + case e => println("Should not throw an exception: " + e) + } + + // output + latch.await(5, TimeUnit.SECONDS) + if (latch.getCount() > 0) { + println("Error: Tasks have not finished!!!") + } + + buff.sorted.foreach(println) + toStop.foreach(_ ! PoisonPill) + } +}
\ No newline at end of file diff --git a/test/files/jvm/actmig-loop-react.check b/test/files/jvm/actmig-loop-react.check index 54cbe942c0..2474cbe71b 100644 --- a/test/files/jvm/actmig-loop-react.check +++ b/test/files/jvm/actmig-loop-react.check @@ -13,3 +13,4 @@ after react do task 1 do string I am a String do task 42 +after react diff --git a/test/files/jvm/actmig-loop-react.scala b/test/files/jvm/actmig-loop-react.scala new file mode 100644 index 0000000000..7f4c6f96dc --- /dev/null +++ b/test/files/jvm/actmig-loop-react.scala @@ -0,0 +1,196 @@ +/** + * NOTE: Code snippets from this test are included in the Actor Migration Guide. In case you change + * code in these tests prior to the 2.10.0 release please send the notification to @vjovanov. + */ +import scala.actors.migration.MigrationSystem._ +import scala.actors.Actor._ +import scala.actors._ +import scala.actors.migration._ +import java.util.concurrent.{ TimeUnit, CountDownLatch } +import scala.collection.mutable.ArrayBuffer +import scala.concurrent.duration._ +import scala.concurrent.{ Promise, Await } + +object Test { + val finishedLWCR, finishedTNR, finishedEH = Promise[Boolean] + val finishedLWCR1, finishedTNR1, finishedEH1 = Promise[Boolean] + + def testLoopWithConditionReact() = { + // Snippet showing composition of receives + // Loop with Condition Snippet - before + val myActor = actor { + var c = true + loopWhile(c) { + react { + case x: Int => + // do task + println("do task") + if (x == 42) { + c = false + finishedLWCR1.success(true) + } + } + } + } + + myActor.start() + myActor ! 1 + myActor ! 42 + + Await.ready(finishedLWCR1.future, 5 seconds) + + // Loop with Condition Snippet - migrated + val myAkkaActor = MigrationSystem.actorOf(Props(() => new StashingActor { + + def receive = { + case x: Int => + // do task + println("do task") + if (x == 42) { + finishedLWCR.success(true) + context.stop(self) + } + } + }, "default-stashing-dispatcher")) + myAkkaActor ! 1 + myAkkaActor ! 42 + } + + def testNestedReact() = { + // Snippet showing composition of receives + // Loop with Condition Snippet - before + val myActor = actor { + var c = true + loopWhile(c) { + react { + case x: Int => + // do task + println("do task " + x) + if (x == 42) { + c = false + } else { + react { + case y: String => + println("do string " + y) + } + } + println("after react") + finishedTNR1.success(true) + } + } + } + myActor.start() + + myActor ! 1 + myActor ! "I am a String" + myActor ! 42 + + Await.ready(finishedTNR1.future, 5 seconds) + + // Loop with Condition Snippet - migrated + val myAkkaActor = MigrationSystem.actorOf(Props(() => new StashingActor { + + def receive = { + case x: Int => + // do task + println("do task " + x) + if (x == 42) { + println("after react") + finishedTNR.success(true) + context.stop(self) + } else + context.become(({ + case y: String => + println("do string " + y) + }: Receive).andThen(x => { + unstashAll() + context.unbecome() + }).orElse { case x => stash() }) + } + }, "default-stashing-dispatcher")) + + myAkkaActor ! 1 + myAkkaActor ! "I am a String" + myAkkaActor ! 42 + + } + + def exceptionHandling() = { + // Stashing actor with act and exception handler + val myActor = MigrationSystem.actorOf(Props(() => new StashingActor { + + def receive = { case _ => println("Dummy method.") } + override def act() = { + loop { + react { + case "fail" => + throw new Exception("failed") + case "work" => + println("working") + case "die" => + finishedEH1.success(true) + exit() + } + } + } + + override def exceptionHandler = { + case x: Exception => println("scala got exception") + } + + }, "default-stashing-dispatcher")) + + myActor ! "work" + myActor ! "fail" + myActor ! "die" + + Await.ready(finishedEH1.future, 5 seconds) + // Stashing actor in Akka style + val myAkkaActor = MigrationSystem.actorOf(Props(() => new StashingActor { + def receive = PFCatch({ + case "fail" => + throw new Exception("failed") + case "work" => + println("working") + case "die" => + finishedEH.success(true) + context.stop(self) + }, { case x: Exception => println("akka got exception") }) + }, "default-stashing-dispatcher")) + + myAkkaActor ! "work" + myAkkaActor ! "fail" + myAkkaActor ! "die" + } + + def main(args: Array[String]) = { + testLoopWithConditionReact() + Await.ready(finishedLWCR.future, 5 seconds) + exceptionHandling() + Await.ready(finishedEH.future, 5 seconds) + testNestedReact() + Await.ready(finishedTNR.future, 5 seconds) + } + +} + +// As per Jim Mcbeath's blog (http://jim-mcbeath.blogspot.com/2008/07/actor-exceptions.html) +class PFCatch(f: PartialFunction[Any, Unit], + handler: PartialFunction[Exception, Unit]) + extends PartialFunction[Any, Unit] { + + def apply(x: Any) = { + try { + f(x) + } catch { + case e: Exception if handler.isDefinedAt(e) => handler(e) + } + } + + def isDefinedAt(x: Any) = f.isDefinedAt(x) +} + +object PFCatch { + def apply(f: PartialFunction[Any, Unit], + handler: PartialFunction[Exception, Unit]) = new PFCatch(f, handler) +} diff --git a/test/files/jvm/actmig-public-methods.check b/test/files/jvm/actmig-public-methods.check index bb6530c926..c861c90e63 100644 --- a/test/files/jvm/actmig-public-methods.check +++ b/test/files/jvm/actmig-public-methods.check @@ -1,6 +1,6 @@ None Some(bang qmark after 1) bang +bang bang in the future after 0 bang qmark after 0 -bang qmark in future after 0 -typed bang qmark in future after 0 +typed bang bang in the future after 0 diff --git a/test/files/jvm/actmig-public-methods.scala b/test/files/jvm/actmig-public-methods.scala new file mode 100644 index 0000000000..58d7a1a9d4 --- /dev/null +++ b/test/files/jvm/actmig-public-methods.scala @@ -0,0 +1,74 @@ +/** + * NOTE: Code snippets from this test are included in the Actor Migration Guide. In case you change + * code in these tests prior to the 2.10.0 release please send the notification to @vjovanov. + */ +import scala.collection.mutable.ArrayBuffer +import scala.actors.Actor._ +import scala.actors._ +import scala.actors.migration.MigrationSystem +import scala.util.continuations._ +import java.util.concurrent.{ TimeUnit, CountDownLatch } + +object Test { + val NUMBER_OF_TESTS = 6 + + // used for sorting non-deterministic output + val buff = ArrayBuffer[String]() + val latch = new CountDownLatch(NUMBER_OF_TESTS) + val toStop = ArrayBuffer[Actor]() + + def append(v: String) = synchronized { + buff += v + } + + def main(args: Array[String]) = { + + val respActor = actor { + loop { + react { + case (x: String, time: Long) => + Thread.sleep(time) + reply(x + " after " + time) + case str: String => + append(str) + latch.countDown() + case _ => exit() + } + } + } + + toStop += respActor + + respActor ! ("bang") + + val res1 = respActor !? (("bang qmark", 0L)) + append(res1.toString) + latch.countDown() + + val res2 = respActor !? (5000, ("bang qmark", 1L)) + append(res2.toString) + latch.countDown() + + // this one should timeout + val res21 = respActor !? (1, ("bang qmark", 5000L)) + append(res21.toString) + latch.countDown() + + val fut1 = respActor !! (("bang bang in the future", 0L)) + append(fut1().toString()) + latch.countDown() + + val fut2 = respActor !! (("typed bang bang in the future", 0L), { case x: String => x }) + append(fut2()) + latch.countDown() + + // output + latch.await(10, TimeUnit.SECONDS) + if (latch.getCount() > 0) { + println("Error: Tasks have not finished!!!") + } + + buff.sorted.foreach(println) + toStop.foreach(_ ! 'stop) + } +}
\ No newline at end of file diff --git a/test/files/jvm/actmig-public-methods_1.check b/test/files/jvm/actmig-public-methods_1.check index bb6530c926..c861c90e63 100644 --- a/test/files/jvm/actmig-public-methods_1.check +++ b/test/files/jvm/actmig-public-methods_1.check @@ -1,6 +1,6 @@ None Some(bang qmark after 1) bang +bang bang in the future after 0 bang qmark after 0 -bang qmark in future after 0 -typed bang qmark in future after 0 +typed bang bang in the future after 0 diff --git a/test/files/jvm/actmig-public-methods_1.scala b/test/files/jvm/actmig-public-methods_1.scala index 4bbdc9a71f..15516a5d51 100644 --- a/test/files/jvm/actmig-public-methods_1.scala +++ b/test/files/jvm/actmig-public-methods_1.scala @@ -1,10 +1,18 @@ +/** + * NOTE: Code snippets from this test are included in the Actor Migration Guide. In case you change + * code in these tests prior to the 2.10.0 release please send the notification to @vjovanov. + */ import scala.collection.mutable.ArrayBuffer import scala.actors.Actor._ import scala.actors._ +import scala.actors.migration._ import scala.util._ +import scala.concurrent._ +import scala.concurrent.duration._ import java.util.concurrent.{ TimeUnit, CountDownLatch } -import scala.concurrent.duration.Duration -import scala.actors.pattern._ +import scala.concurrent.duration._ +import scala.actors.migration.pattern._ +import scala.concurrent.ExecutionContext.Implicits.global object Test { val NUMBER_OF_TESTS = 6 @@ -39,45 +47,53 @@ object Test { respActor ! "bang" - implicit val timeout = Timeout(Duration(500, TimeUnit.MILLISECONDS)) - val msg = ("bang qmark", 0L) - val res1 = respActor.?(msg)(Timeout(Duration.Inf)) - append(res1().toString) - latch.countDown() - - val msg1 = ("bang qmark", 1L) - val res2 = respActor.?(msg1)(Timeout(Duration(500, TimeUnit.MILLISECONDS))) - append((res2() match { - case x: AskTimeoutException => None - case v => Some(v) - }).toString) - latch.countDown() - - // this one should time out - val msg11 = ("bang qmark", 500L) - val res21 = respActor.?(msg11)(Timeout(Duration(1, TimeUnit.MILLISECONDS))) - append((res21() match { - case x: AskTimeoutException => None - case v => Some(v) - }).toString) - latch.countDown() - - val msg2 = ("bang qmark in future", 0L) - val fut1 = respActor.?(msg2)(Duration.Inf) - append(fut1().toString()) - latch.countDown() - - val handler: PartialFunction[Any, String] = { - case x: String => x.toString + { + val msg = ("bang qmark", 0L) + val res = respActor.?(msg)(Timeout(Duration.Inf)) + append(Await.result(res, Duration.Inf).toString) + latch.countDown() } - val msg3 = ("typed bang qmark in future", 0L) - val fut2 = (respActor.?(msg3)(Duration.Inf)) - append(Futures.future { handler.apply(fut2()) }().toString) - latch.countDown() + { + val msg = ("bang qmark", 1L) + val res = respActor.?(msg)(Timeout(5 seconds)) + + val promise = Promise[Option[Any]]() + res.onComplete(v => promise.success(v.toOption)) + append(Await.result(promise.future, Duration.Inf).toString) + + latch.countDown() + } + + { + val msg = ("bang qmark", 5000L) + val res = respActor.?(msg)(Timeout(1 millisecond)) + val promise = Promise[Option[Any]]() + res.onComplete(v => promise.success(v.toOption)) + append(Await.result(promise.future, Duration.Inf).toString) + latch.countDown() + } + + { + val msg = ("bang bang in the future", 0L) + val fut = respActor.?(msg)(Timeout(Duration.Inf)) + append(Await.result(fut, Duration.Inf).toString) + latch.countDown() + } + + { + val handler: PartialFunction[Any, String] = { + case x: String => x + } + + val msg = ("typed bang bang in the future", 0L) + val fut = (respActor.?(msg)(Timeout(Duration.Inf))) + append((Await.result(fut.map(handler), Duration.Inf)).toString) + latch.countDown() + } // output - latch.await(200, TimeUnit.MILLISECONDS) + latch.await(10, TimeUnit.SECONDS) if (latch.getCount() > 0) { println("Error: Tasks have not finished!!!") } diff --git a/test/files/jvm/actmig-react-receive.scala b/test/files/jvm/actmig-react-receive.scala index 280582511f..6adeac8b52 100644 --- a/test/files/jvm/actmig-react-receive.scala +++ b/test/files/jvm/actmig-react-receive.scala @@ -1,6 +1,11 @@ -import scala.actors.MigrationSystem._ +/** + * NOTE: Code snippets from this test are included in the Actor Migration Guide. In case you change + * code in these tests prior to the 2.10.0 release please send the notification to @vjovanov. + */ +import scala.actors.migration.MigrationSystem._ import scala.actors.Actor._ -import scala.actors.{ Actor, StashingActor, ActorRef, Props, MigrationSystem, PoisonPill } +import scala.actors._ +import scala.actors.migration._ import java.util.concurrent.{ TimeUnit, CountDownLatch } import scala.collection.mutable.ArrayBuffer import scala.concurrent.duration._ diff --git a/test/files/jvm/actmig-react-within.check b/test/files/jvm/actmig-react-within.check new file mode 100644 index 0000000000..57798dbefb --- /dev/null +++ b/test/files/jvm/actmig-react-within.check @@ -0,0 +1,2 @@ +received +received diff --git a/test/files/jvm/actmig-react-within.scala b/test/files/jvm/actmig-react-within.scala new file mode 100644 index 0000000000..43350ef120 --- /dev/null +++ b/test/files/jvm/actmig-react-within.scala @@ -0,0 +1,48 @@ +/** + * NOTE: Code snippets from this test are included in the Actor Migration Guide. In case you change + * code in these tests prior to the 2.10.0 release please send the notification to @vjovanov. + */ +import scala.actors.migration.MigrationSystem._ +import scala.actors.Actor._ +import scala.actors._ +import scala.actors.migration._ +import java.util.concurrent.{ TimeUnit, CountDownLatch } +import scala.collection.mutable.ArrayBuffer +import scala.concurrent.duration._ +import scala.concurrent.{ Promise, Await } + +object Test { + val finished = Promise[Boolean] + + def testReactWithin() = { + val sActor = actor { + loop { + reactWithin(1) { + case scala.actors.TIMEOUT => + println("received") + exit() + case _ => + println("Should not occur.") + } + } + } + + val myActor = MigrationSystem.actorOf(Props(() => new StashingActor { + context.setReceiveTimeout(1 millisecond) + def receive = { + case ReceiveTimeout => + println("received") + finished.success(true) + context.stop(self) + case _ => + println("Should not occur.") + } + }, "default-stashing-dispatcher")) + } + + def main(args: Array[String]) = { + testReactWithin() + Await.ready(finished.future, 5 seconds) + } + +} diff --git a/test/files/jvm/actmig-receive.check b/test/files/jvm/actmig-receive.check new file mode 100644 index 0000000000..30886140e1 --- /dev/null +++ b/test/files/jvm/actmig-receive.check @@ -0,0 +1,27 @@ +Original +do before +receive 1 +do in between +receive 1 +do after +Transformed +do before +receive 1 +do in between +receive 1 +do after +Test Loop Receive +Original +do before body +receive 1 +do after receive +do before body +do after receive +after loop +Transformed +do before body +receive 1 +do after receive +do before body +do after receive +after loop diff --git a/test/files/jvm/actmig-receive.scala b/test/files/jvm/actmig-receive.scala new file mode 100644 index 0000000000..03dc1be63b --- /dev/null +++ b/test/files/jvm/actmig-receive.scala @@ -0,0 +1,120 @@ +/** + * NOTE: Code snippets from this test are included in the Actor Migration Guide. In case you change + * code in these tests prior to the 2.10.0 release please send the notification to @vjovanov. + */ +import scala.actors.migration.MigrationSystem._ +import scala.actors.Actor._ +import scala.actors._ +import scala.actors.migration._ +import java.util.concurrent.{ TimeUnit, CountDownLatch } +import scala.collection.mutable.ArrayBuffer +import scala.concurrent.duration._ +import scala.concurrent.{ Promise, Await } + +object Test { + val finishedSingle, finishedSingle1, finishedLoop, finishedLoop1 = Promise[Boolean] + + def testDoubleReceive() = { + println("Original") + // Snippet that shows how to get rid of receive calls in Scala Actors. + // This snippet is used in the Actors Migration Kit. + val myActor = actor { + println("do before") + receive { + case "hello" => + println("receive 1") + } + println("do in between") + receive { + case "hello" => + println("receive 1") + } + println("do after") + finishedSingle.success(true) + } + + myActor ! "hello" + myActor ! "hello" + + Await.ready(finishedSingle.future, 5 seconds) + println("Transformed") + val myActorReact = actor { + println("do before") + react (({ + case "hello" => + println("receive 1") + }: PartialFunction[Any, Unit]).andThen { x => + println("do in between") + react (({ + case "hello" => + println("receive 1") + }: PartialFunction[Any, Unit]).andThen { x => + println("do after") + finishedSingle1.success(true) + }) + }) + } + + myActorReact ! "hello" + myActorReact ! "hello" + + Await.ready(finishedSingle1.future, 5 seconds) + } + + def testLoopReceive() = { + println("Test Loop Receive") + // Snippet that shows how to get rid of receive calls in loops. + // This snippet is used in the Actors Migration Kit. + println("Original") + val myActor = actor { + var c = true + while (c) { + println("do before body") + receive { + case "hello" => + println("receive 1") + case "exit" => + c = false + } + println("do after receive") + } + println("after loop") + finishedLoop.success(true) + } + + myActor ! "hello" + myActor ! "exit" + Await.ready(finishedLoop.future, 5 seconds) + println("Transformed") + + val myActorReact = actor { + var c = true + loopWhile(c) { + println("do before body") + react (({ + case "hello" => + println("receive 1") + case "exit" => + c = false + }: PartialFunction[Any, Unit]).andThen { x => + println("do after receive") + if (c == false) { + println("after loop") + finishedLoop1.success(true) + } + }) + } + } + + myActorReact ! "hello" + myActorReact ! "exit" + + Await.ready(finishedLoop1.future, 5 seconds) + } + + def main(args: Array[String]) = { + testDoubleReceive() + testLoopReceive() + } + +} diff --git a/test/files/run/existentials3-new.check b/test/files/run/existentials3-new.check index bb6fe1a5e3..00614b19db 100644 --- a/test/files/run/existentials3-new.check +++ b/test/files/run/existentials3-new.check @@ -3,8 +3,8 @@ Bar, t=TypeRef, s=type Bar Test.ToS, t=RefinedType, s=f3 Test.ToS, t=RefinedType, s=f4 Test.ToS, t=RefinedType, s=f5 -() => Test.ToS, t=TypeRef, s=class Function0 -() => Test.ToS, t=TypeRef, s=class Function0 +() => Test.ToS, t=TypeRef, s=trait Function0 +() => Test.ToS, t=TypeRef, s=trait Function0 $anon, t=TypeRef, s=type $anon $anon, t=TypeRef, s=type $anon List[java.lang.Object{type T1}#T1], t=TypeRef, s=class List @@ -15,8 +15,8 @@ Bar, t=TypeRef, s=type Bar Test.ToS, t=RefinedType, s=g3 Test.ToS, t=RefinedType, s=g4 Test.ToS, t=RefinedType, s=g5 -() => Test.ToS, t=TypeRef, s=class Function0 -() => Test.ToS, t=TypeRef, s=class Function0 +() => Test.ToS, t=TypeRef, s=trait Function0 +() => Test.ToS, t=TypeRef, s=trait Function0 $anon, t=TypeRef, s=type $anon $anon, t=TypeRef, s=type $anon List[java.lang.Object{type T1}#T1], t=TypeRef, s=class List diff --git a/test/files/run/macro-openmacros/Impls_Macros_1.scala b/test/files/run/macro-openmacros/Impls_Macros_1.scala index 38d46c5185..b863ac048b 100644 --- a/test/files/run/macro-openmacros/Impls_Macros_1.scala +++ b/test/files/run/macro-openmacros/Impls_Macros_1.scala @@ -4,8 +4,7 @@ object Macros { def impl(c: Context): c.Expr[Unit] = { // we're macros, so we can reflect against our source path // so we don't need any partests to clean up after us! - val c.CompilationUnit(file, _, _) = c.enclosingUnit - val dir = file.getCanonicalFile.getParentFile + val dir = c.enclosingUnit.source.file.file.getCanonicalFile.getParentFile def normalizePaths(s: String) = { val base = (dir.getCanonicalPath + java.io.File.separator).replace('\\', '/') var regex = """\Q%s\E""" format base diff --git a/test/files/run/macro-reify-nested-a/Impls_Macros_1.scala b/test/files/run/macro-reify-nested-a/Impls_Macros_1.scala index ae2def2d3e..b4351c2c53 100644 --- a/test/files/run/macro-reify-nested-a/Impls_Macros_1.scala +++ b/test/files/run/macro-reify-nested-a/Impls_Macros_1.scala @@ -23,9 +23,10 @@ case class Utils[C <: Context]( c:C ) { object QueryableMacros{ def _helper[C <: Context,S:c.WeakTypeTag]( c:C )( name:String, projection:c.Expr[_] ) = { import c.universe._ + import treeBuild._ val element_type = implicitly[c.WeakTypeTag[S]].tpe val foo = c.Expr[ru.Expr[Queryable[S]]]( - c.reifyTree( c.runtimeUniverse, EmptyTree, c.typeCheck( + c.reifyTree( mkRuntimeUniverseRef, EmptyTree, c.typeCheck( Utils[c.type](c).removeDoubleReify( Apply(Select(c.prefix.tree, newTermName( name )), List( projection.tree )) ).asInstanceOf[Tree] diff --git a/test/files/run/macro-reify-nested-b/Impls_Macros_1.scala b/test/files/run/macro-reify-nested-b/Impls_Macros_1.scala index ae2def2d3e..b4351c2c53 100644 --- a/test/files/run/macro-reify-nested-b/Impls_Macros_1.scala +++ b/test/files/run/macro-reify-nested-b/Impls_Macros_1.scala @@ -23,9 +23,10 @@ case class Utils[C <: Context]( c:C ) { object QueryableMacros{ def _helper[C <: Context,S:c.WeakTypeTag]( c:C )( name:String, projection:c.Expr[_] ) = { import c.universe._ + import treeBuild._ val element_type = implicitly[c.WeakTypeTag[S]].tpe val foo = c.Expr[ru.Expr[Queryable[S]]]( - c.reifyTree( c.runtimeUniverse, EmptyTree, c.typeCheck( + c.reifyTree( mkRuntimeUniverseRef, EmptyTree, c.typeCheck( Utils[c.type](c).removeDoubleReify( Apply(Select(c.prefix.tree, newTermName( name )), List( projection.tree )) ).asInstanceOf[Tree] diff --git a/test/files/run/macro-reify-splice-outside-reify/Impls_Macros_1.scala b/test/files/run/macro-reify-splice-outside-reify/Impls_Macros_1.scala index b23a5c70e1..5330d0e32b 100644 --- a/test/files/run/macro-reify-splice-outside-reify/Impls_Macros_1.scala +++ b/test/files/run/macro-reify-splice-outside-reify/Impls_Macros_1.scala @@ -4,18 +4,7 @@ object Impls { def foo(c: Ctx)(x: c.Expr[Int]) = { val x1 = c.Expr[Int](c.resetAllAttrs(x.tree)) // was: c.literal(x1.splice) - c.literal(eval(c)(x1)) - } - - private def eval[T](c: Ctx)(x: c.Expr[T]): T = { - import scala.reflect.runtime.{universe => ru} - val mirror = ru.runtimeMirror(c.libraryClassLoader) - import scala.tools.reflect.ToolBox - val toolBox = mirror.mkToolBox() - val importer = ru.mkImporter(c.universe).asInstanceOf[ru.Importer { val from: c.universe.type }] - val tree = c.resetAllAttrs(x.tree.duplicate) - val imported = importer.importTree(tree) - toolBox.eval(imported).asInstanceOf[T] + c.literal(c.eval(x1)) } } diff --git a/test/files/run/macro-reify-unreify/Macros_1.scala b/test/files/run/macro-reify-unreify/Macros_1.scala index 620a929210..9f04c13014 100644 --- a/test/files/run/macro-reify-unreify/Macros_1.scala +++ b/test/files/run/macro-reify-unreify/Macros_1.scala @@ -6,9 +6,10 @@ object Macros { object Impls { def foo(c: Ctx)(s: c.Expr[String]) = { import c.universe._ + import treeBuild._ - val world = c.reifyTree(c.runtimeUniverse, EmptyTree, s.tree) - val greeting = c.reifyTree(c.runtimeUniverse, EmptyTree, c.typeCheck(Apply(Select(Literal(Constant("hello ")), newTermName("$plus")), List(c.unreifyTree(world))))) + val world = c.reifyTree(mkRuntimeUniverseRef, EmptyTree, s.tree) + val greeting = c.reifyTree(mkRuntimeUniverseRef, EmptyTree, c.typeCheck(Apply(Select(Literal(Constant("hello ")), newTermName("$plus")), List(c.unreifyTree(world))))) val typedGreeting = c.Expr[String](greeting) c.universe.reify { diff --git a/test/files/run/macro-sip19-revised/Impls_Macros_1.scala b/test/files/run/macro-sip19-revised/Impls_Macros_1.scala index 0793696fd4..5f3f61ca3f 100644 --- a/test/files/run/macro-sip19-revised/Impls_Macros_1.scala +++ b/test/files/run/macro-sip19-revised/Impls_Macros_1.scala @@ -8,7 +8,7 @@ object Macros { val outer = c.Expr[SourceLocation](if (!inscope.isEmpty) inscope else Literal(Constant(null))) val Apply(fun, args) = c.enclosingImplicits(0)._2 - val fileName = fun.pos.fileInfo.getName + val fileName = fun.pos.source.file.file.getName val line = fun.pos.line val charOffset = fun.pos.point c.universe.reify { SourceLocation1(outer.splice, c.literal(fileName).splice, c.literal(line).splice, c.literal(charOffset).splice) } diff --git a/test/files/run/macro-sip19/Impls_Macros_1.scala b/test/files/run/macro-sip19/Impls_Macros_1.scala index f89e51f560..535ec2ccf0 100644 --- a/test/files/run/macro-sip19/Impls_Macros_1.scala +++ b/test/files/run/macro-sip19/Impls_Macros_1.scala @@ -4,7 +4,7 @@ object Macros { def impl(c: Context) = { import c.universe._ val Apply(fun, args) = c.enclosingImplicits(0)._2 - val fileName = fun.pos.fileInfo.getName + val fileName = fun.pos.source.file.file.getName val line = fun.pos.line val charOffset = fun.pos.point c.universe.reify { SourceLocation(c.literal(fileName).splice, c.literal(line).splice, c.literal(charOffset).splice) } diff --git a/test/files/run/macro-typecheck-macrosdisabled.check b/test/files/run/macro-typecheck-macrosdisabled.check index 719c6a2ef2..29a881f8b1 100644 --- a/test/files/run/macro-typecheck-macrosdisabled.check +++ b/test/files/run/macro-typecheck-macrosdisabled.check @@ -7,7 +7,7 @@ $treecreator1.super.<init>(); () }; - def apply[U >: Nothing <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.MirrorOf[U]): U#Tree = { + def apply[U >: Nothing <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.Mirror[U]): U#Tree = { val $u: U = $m$untyped.universe; val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror]; $u.Literal.apply($u.Constant.apply(2)) @@ -20,7 +20,7 @@ $typecreator2.super.<init>(); () }; - def apply[U >: Nothing <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.MirrorOf[U]): U#Type = { + def apply[U >: Nothing <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.Mirror[U]): U#Type = { val $u: U = $m$untyped.universe; val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror]; $u.ConstantType.apply($u.Constant.apply(2)) diff --git a/test/files/run/macro-typecheck-macrosdisabled2.check b/test/files/run/macro-typecheck-macrosdisabled2.check index 1fd422083c..7bdd1d6a3a 100644 --- a/test/files/run/macro-typecheck-macrosdisabled2.check +++ b/test/files/run/macro-typecheck-macrosdisabled2.check @@ -7,7 +7,7 @@ $treecreator1.super.<init>(); () }; - def apply[U >: Nothing <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.MirrorOf[U]): U#Tree = { + def apply[U >: Nothing <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.Mirror[U]): U#Tree = { val $u: U = $m$untyped.universe; val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror]; $u.Apply.apply($u.Select.apply($u.Select.apply($u.build.Ident($m.staticPackage("scala")), $u.newTermName("Array")), $u.newTermName("apply")), scala.collection.immutable.List.apply[$u.Literal]($u.Literal.apply($u.Constant.apply(2)))) @@ -20,7 +20,7 @@ $typecreator2.super.<init>(); () }; - def apply[U >: Nothing <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.MirrorOf[U]): U#Type = { + def apply[U >: Nothing <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.Mirror[U]): U#Type = { val $u: U = $m$untyped.universe; val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror]; $u.TypeRef.apply($u.ThisType.apply($m.staticPackage("scala").asModule.moduleClass), $m.staticClass("scala.Array"), scala.collection.immutable.List.apply[$u.Type]($m.staticClass("scala.Int").asType.toTypeConstructor)) diff --git a/test/files/run/reflection-java-annotations.scala b/test/files/run/reflection-java-annotations.scala index 0b16c0d103..2e3fed48ce 100644 --- a/test/files/run/reflection-java-annotations.scala +++ b/test/files/run/reflection-java-annotations.scala @@ -2,6 +2,6 @@ object Test extends App { import scala.reflect.runtime.universe._ val sym = typeOf[JavaAnnottee].typeSymbol sym.typeSignature - sym.getAnnotations foreach (_.javaArgs) - println(sym.getAnnotations) + sym.annotations foreach (_.javaArgs) + println(sym.annotations) }
\ No newline at end of file diff --git a/test/files/run/reflection-magicsymbols-invoke.check b/test/files/run/reflection-magicsymbols-invoke.check index 520dc2bfbe..f5258efeb7 100644 --- a/test/files/run/reflection-magicsymbols-invoke.check +++ b/test/files/run/reflection-magicsymbols-invoke.check @@ -90,7 +90,7 @@ method $asInstanceOf: [T0]()T0 method $isInstanceOf: [T0]()Boolean method ==: (x$1: Any)Boolean method ==: (x$1: AnyRef)Boolean -method apply: (i: <?>)T +method apply: (i: Int)T method asInstanceOf: [T0]=> T0 method clone: ()Array[T] method eq: (x$1: AnyRef)Boolean @@ -105,7 +105,7 @@ method notify: ()Unit method notifyAll: ()Unit method synchronized: [T0](x$1: T0)T0 method toString: ()java.lang.String -method update: (i: <?>, x: <?>)Unit +method update: (i: Int, x: T)Unit method wait: ()Unit method wait: (x$1: Long)Unit method wait: (x$1: Long, x$2: Int)Unit diff --git a/test/files/run/reflection-mem-typecheck.scala b/test/files/run/reflection-mem-typecheck.scala new file mode 100644 index 0000000000..a312c2c893 --- /dev/null +++ b/test/files/run/reflection-mem-typecheck.scala @@ -0,0 +1,26 @@ +import scala.tools.partest.MemoryTest + +trait A { type T <: A } +trait B { type T <: B } + +object Test extends MemoryTest { + lazy val tb = { + import scala.reflect.runtime.universe._ + import scala.reflect.runtime.{currentMirror => cm} + import scala.tools.reflect.ToolBox + cm.mkToolBox() + } + + override def maxDelta = 10 + override def calcsPerIter = 8 + override def calc() { + var snippet = """ + trait A { type T <: A } + trait B { type T <: B } + def foo[T](x: List[T]) = x + foo(List(new A {}, new B {})) + """.trim + snippet = snippet + "\n" + (List.fill(50)(snippet.split("\n").last) mkString "\n") + tb.typeCheck(tb.parse(snippet)) + } +}
\ No newline at end of file diff --git a/test/files/run/reify_ann1a.scala b/test/files/run/reify_ann1a.scala index 88b4191195..c23048e463 100644 --- a/test/files/run/reify_ann1a.scala +++ b/test/files/run/reify_ann1a.scala @@ -21,7 +21,6 @@ object Test extends App { // test 2: import and typecheck val toolbox = cm.mkToolBox() val ttree = toolbox.typeCheck(tree) - ttree.foreach(sub => if (sub.hasSymbol) sub.symbol.typeSignature) println(ttree.toString) // test 3: import and compile diff --git a/test/files/run/reify_ann1b.scala b/test/files/run/reify_ann1b.scala index a8fb876023..29ce6021a2 100644 --- a/test/files/run/reify_ann1b.scala +++ b/test/files/run/reify_ann1b.scala @@ -21,7 +21,6 @@ object Test extends App { // test 2: import and typecheck val toolbox = cm.mkToolBox() val ttree = toolbox.typeCheck(tree) - ttree.foreach(sub => if (sub.hasSymbol) sub.symbol.typeSignature) println(ttree.toString) // test 3: import and compile diff --git a/test/files/run/reify_ann2a.scala b/test/files/run/reify_ann2a.scala index b7e5833584..53423e12c3 100644 --- a/test/files/run/reify_ann2a.scala +++ b/test/files/run/reify_ann2a.scala @@ -21,7 +21,6 @@ object Test extends App { // test 2: import and typecheck val toolbox = cm.mkToolBox() val ttree = toolbox.typeCheck(tree) - ttree.foreach(sub => if (sub.hasSymbol) sub.symbol.typeSignature) println(ttree.toString) // test 3: import and compile diff --git a/test/files/run/reify_ann3.scala b/test/files/run/reify_ann3.scala index 662d58aaf3..4162fa532f 100644 --- a/test/files/run/reify_ann3.scala +++ b/test/files/run/reify_ann3.scala @@ -15,7 +15,6 @@ object Test extends App { // test 2: import and typecheck val toolbox = cm.mkToolBox() val ttree = toolbox.typeCheck(tree) - ttree.foreach(sub => if (sub.hasSymbol) sub.symbol.typeSignature) println(ttree.toString) // test 3: import and compile diff --git a/test/files/run/reify_ann4.scala b/test/files/run/reify_ann4.scala index a85e5e3625..0aedb77b5e 100644 --- a/test/files/run/reify_ann4.scala +++ b/test/files/run/reify_ann4.scala @@ -19,7 +19,6 @@ object Test extends App { // test 2: import and typecheck val toolbox = cm.mkToolBox() val ttree = toolbox.typeCheck(tree) - ttree.foreach(sub => if (sub.hasSymbol) sub.symbol.typeSignature) println(ttree.toString) // test 3: import and compile diff --git a/test/files/run/reify_ann5.scala b/test/files/run/reify_ann5.scala index 877360180c..d27be3b6d5 100644 --- a/test/files/run/reify_ann5.scala +++ b/test/files/run/reify_ann5.scala @@ -16,7 +16,6 @@ object Test extends App { // test 2: import and typecheck val toolbox = cm.mkToolBox() val ttree = toolbox.typeCheck(tree) - ttree.foreach(sub => if (sub.hasSymbol) sub.symbol.typeSignature) println(ttree.toString) // test 3: import and compile diff --git a/test/files/run/t5423.scala b/test/files/run/t5423.scala index 9b8ba090fa..c1632126b2 100644 --- a/test/files/run/t5423.scala +++ b/test/files/run/t5423.scala @@ -7,5 +7,5 @@ final class table extends annotation.StaticAnnotation object Test extends App { val s = cm.classSymbol(classOf[A]) - println(s.getAnnotations) + println(s.annotations) }
\ No newline at end of file diff --git a/test/files/run/t6277.check b/test/files/run/t6277.check new file mode 100644 index 0000000000..f32a5804e2 --- /dev/null +++ b/test/files/run/t6277.check @@ -0,0 +1 @@ +true
\ No newline at end of file diff --git a/test/files/run/t6277.scala b/test/files/run/t6277.scala new file mode 100644 index 0000000000..41feee8a8a --- /dev/null +++ b/test/files/run/t6277.scala @@ -0,0 +1,9 @@ +import scala.reflect.runtime.universe._ + +object Test extends App { + locally { + val sym = typeOf[List[_]].typeSymbol.asClass + val q = sym.isSealed + println(q) + } +}
\ No newline at end of file diff --git a/test/files/run/t6410.check b/test/files/run/t6410.check new file mode 100644 index 0000000000..051fe4995a --- /dev/null +++ b/test/files/run/t6410.check @@ -0,0 +1,2 @@ +ParMap(0 -> 4, 1 -> 5) +ParMap(0 -> 4, 1 -> 5)
\ No newline at end of file diff --git a/test/files/run/t6410.scala b/test/files/run/t6410.scala new file mode 100644 index 0000000000..2a001b47ab --- /dev/null +++ b/test/files/run/t6410.scala @@ -0,0 +1,9 @@ + + + +object Test extends App { + val x = collection.parallel.mutable.ParArray.range(1,10) groupBy { _ % 2 } mapValues { _.size } + println(x) + val y = collection.parallel.immutable.ParVector.range(1,10) groupBy { _ % 2 } mapValues { _.size } + println(y) +}
\ No newline at end of file diff --git a/test/files/run/toolbox_console_reporter.check b/test/files/run/toolbox_console_reporter.check index e69de29bb2..1395c68740 100644 --- a/test/files/run/toolbox_console_reporter.check +++ b/test/files/run/toolbox_console_reporter.check @@ -0,0 +1,8 @@ +hello +============compiler console============= +warning: method foo in object Utils is deprecated: test + +========================================= +============compiler messages============ +Info(NoPosition,method foo in object Utils is deprecated: test,WARNING) +========================================= diff --git a/test/files/run/toolbox_console_reporter.scala b/test/files/run/toolbox_console_reporter.scala index a57dea38a8..d672ccb9cb 100644 --- a/test/files/run/toolbox_console_reporter.scala +++ b/test/files/run/toolbox_console_reporter.scala @@ -1,16 +1,29 @@ import scala.reflect.runtime.universe._ +import scala.reflect.runtime.{universe => ru} +import scala.reflect.runtime.{currentMirror => cm} +import scala.tools.reflect.{ToolBox, mkConsoleFrontEnd} object Test extends App { - // todo. cannot test this unfortunately, because ConsoleFrontEnd grabs Console.out too early - // todo. and isn't affected by Console.setOut employed by partest to intercept output + val oldErr = Console.err; + val baos = new java.io.ByteArrayOutputStream(); + Console.setErr(new java.io.PrintStream(baos)); + try { + val toolbox = cm.mkToolBox(frontEnd = mkConsoleFrontEnd(), options = "-deprecation") + toolbox.eval(reify{ + object Utils { + @deprecated("test", "2.10.0") + def foo { println("hello") } + } - //val toolbox = mkToolBox(frontEnd = mkConsoleFrontEnd(), options = "-deprecation") - //toolbox.eval(reify{ - // object Utils { - // @deprecated("test", "2.10.0") - // def foo { println("hello") } - // } - // - // Utils.foo - //}) + Utils.foo + }.tree) + println("============compiler console=============") + println(baos.toString); + println("=========================================") + println("============compiler messages============") + toolbox.frontEnd.infos.foreach(println(_)) + println("=========================================") + } finally { + Console.setErr(oldErr); + } }
\ No newline at end of file diff --git a/test/files/run/toolbox_silent_reporter.scala b/test/files/run/toolbox_silent_reporter.scala index 15f559d605..03b1d6defa 100644 --- a/test/files/run/toolbox_silent_reporter.scala +++ b/test/files/run/toolbox_silent_reporter.scala @@ -1,10 +1,10 @@ import scala.reflect.runtime.universe._ import scala.reflect.runtime.{universe => ru} import scala.reflect.runtime.{currentMirror => cm} -import scala.tools.reflect.ToolBox +import scala.tools.reflect.{ToolBox, mkSilentFrontEnd} object Test extends App { - val toolbox = cm.mkToolBox(options = "-deprecation") + val toolbox = cm.mkToolBox(options = "-deprecation", frontEnd = mkSilentFrontEnd()) toolbox.eval(reify{ object Utils { @deprecated("test", "2.10.0") diff --git a/test/files/run/toolbox_typecheck_macrosdisabled.check b/test/files/run/toolbox_typecheck_macrosdisabled.check index 9e997dafed..688f37927c 100644 --- a/test/files/run/toolbox_typecheck_macrosdisabled.check +++ b/test/files/run/toolbox_typecheck_macrosdisabled.check @@ -16,7 +16,7 @@ $treecreator1.super.<init>(); () }; - def apply[U <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.MirrorOf[U]): U#Tree = { + def apply[U <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.Mirror[U]): U#Tree = { val $u: U = $m$untyped.universe; val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror]; $u.Literal.apply($u.Constant.apply(2)) @@ -29,7 +29,7 @@ $typecreator2.super.<init>(); () }; - def apply[U <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.MirrorOf[U]): U#Type = { + def apply[U <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.Mirror[U]): U#Type = { val $u: U = $m$untyped.universe; val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror]; $u.ConstantType.apply($u.Constant.apply(2)) diff --git a/test/files/run/toolbox_typecheck_macrosdisabled2.check b/test/files/run/toolbox_typecheck_macrosdisabled2.check index 16c8d6c397..f5c9b6eeab 100644 --- a/test/files/run/toolbox_typecheck_macrosdisabled2.check +++ b/test/files/run/toolbox_typecheck_macrosdisabled2.check @@ -16,7 +16,7 @@ $treecreator1.super.<init>(); () }; - def apply[U <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.MirrorOf[U]): U#Tree = { + def apply[U <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.Mirror[U]): U#Tree = { val $u: U = $m$untyped.universe; val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror]; $u.Apply.apply($u.Select.apply($u.Select.apply($u.build.Ident($m.staticPackage("scala")), $u.newTermName("Array")), $u.newTermName("apply")), scala.collection.immutable.List.apply[$u.Literal]($u.Literal.apply($u.Constant.apply(2)))) @@ -29,7 +29,7 @@ $typecreator2.super.<init>(); () }; - def apply[U <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.MirrorOf[U]): U#Type = { + def apply[U <: scala.reflect.api.Universe with Singleton]($m$untyped: scala.reflect.api.Mirror[U]): U#Type = { val $u: U = $m$untyped.universe; val $m: $u.Mirror = $m$untyped.asInstanceOf[$u.Mirror]; $u.TypeRef.apply($u.ThisType.apply($m.staticPackage("scala").asModule.moduleClass), $m.staticClass("scala.Array"), scala.collection.immutable.List.apply[$u.Type]($m.staticClass("scala.Int").asType.toTypeConstructor)) diff --git a/test/files/run/typetags_without_scala_reflect_manifest_lookup.scala b/test/files/run/typetags_without_scala_reflect_manifest_lookup.scala index 37047e7884..6fd3d2dc2b 100644 --- a/test/files/run/typetags_without_scala_reflect_manifest_lookup.scala +++ b/test/files/run/typetags_without_scala_reflect_manifest_lookup.scala @@ -2,7 +2,7 @@ import scala.tools.partest._ import scala.tools.nsc.Settings object Test extends DirectTest { - override def extraSettings = "-cp " + sys.props("partest.lib") + override def extraSettings = "-cp " + sys.props("partest.lib") + " -d \"" + testOutput.path + "\"" def code = """ object Test extends App { diff --git a/test/osgi/src/BasicLibrary.scala b/test/osgi/src/BasicLibrary.scala index 38dea69e99..6618f02102 100644 --- a/test/osgi/src/BasicLibrary.scala +++ b/test/osgi/src/BasicLibrary.scala @@ -29,7 +29,7 @@ class BasicLibraryTest extends ScalaOsgiHelper { def everythingLoads(): Unit = { // Note - This tests sun.misc usage. import scala.concurrent._ - import scala.concurrent.util.Duration.Inf + import scala.concurrent.duration.Duration.Inf import ExecutionContext.Implicits._ val x = Future(2) map (_ + 1) assertEquals(3, Await.result(x, Inf)) diff --git a/test/pending/run/reflection-mem-eval.scala b/test/pending/run/reflection-mem-eval.scala new file mode 100644 index 0000000000..9045c44cd6 --- /dev/null +++ b/test/pending/run/reflection-mem-eval.scala @@ -0,0 +1,26 @@ +import scala.tools.partest.MemoryTest + +trait A { type T <: A } +trait B { type T <: B } + +object Test extends MemoryTest { + lazy val tb = { + import scala.reflect.runtime.universe._ + import scala.reflect.runtime.{currentMirror => cm} + import scala.tools.reflect.ToolBox + cm.mkToolBox() + } + + override def maxDelta = 10 + override def calcsPerIter = 3 + override def calc() { + var snippet = """ + trait A { type T <: A } + trait B { type T <: B } + def foo[T](x: List[T]) = x + foo(List(new A {}, new B {})) + """.trim + snippet = snippet + "\n" + (List.fill(50)(snippet.split("\n").last) mkString "\n") + tb.eval(tb.parse(snippet)) + } +}
\ No newline at end of file diff --git a/test/scaladoc/resources/links.scala b/test/scaladoc/resources/links.scala index 679d0b0dce..09a52a4334 100644 --- a/test/scaladoc/resources/links.scala +++ b/test/scaladoc/resources/links.scala @@ -34,24 +34,29 @@ package scala.test.scaladoc.links { /** * Links to the trait: - * - [[scala.test.scaladoc.links.Target!.T trait Target -> type T]] - * - [[test.scaladoc.links.Target!.S trait Target -> type S]] - * - [[scaladoc.links.Target!.foo(Int)* trait Target -> def foo]] - * - [[links.Target!.bar trait Target -> def bar]] - * - [[[[Target!.foo[A[_[_]]]* trait Target -> def foo with 3 nested tparams]]]] (should exercise nested parens) - * - [[Target$.T object Target -> type T]] - * - [[Target$.S object Target -> type S]] - * - [[Target$.foo(Str* object Target -> def foo]] - * - [[Target$.bar object Target -> def bar]] - * - [[[[Target$.foo[A[_[_]]]* trait Target -> def foo with 3 nested tparams]]]] (should exercise nested parens) - * - [[Target.onlyInObject object Target -> def foo]] (should find the object) - * - [[Target$.C object Target -> class C]] (should link directly to C, not as a member) - * - [[Target!.C trait Target -> class C]] (should link directly to C, not as a member) - * - [[Target$.baz(links\.C)* object Target -> def baz]] (should use dots in prefix) - * - [[Target!.baz(links\.C)* trait Target -> def baz]] (should use dots in prefix) - * - [[localMethod object TEST -> localMethod]] (should use the current template to resolve link instead of inTpl, that's the package) + * - [[scala.test.scaladoc.links.Target$ object Test]] + * - [[scala.test package scala.test]] + * - [[scala.test.scaladoc.links.Target!.T trait Target -> type T]] + * - [[test.scaladoc.links.Target!.S trait Target -> type S]] + * - [[scaladoc.links.Target!.foo(i:Int)* trait Target -> def foo]] + * - [[links.Target!.bar trait Target -> def bar]] + * - [[[[Target!.foo[A[_[_]]]* trait Target -> def foo with 3 nested tparams]]]] (should exercise nested parens) + * - [[Target$.T object Target -> type T]] + * - [[Target$.S object Target -> type S]] + * - [[Target$.foo(z:Str* object Target -> def foo]] + * - [[Target$.bar object Target -> def bar]] + * - [[[[Target$.foo[A[_[_]]]* trait Target -> def foo with 3 nested tparams]]]] (should exercise nested parens) + * - [[Target.onlyInObject object Target -> def foo]] (should find the object) + * - [[Target$.C object Target -> class C]] (should link directly to C, not as a member) + * - [[Target!.C trait Target -> class C]] (should link directly to C, not as a member) + * - [[Target$.baz(c:scala\.test\.scaladoc\.links\.C)* object Target -> def baz]] (should use dots in prefix) + * - [[Target!.baz(c:scala\.test\.scaladoc\.links\.C)* trait Target -> def baz]] (should use dots in prefix) + * - [[localMethod object TEST -> localMethod]] (should use the current template to resolve link instead of inTpl, that's the package) + * - [[#localMethod object TEST -> localMethod]] (should exercise Java-style links to empty members) + * - [[ImOutside class ImOutside (check correct lookup in EmptyPackage)]] */ object TEST { def localMethod = 3 } } +class ImOutside
\ No newline at end of file diff --git a/test/scaladoc/run/links.scala b/test/scaladoc/run/links.scala index 40ce6368ce..de359539cf 100644 --- a/test/scaladoc/run/links.scala +++ b/test/scaladoc/run/links.scala @@ -22,7 +22,7 @@ object Test extends ScaladocModelTest { val memberLinks = countLinks(TEST.comment.get, _.link.isInstanceOf[LinkToMember]) val templateLinks = countLinks(TEST.comment.get, _.link.isInstanceOf[LinkToTpl]) - assert(memberLinks == 14, memberLinks + " == 14 (the member links in object TEST)") - assert(templateLinks == 2, templateLinks + " == 2 (the template links in object TEST)") + assert(memberLinks == 15, memberLinks + " == 15 (the member links in object TEST)") + assert(templateLinks == 5, templateLinks + " == 5 (the template links in object TEST)") } }
\ No newline at end of file |