10 files changed, 587 insertions, 0 deletions
diff --git a/src/test/scala/scala/async/MinimalScalaTest.scala b/src/test/scala/scala/async/MinimalScalaTest.scala
new file mode 100644
index 0000000..af5b04e
--- /dev/null
+++ b/src/test/scala/scala/async/MinimalScalaTest.scala
@@ -0,0 +1,79 @@
+package scala.async
+
+import language.reflectiveCalls
+import language.postfixOps
+import language.implicitConversions
+
+import scala.reflect.{ClassTag, classTag}
+
+import scala.collection.mutable
+import scala.concurrent.{Future, Awaitable, CanAwait}
+import java.util.concurrent.{TimeoutException, CountDownLatch, TimeUnit}
+import scala.concurrent.duration.Duration
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+
+trait Output {
+  val buffer = new StringBuilder
+
+  def bufferPrintln(a: Any): Unit = buffer.synchronized {
+    buffer.append(a.toString + "\n")
+  }
+}
+
+trait MinimalScalaTest extends Output {
+  implicit class objectops(obj: Any) {
+    def mustBe(other: Any) = assert(obj == other, obj + " is not " + other)
+
+    def mustEqual(other: Any) = mustBe(other)
+  }
+
+  implicit class stringops(text: String) {
+    def mustContain(substring: String) = assert(text contains substring, text)
+  }
+
+  def intercept[T <: Throwable : ClassTag](body: => Any): T = {
+    try {
+      body
+      throw new Exception(s"Exception of type ${classTag[T]} was not thrown")
+    } catch {
+      case t: Throwable =>
+        if (classTag[T].runtimeClass != t.getClass) throw t
+        else t.asInstanceOf[T]
+    }
+  }
+}
+
+
+object TestLatch {
+  val DefaultTimeout = Duration(5, TimeUnit.SECONDS)
+
+  def apply(count: Int = 1) = new TestLatch(count)
+}
+
+
+class TestLatch(count: Int = 1) extends Awaitable[Unit] {
+  private var latch = new CountDownLatch(count)
+
+  def countDown() = latch.countDown()
+
+  def isOpen: Boolean = latch.getCount == 0
+
+  def open() = while (!isOpen) countDown()
+
+  def reset() = latch = new CountDownLatch(count)
+
+  @throws(classOf[TimeoutException])
+  def ready(atMost: Duration)(implicit permit: CanAwait) = {
+    val opened = latch.await(atMost.toNanos, TimeUnit.NANOSECONDS)
+    if (!opened) throw new TimeoutException(s"Timeout of ${(atMost.toString)}.")
+    this
+  }
+
+  @throws(classOf[Exception])
+  def result(atMost: Duration)(implicit permit: CanAwait): Unit = {
+    ready(atMost)
+  }
+
+}
diff --git a/src/test/scala/scala/async/neg/SampleNegSpec.scala b/src/test/scala/scala/async/neg/SampleNegSpec.scala
new file mode 100644
index 0000000..8825f11
--- /dev/null
+++ b/src/test/scala/scala/async/neg/SampleNegSpec.scala
@@ -0,0 +1,25 @@
+package scala.async
+package neg
+
+import java.io.File
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.Test
+import tools.reflect.ToolBoxError
+
+@RunWith(classOf[JUnit4])
+class SampleNegSpec extends MinimalScalaTest {
+  val f = new File("/Users/jason/code/scala-async/test/files/run/await0")
+
+  @Test
+  def `missing symbol` {
+    intercept[ToolBoxError] {
+      eval {
+        """
+          | kaboom
+        """.stripMargin
+      }
+    }.getMessage mustContain "not found: value kaboom"
+
+  }
+}
diff --git a/src/test/scala/scala/async/neg/package.scala b/src/test/scala/scala/async/neg/package.scala
new file mode 100644
index 0000000..1326394
--- /dev/null
+++ b/src/test/scala/scala/async/neg/package.scala
@@ -0,0 +1,11 @@
+package scala.async
+
+package object neg {
+  def eval(code: String): Any = {
+    val m = scala.reflect.runtime.currentMirror
+    import scala.tools.reflect.ToolBox
+    val tb = m.mkToolBox()
+    val result = tb.eval(tb.parse(code))
+    result
+  }
+}
diff --git a/src/test/scala/scala/async/run/await0/await0.scala b/src/test/scala/scala/async/run/await0/await0.scala
new file mode 100644
index 0000000..77867aa
--- /dev/null
+++ b/src/test/scala/scala/async/run/await0/await0.scala
@@ -0,0 +1,78 @@
+package scala.async
+package run
+package await0
+
+/**
+ * Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+import language.{reflectiveCalls, postfixOps}
+
+import scala.concurrent.{Future, ExecutionContext, future, Await}
+import scala.concurrent.duration._
+import scala.async.Async.{async, await}
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.Test
+
+class Await0Class {
+
+  import ExecutionContext.Implicits.global
+
+  def m1(x: Double): Future[Double] = future {
+    Thread.sleep(200)
+    x + 2.0
+  }
+
+  def m2(x: Float): Future[Float] = future {
+    Thread.sleep(200)
+    x + 2.0f
+  }
+
+  def m3(x: Char): Future[Char] = future {
+    Thread.sleep(200)
+    (x.toInt + 2).toChar
+  }
+
+  def m4(x: Short): Future[Short] = future {
+    Thread.sleep(200)
+    (x + 2).toShort
+  }
+
+  def m5(x: Byte): Future[Byte] = future {
+    Thread.sleep(200)
+    (x + 2).toByte
+  }
+
+  def m0(y: Int): Future[Double] = async {
+    val f1 = m1(y.toDouble)
+    val x1: Double = await(f1)
+
+    val f2 = m2(y.toFloat)
+    val x2: Float = await(f2)
+
+    val f3 = m3(y.toChar)
+    val x3: Char = await(f3)
+
+    val f4 = m4(y.toShort)
+    val x4: Short = await(f4)
+
+    val f5 = m5(y.toByte)
+    val x5: Byte = await(f5)
+
+    x1 + x2 + 2.0
+  }
+}
+
+@RunWith(classOf[JUnit4])
+class Await0Spec extends MinimalScalaTest {
+
+  @Test
+  def `An async method support a simple await` {
+    val o = new Await0Class
+    val fut = o.m0(10)
+    val res = Await.result(fut, 10 seconds)
+    res mustBe (26.0)
+  }
+}
+
diff --git a/src/test/scala/scala/async/run/block0/AsyncSpec.scala b/src/test/scala/scala/async/run/block0/AsyncSpec.scala
new file mode 100644
index 0000000..de58bb1
--- /dev/null
+++ b/src/test/scala/scala/async/run/block0/AsyncSpec.scala
@@ -0,0 +1,61 @@
+/**
+ * Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.async
+package run
+package block0
+
+import language.{reflectiveCalls, postfixOps}
+import scala.concurrent.{Future, ExecutionContext, future, Await}
+import scala.concurrent.duration._
+import scala.async.Async.{async, await}
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+
+class Test1Class {
+
+  import ExecutionContext.Implicits.global
+
+  def m1(x: Int): Future[Int] = future {
+    Thread.sleep(1000)
+    x + 2
+  }
+
+  def m2(y: Int): Future[Int] = async {
+    val f = m1(y)
+    val x = await(f)
+    x + 2
+  }
+
+  def m3(y: Int): Future[Int] = async {
+    val f1 = m1(y)
+    val x1 = await(f1)
+    val f2 = m1(y + 2)
+    val x2 = await(f2)
+    x1 + x2
+  }
+}
+
+
+@RunWith(classOf[JUnit4])
+class AsyncSpec extends MinimalScalaTest {
+
+  @Test
+  def `simple await` {
+    val o = new Test1Class
+    val fut = o.m2(10)
+    val res = Await.result(fut, 2 seconds)
+    res mustBe (14)
+  }
+
+  @Test
+  def `several awaits in sequence` {
+    val o = new Test1Class
+    val fut = o.m3(10)
+    val res = Await.result(fut, 4 seconds)
+    res mustBe (26)
+  }
+}
diff --git a/src/test/scala/scala/async/run/block1/block1.scala b/src/test/scala/scala/async/run/block1/block1.scala
new file mode 100644
index 0000000..29890bb
--- /dev/null
+++ b/src/test/scala/scala/async/run/block1/block1.scala
@@ -0,0 +1,46 @@
+/**
+ * Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.async
+package run
+package block1
+
+import language.{reflectiveCalls, postfixOps}
+import scala.concurrent.{Future, ExecutionContext, future, Await}
+import scala.concurrent.duration._
+import scala.async.Async.{async, await}
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+
+class Test1Class {
+
+  import ExecutionContext.Implicits.global
+
+  def m1(x: Int): Future[Int] = future {
+    Thread.sleep(1000)
+    x + 2
+  }
+
+  def m4(y: Int): Future[Int] = async {
+    val f1 = m1(y)
+    val f2 = m1(y + 2)
+    val x1 = await(f1)
+    println("between two awaits")
+    val x2 = await(f2)
+    x1 + x2
+  }
+}
+
+@RunWith(classOf[JUnit4])
+class Block1Spec extends MinimalScalaTest {
+
+  @Test def `support a simple await` {
+    val o = new Test1Class
+    val fut = o.m4(10)
+    val res = Await.result(fut, 2 seconds)
+    res mustBe (26)
+  }
+}
diff --git a/src/test/scala/scala/async/run/ifelse0/IfElse0.scala b/src/test/scala/scala/async/run/ifelse0/IfElse0.scala
new file mode 100644
index 0000000..2088609
--- /dev/null
+++ b/src/test/scala/scala/async/run/ifelse0/IfElse0.scala
@@ -0,0 +1,51 @@
+/**
+ * Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.async
+package run
+package ifelse0
+
+import language.{reflectiveCalls, postfixOps}
+import scala.concurrent.{Future, ExecutionContext, future, Await}
+import scala.concurrent.duration._
+import scala.async.Async.{async, await}
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.Test
+
+
+class TestIfElseClass {
+
+  import ExecutionContext.Implicits.global
+
+  def m1(x: Int): Future[Int] = future {
+    Thread.sleep(1000)
+    x + 2
+  }
+
+  def m2(y: Int): Future[Int] = async {
+    val f = m1(y)
+    var z = 0
+    if (y > 0) {
+      val x1 = await(f)
+      z = x1 + 2
+    } else {
+      val x2 = await(f)
+      z = x2 - 2
+    }
+    z
+  }
+}
+
+
+@RunWith(classOf[JUnit4])
+class IfElseSpec extends MinimalScalaTest {
+
+  @Test def `support await in a simple if-else expression` {
+    val o = new TestIfElseClass
+    val fut = o.m2(10)
+    val res = Await.result(fut, 2 seconds)
+    res mustBe (14)
+  }
+}
diff --git a/src/test/scala/scala/async/run/ifelse1/IfElse1.scala b/src/test/scala/scala/async/run/ifelse1/IfElse1.scala
new file mode 100644
index 0000000..df528da
--- /dev/null
+++ b/src/test/scala/scala/async/run/ifelse1/IfElse1.scala
@@ -0,0 +1,131 @@
+/**
+ * Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.async
+package run
+package ifelse1
+
+import language.{reflectiveCalls, postfixOps}
+import scala.concurrent.{Future, ExecutionContext, future, Await}
+import scala.concurrent.duration._
+import scala.async.Async.{async, await}
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.Test
+
+
+class TestIfElse1Class {
+
+  import ExecutionContext.Implicits.global
+
+  def base(x: Int): Future[Int] = future {
+    Thread.sleep(1000)
+    x + 2
+  }
+
+  def m1(y: Int): Future[Int] = async {
+    val f = base(y)
+    var z = 0
+    if (y > 0) {
+      if (y > 100)
+        5
+      else {
+        val x1 = await(f)
+        z = x1 + 2
+      }
+    } else {
+      val x2 = await(f)
+      z = x2 - 2
+    }
+    z
+  }
+
+  def m2(y: Int): Future[Int] = async {
+    val f = base(y)
+    var z = 0
+    if (y > 0) {
+      if (y < 100) {
+        val x1 = await(f)
+        z = x1 + 2
+      }
+      else
+        5
+    } else {
+      val x2 = await(f)
+      z = x2 - 2
+    }
+    z
+  }
+
+  def m3(y: Int): Future[Int] = async {
+    val f = base(y)
+    var z = 0
+    if (y < 0) {
+      val x2 = await(f)
+      z = x2 - 2
+    } else {
+      if (y > 100)
+        5
+      else {
+        val x1 = await(f)
+        z = x1 + 2
+      }
+    }
+    z
+  }
+
+  def m4(y: Int): Future[Int] = async {
+    val f = base(y)
+    var z = 0
+    if (y < 0) {
+      val x2 = await(f)
+      z = x2 - 2
+    } else {
+      if (y < 100) {
+        val x1 = await(f)
+        z = x1 + 2
+      } else
+        5
+    }
+    z
+  }
+}
+
+@RunWith(classOf[JUnit4])
+class IfElse1Spec extends MinimalScalaTest {
+
+  @Test
+  def `await in a nested if-else expression` {
+    val o = new TestIfElse1Class
+    val fut = o.m1(10)
+    val res = Await.result(fut, 2 seconds)
+    res mustBe (14)
+  }
+
+  @Test
+  def `await in a nested if-else expression 2` {
+    val o = new TestIfElse1Class
+    val fut = o.m2(10)
+    val res = Await.result(fut, 2 seconds)
+    res mustBe (14)
+  }
+
+
+  @Test
+  def `await in a nested if-else expression 3` {
+    val o = new TestIfElse1Class
+    val fut = o.m3(10)
+    val res = Await.result(fut, 2 seconds)
+    res mustBe (14)
+  }
+
+
+  @Test
+  def `await in a nested if-else expression 4` {
+    val o = new TestIfElse1Class
+    val fut = o.m4(10)
+    val res = Await.result(fut, 2 seconds)
+    res mustBe (14)
+  }
+}
diff --git a/src/test/scala/scala/async/run/ifelse2/ifelse2.scala b/src/test/scala/scala/async/run/ifelse2/ifelse2.scala
new file mode 100644
index 0000000..d702d72
--- /dev/null
+++ b/src/test/scala/scala/async/run/ifelse2/ifelse2.scala
@@ -0,0 +1,51 @@
+/**
+ * Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.async
+package run
+package ifelse2
+
+import language.{reflectiveCalls, postfixOps}
+import scala.concurrent.{Future, ExecutionContext, future, Await}
+import scala.concurrent.duration._
+import scala.async.Async.{async, await}
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.Test
+
+
+class TestIfElse2Class {
+
+  import ExecutionContext.Implicits.global
+
+  def base(x: Int): Future[Int] = future {
+    Thread.sleep(1000)
+    x + 2
+  }
+
+  def m(y: Int): Future[Int] = async {
+    val f = base(y)
+    var z = 0
+    if (y > 0) {
+      val x = await(f)
+      z = x + 2
+    } else {
+      val x = await(f)
+      z = x - 2
+    }
+    z
+  }
+}
+
+@RunWith(classOf[JUnit4])
+class IfElse2Spec extends MinimalScalaTest {
+
+  @Test
+  def `variables of the same name in different blocks` {
+    val o = new TestIfElse2Class
+    val fut = o.m(10)
+    val res = Await.result(fut, 2 seconds)
+    res mustBe (14)
+  }
+}
diff --git a/src/test/scala/scala/async/run/ifelse3/IfElse3.scala b/src/test/scala/scala/async/run/ifelse3/IfElse3.scala
new file mode 100644
index 0000000..cac646a
--- /dev/null
+++ b/src/test/scala/scala/async/run/ifelse3/IfElse3.scala
@@ -0,0 +1,54 @@
+/**
+ * Copyright (C) 2012 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.async
+package run
+package ifelse3
+
+import language.{reflectiveCalls, postfixOps}
+import scala.concurrent.{Future, ExecutionContext, future, Await}
+import scala.concurrent.duration._
+import scala.async.Async.{async, await}
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.junit.Test
+
+
+class TestIfElse3Class {
+
+  import ExecutionContext.Implicits.global
+
+  def base(x: Int): Future[Int] = future {
+    Thread.sleep(1000)
+    x + 2
+  }
+
+  def m(y: Int): Future[Int] = async {
+    val f = base(y)
+    var z = 0
+    if (y > 0) {
+      val x1 = await(f)
+      var w = x1 + 2
+      z = w + 2
+    } else {
+      val x2 = await(f)
+      var w = x2 + 2
+      z = w - 2
+    }
+    z
+  }
+}
+
+
+@RunWith(classOf[JUnit4])
+class IfElse3Spec extends MinimalScalaTest {
+
+  @Test
+  def `variables of the same name in different blocks` {
+    val o = new TestIfElse3Class
+    val fut = o.m(10)
+    val res = Await.result(fut, 2 seconds)
+    res mustBe (16)
+  }
+}