From 5fcd1e067767b56ae323b0a37b169bf4e0a937b6 Mon Sep 17 00:00:00 2001
From: Philipp Haller <hallerp@gmail.com>
Date: Tue, 13 Dec 2011 09:03:30 +0100
Subject: Fix default.ExecutionContextImpl.promise. Add promise test.

---
 .../scala/concurrent/default/TaskImpl.scala        |  6 +++---
 test/files/jvm/scala-concurrent-tck.scala          | 25 +++++++++++++++++++++-
 2 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/src/library/scala/concurrent/default/TaskImpl.scala b/src/library/scala/concurrent/default/TaskImpl.scala
index b4c08ba710..ea465225c8 100644
--- a/src/library/scala/concurrent/default/TaskImpl.scala
+++ b/src/library/scala/concurrent/default/TaskImpl.scala
@@ -91,7 +91,7 @@ private[concurrent] class PromiseImpl[T](context: ExecutionContextImpl)
    *  
    *  $promiseCompletion
    */
-  def fulfill(value: T): Unit = {
+  def success(value: T): Unit = {
     val cbs = tryCompleteState(Success(value))
     if (cbs == null)
       throw new IllegalStateException
@@ -109,7 +109,7 @@ private[concurrent] class PromiseImpl[T](context: ExecutionContextImpl)
    *  
    *  $promiseCompletion
    */
-  def break(t: Throwable): Unit = {
+  def failure(t: Throwable): Unit = {
     val wrapped = wrap(t)
     val cbs = tryCompleteState(Failure(wrapped))
     if (cbs == null)
@@ -260,7 +260,7 @@ private[concurrent] final class ExecutionContextImpl extends ExecutionContext {
   }
   
   def promise[T]: Promise[T] =
-    null // TODO
+    new PromiseImpl[T](this)
   
   // TODO fix the timeout
   def blockingCall[T](timeout: Timeout, b: Blockable[T]): T = b match {
diff --git a/test/files/jvm/scala-concurrent-tck.scala b/test/files/jvm/scala-concurrent-tck.scala
index e1b8d2763c..705675ae43 100644
--- a/test/files/jvm/scala-concurrent-tck.scala
+++ b/test/files/jvm/scala-concurrent-tck.scala
@@ -3,6 +3,7 @@
 
 import scala.concurrent.{
   Future,
+  Promise,
   TimeoutException,
   SyncVar,
   ExecutionException
@@ -14,6 +15,8 @@ trait TestBase {
   
   def future[T](body: =>T): Future[T]
   
+  def promise[T]: Promise[T]
+  
   def once(body: (() => Unit) => Unit) {
     val sv = new SyncVar[Boolean]
     body(() => sv put true)
@@ -141,7 +144,25 @@ trait FutureProjections extends TestBase {
 
 
 trait Promises extends TestBase {
-  
+
+  def testSuccess(): Unit = once {
+    done =>
+    val p = promise[Int]
+    val f = p.future
+    
+    f.onSuccess { x =>
+      done()
+      assert(x == 5)
+    } onFailure { case any =>
+      done()
+      assert(false)
+    }
+    
+    p.success(5)
+  }
+
+  testSuccess()
+
 }
 
 
@@ -161,6 +182,8 @@ with Exceptions
   
   def future[T](body: =>T) = scala.concurrent.future(body)
   
+  def promise[T] = scala.concurrent.promise[T]
+
 }
 
 
-- 
cgit v1.2.3