1 files changed, 156 insertions, 1 deletions
diff --git a/test/files/jvm/scala-concurrent-tck.scala b/test/files/jvm/scala-concurrent-tck.scala
index ce86d4aef0..7197c1d853 100644
--- a/test/files/jvm/scala-concurrent-tck.scala
+++ b/test/files/jvm/scala-concurrent-tck.scala
@@ -90,6 +90,25 @@ trait FutureCallbacks extends TestBase {
     promise.success(-1)
   }
 
+  def stressTestNumberofCallbacks(): Unit = once {
+    done =>
+      val promise = Promise[Unit]
+      val otherPromise = Promise[Unit]
+      def attachMeaninglessCallbacksTo(f: Future[Any]): Unit = (1 to 1000).foreach(_ => f.onComplete(_ => ()))
+      attachMeaninglessCallbacksTo(promise.future)
+      val future = promise.future.flatMap { _ =>
+        attachMeaninglessCallbacksTo(otherPromise.future)
+        otherPromise.future
+      }
+      val numbers = new java.util.concurrent.ConcurrentHashMap[Int, Unit]()
+      (0 to 10000) foreach { x => numbers.put(x, ()) }
+      Future.sequence((0 to 10000) map { x => future.andThen({ case _ => numbers.remove(x) }) }) onComplete {
+        _ => done(numbers.isEmpty)
+      }
+      promise.success(())
+      otherPromise.success(())
+  }
+
   testOnSuccess()
   testOnSuccessWhenCompleted()
   testOnSuccessWhenFailed()
@@ -100,6 +119,7 @@ trait FutureCallbacks extends TestBase {
   //testOnFailureWhenSpecialThrowable(7, new InterruptedException)
   testThatNestedCallbacksDoNotYieldStackOverflow()
   testOnFailureWhenTimeoutException()
+  stressTestNumberofCallbacks()
 }
 
 
@@ -165,6 +185,100 @@ def testTransformFailure(): Unit = once {
       g onFailure { case e => done(e eq transformed) }
   }
 
+  def testTransformResultToResult(): Unit = once {
+    done =>
+      Future("foo").transform {
+        case Success(s) => Success(s.toUpperCase)
+        case Failure(f) => throw new Exception("test failed")
+      } onComplete {
+        case Success("FOO") => done(true)
+        case _ => done(false)
+      }
+  }
+
+  def testTransformResultToFailure(): Unit = once {
+    done => 
+      val e = new Exception("expected")
+      Future("foo").transform {
+        case Success(s) => Failure(e)
+        case Failure(f) => throw new Exception("test failed")
+      } onComplete {
+        case Failure(`e`) => done(true)
+        case _ => done(false)
+      }
+  }
+
+  def testTransformFailureToResult(): Unit = once {
+    done =>
+    val e = "foo"
+      Future(throw new Exception("initial")).transform {
+        case Success(s) => throw new Exception("test failed")
+        case Failure(f) => Success(e)
+      } onComplete {
+        case Success(`e`) => done(true)
+        case _ => done(false)
+      }
+  }
+
+  def testTransformFailureToFailure(): Unit = once {
+    done =>
+      val e = new Exception("expected")
+      Future(throw new Exception("initial")).transform {
+        case Success(s) => throw new Exception("test failed")
+        case Failure(f) => Failure(e)
+      } onComplete {
+        case Failure(`e`) => done(true)
+        case _ => done(false)
+      }
+  }
+
+    def testTransformWithResultToResult(): Unit = once {
+    done =>
+      Future("foo").transformWith {
+        case Success(s) => Future(s.toUpperCase)
+        case Failure(f) => throw new Exception("test failed")
+      } onComplete {
+        case Success("FOO") => done(true)
+        case _ => done(false)
+      }
+  }
+
+  def testTransformWithResultToFailure(): Unit = once {
+    done => 
+      val e = new Exception("expected")
+      Future("foo").transformWith {
+        case Success(s) => Future(throw e)
+        case Failure(f) => throw new Exception("test failed")
+      } onComplete {
+        case Failure(`e`) => done(true)
+        case _ => done(false)
+      }
+  }
+
+  def testTransformWithFailureToResult(): Unit = once {
+    done =>
+    val e = "foo"
+      Future(throw new Exception("initial")).transformWith {
+        case Success(s) => throw new Exception("test failed")
+        case Failure(f) => Future(e)
+      } onComplete {
+        case Success(`e`) => done(true)
+        case _ => done(false)
+      }
+  }
+
+  def testTransformWithFailureToFailure(): Unit = once {
+    done =>
+      val e = new Exception("expected")
+      Future(throw new Exception("initial")).transformWith {
+        case Success(s) => throw new Exception("test failed")
+        case Failure(f) => Future(throw e)
+      } onComplete {
+        case Failure(`e`) => done(true)
+        case _ => done(false)
+      }
+  }
+
   def testFoldFailure(): Unit = once {
     done =>
       val f = Future[Unit] { throw new Exception("expected") }
@@ -189,6 +303,16 @@ def testTransformFailure(): Unit = once {
       g onFailure { case t => done(t.getMessage() == "expected") }
   }
 
+  def testFlatMapDelayed(): Unit = once {
+    done =>
+      val f = Future { 5 }
+      val p = Promise[Int]
+      val g = f flatMap { _ => p.future }
+      g onSuccess { case x => done(x == 10) }
+      g onFailure { case _ => done(false) }
+      p.success(10)
+  }
+
   def testFilterSuccess(): Unit = once {
     done =>
       val f = Future { 4 }
@@ -352,10 +476,19 @@ def testTransformFailure(): Unit = once {
     h onFailure { case e => done(e eq cause) }
   }
 
+  def testFallbackToThis(): Unit = {
+    def check(f: Future[Int]) = assert((f fallbackTo f) eq f)
+
+    check(Future { 1 })
+    check(Future.successful(1))
+    check(Future.failed[Int](new Exception))
+  }
+
   testMapSuccess()
   testMapFailure()
   testFlatMapSuccess()
   testFlatMapFailure()
+  testFlatMapDelayed()
   testFilterSuccess()
   testFilterFailure()
   testCollectSuccess()
@@ -373,6 +506,16 @@ def testTransformFailure(): Unit = once {
   testFallbackToFailure()
   testTransformSuccess()
   testTransformSuccessPF()
+  testTransformFailure()
+  testTransformFailurePF()
+  testTransformResultToResult()
+  testTransformResultToFailure()
+  testTransformFailureToResult()
+  testTransformFailureToFailure()
+  testTransformWithResultToResult()
+  testTransformWithResultToFailure()
+  testTransformWithFailureToResult()
+  testTransformWithFailureToFailure()
 }
 
 
@@ -517,7 +660,7 @@ trait BlockContexts extends TestBase {
   // test BlockContext in our default ExecutionContext
   def testDefaultFJP(): Unit = {
     val bc = getBlockContext(BlockContext.current)
-    assert(bc.isInstanceOf[scala.concurrent.forkjoin.ForkJoinWorkerThread])
+    assert(bc.isInstanceOf[java.util.concurrent.ForkJoinWorkerThread])
   }
 
   // test BlockContext inside BlockContext.withBlockContext
@@ -593,6 +736,17 @@ trait Exceptions extends TestBase {
 
 }
 
+trait GlobalExecutionContext extends TestBase {
+  def testNameOfGlobalECThreads(): Unit = once {
+    done => Future({
+        val expectedName = "scala-execution-context-global-"+ Thread.currentThread.getId
+        done(expectedName == Thread.currentThread.getName)
+      })(ExecutionContext.global)
+  }
+
+  testNameOfGlobalECThreads()
+}
+
 trait CustomExecutionContext extends TestBase {
   import scala.concurrent.{ ExecutionContext, Awaitable }
 
@@ -772,6 +926,7 @@ with FutureProjections
 with Promises
 with BlockContexts
 with Exceptions
+with GlobalExecutionContext
 with CustomExecutionContext
 with ExecutionContextPrepare
 {