Disable execution context and futures implementation in the default package.

Fixed some tests so that they work now.
The Transactions.scala test was failing when defined in scala.concurrent
package, reporting that type `_$1` is defined twice. Until we figure out
the reason for this, the package name in that test is renamed.

3 files changed, 19 insertions, 409 deletions

diff --git a/test/files/jvm/concurrent-future.scala b/test/files/jvm/concurrent-future.scala
index eb3bbad591..b44d054219 100644
--- a/test/files/jvm/concurrent-future.scala
+++ b/test/files/jvm/concurrent-future.scala
@@ -22,7 +22,7 @@ object Test extends App {
     val f = future {
       output(1, "hai world")
     }
-    f onSuccess { _ =>
+    f onSuccess { case _ =>
       output(1, "kthxbye")
       done()
     }
@@ -33,9 +33,9 @@ object Test extends App {
     val f = future {
       output(2, "hai world")
     }
-    f onSuccess { _ =>
+    f onSuccess { case _ =>
       output(2, "awsum thx")
-      f onSuccess { _ =>
+      f onSuccess { case _ =>
         output(2, "kthxbye")
         done()
       }
@@ -49,7 +49,7 @@ object Test extends App {
       done()
       throw new Exception
     }
-    f onSuccess { _ =>
+    f onSuccess { case _ =>
       output(3, "onoes")
     }
   }
@@ -60,7 +60,7 @@ object Test extends App {
       output(4, "hai world")
       throw new Exception
     }
-    f onSuccess { _ =>
+    f onSuccess { case _ =>
       output(4, "onoes")
       done()
     }
@@ -76,7 +76,7 @@ object Test extends App {
       output(num, "hai world")
       throw cause
     }
-    f onSuccess { _ =>
+    f onSuccess { case _ =>
       output(num, "onoes")
       done()
     }
@@ -96,7 +96,7 @@ object Test extends App {
       output(8, "hai world")
       throw new FutureTimeoutException(null)
     }
-    f onSuccess { _ =>
+    f onSuccess { case _ =>
       output(8, "onoes")
       done()
     }
diff --git a/test/files/jvm/scala-concurrent-tck-akka.scala b/test/files/jvm/scala-concurrent-tck-akka.scala
deleted file mode 100644
index dfd906e59e..0000000000
--- a/test/files/jvm/scala-concurrent-tck-akka.scala
+++ /dev/null
@@ -1,391 +0,0 @@
-
-
-import akka.dispatch.{
-  Future => future,
-  Promise => promise
-}
-import akka.dispatch.Await.{result => await}
-
-// Duration required for await
-import akka.util.Duration
-import java.util.concurrent.TimeUnit
-import TimeUnit._
-
-import scala.concurrent.{
-  TimeoutException,
-  SyncVar,
-  ExecutionException
-}
-//import scala.concurrent.future
-//import scala.concurrent.promise
-//import scala.concurrent.await
-
-
-
-trait TestBase {
-
-  implicit val disp = akka.actor.ActorSystem().dispatcher
-
-  def once(body: (() => Unit) => Unit) {
-    val sv = new SyncVar[Boolean]
-    body(() => sv put true)
-    sv.take()
-  }
-  
-}
-
-
-trait FutureCallbacks extends TestBase {
-  
-  def testOnSuccess(): Unit = once {
-    done =>
-    var x = 0
-    val f = future {
-      x = 1
-    }
-    f onSuccess { case any =>
-      done()
-      assert(x == 1)
-    }
-  }
-  
-  def testOnSuccessWhenCompleted(): Unit = once {
-    done =>
-    var x = 0
-    val f = future {
-      x = 1
-    }
-    f onSuccess { case any =>
-      assert(x == 1)
-      x = 2
-      f onSuccess { case any =>
-        assert(x == 2)
-        done()
-      }
-    }
-  }
-  
-  def testOnSuccessWhenFailed(): Unit = once {
-    done =>
-    val f = future[Unit] {
-      done()
-      throw new Exception
-    }
-    f onSuccess { case any =>
-      assert(false)
-    }
-  }
-  
-  def testOnFailure(): Unit = once {
-    done =>
-    var x = 0
-    val f = future[Unit] {
-      x = 1
-      throw new Exception
-    }
-    f onSuccess { case any =>
-      done()
-      assert(false)
-    }
-    f onFailure {
-      case _ =>
-        done()
-        assert(x == 1)
-    }
-  }
-  
-  def testOnFailureWhenSpecialThrowable(num: Int, cause: Throwable): Unit = once {
-    done =>
-    val f = future[Unit] {
-      throw cause
-    }
-    f onSuccess { case any =>
-      done()
-      assert(false)
-    }
-    f onFailure {
-      case e: ExecutionException if (e.getCause == cause) =>
-        done()
-      case _ =>
-        done()
-        assert(false)
-    }
-  }
-  
-  def testOnFailureWhenTimeoutException(): Unit = once {
-    done =>
-    val f = future[Unit] {
-      throw new TimeoutException()
-    }
-    f onSuccess { case any =>
-      done()
-      assert(false)
-    }
-    f onFailure {
-      case e: TimeoutException =>
-        done()
-      case other =>
-        done()
-        assert(false)
-    }
-  }
-  
-  testOnSuccess()
-  testOnSuccessWhenCompleted()
-  testOnSuccessWhenFailed()
-  testOnFailure()
-//  testOnFailureWhenSpecialThrowable(5, new Error)
-//  testOnFailureWhenSpecialThrowable(6, new scala.util.control.ControlThrowable { })
-//  testOnFailureWhenSpecialThrowable(7, new InterruptedException)
-//  testOnFailureWhenTimeoutException()
-  
-}
-
-
-trait FutureCombinators extends TestBase {
-
-  // map: stub
-  def testMapSuccess(): Unit = once {
-    done =>
-    done()
-  }
-
-  def testMapFailure(): Unit = once {
-    done =>
-    done()
-  }
-
-  // flatMap: stub
-  def testFlatMapSuccess(): Unit = once {
-    done =>
-    done()
-  }
-
-  def testFlatMapFailure(): Unit = once {
-    done =>
-    done()
-  }
-
-  // filter: stub
-  def testFilterSuccess(): Unit = once {
-    done =>
-    done()
-  }
-
-  def testFilterFailure(): Unit = once {
-    done =>
-    done()
-  }
-
-  // foreach: stub
-  def testForeachSuccess(): Unit = once {
-    done =>
-    done()
-  }
-
-  def testForeachFailure(): Unit = once {
-    done =>
-    done()
-  }
-
-  def testRecoverSuccess(): Unit = once {
-    done =>
-    val cause = new RuntimeException
-    val f = future {
-      throw cause
-    } recover {
-      case re: RuntimeException =>
-        "recovered"
-    } onSuccess { case x =>
-      done()
-      assert(x == "recovered")
-    } onFailure { case any =>
-      done()
-      assert(false)
-    }
-  }
-
-  def testRecoverFailure(): Unit = once {
-    done =>
-    val cause = new RuntimeException
-    val f = future {
-      throw cause
-    } recover {
-      case te: TimeoutException => "timeout"
-    } onSuccess { case x =>
-      done()
-      assert(false)
-    } onFailure { case any =>
-      done()
-      assert(any == cause)
-    }
-  }
-
-  testMapSuccess()
-  testMapFailure()
-  testFlatMapSuccess()
-  testFlatMapFailure()
-  testFilterSuccess()
-  testFilterFailure()
-  testForeachSuccess()
-  testForeachFailure()
-  testRecoverSuccess()
-  testRecoverFailure()
-
-}
-
-/*
-trait FutureProjections extends TestBase {
-  
-  def testFailedFailureOnComplete(): Unit = once {
-    done =>
-    val cause = new RuntimeException
-    val f = future {
-      throw cause
-    }
-    f.failed onComplete {
-      case Right(t) =>
-        assert(t == cause)
-        done()
-      case Left(t) =>
-        assert(false)
-    }
-  }
-  
-  def testFailedFailureOnSuccess(): Unit = once {
-    done =>
-    val cause = new RuntimeException
-    val f = future {
-      throw cause
-    }
-    f.failed onSuccess {
-      t =>
-      assert(t == cause)
-      done()
-    }
-  }
-  
-  def testFailedSuccessOnComplete(): Unit = once {
-    done =>
-    val f = future { 0 }
-    f.failed onComplete {
-      case Right(t) =>
-        assert(false)
-      case Left(t) =>
-        assert(t.isInstanceOf[NoSuchElementException])
-        done()
-    }
-  }
-  
-  def testFailedSuccessOnFailure(): Unit = once {
-    done =>
-    val f = future { 0 }
-    f.failed onFailure {
-      case nsee: NoSuchElementException =>
-      done()
-    }
-  }
-  
-  def testFailedFailureAwait(): Unit = once {
-    done =>
-    val cause = new RuntimeException
-    val f = future {
-      throw cause
-    }
-    assert(await(0, f.failed) == cause)
-    done()
-  }
-  
-  def testFailedSuccessAwait(): Unit = once {
-    done =>
-    val f = future { 0 }
-    try {
-      println(await(0, f.failed))
-      assert(false)
-    } catch {
-      case nsee: NoSuchElementException => done()
-    }
-  }
-  
-  testFailedFailureOnComplete()
-  testFailedFailureOnSuccess()
-  testFailedSuccessOnComplete()
-  testFailedSuccessOnFailure()
-  testFailedFailureAwait()
-  //testFailedSuccessAwait()
-  
-}
-*/
-
-trait Blocking extends TestBase {
-  
-  def testAwaitSuccess(): Unit = once {
-    done =>
-    val f = future { 0 }
-    await(f, Duration(500, "ms"))
-    done()
-  }
-  
-  def testAwaitFailure(): Unit = once {
-    done =>
-    val cause = new RuntimeException
-    val f = future {
-      throw cause
-    }
-    try {
-      await(f, Duration(500, "ms"))
-      assert(false)
-    } catch {
-      case t =>
-        assert(t == cause)
-        done()
-    }
-  }
-  
-  testAwaitSuccess()
-  testAwaitFailure()
-  
-}
-
-/*
-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()
-
-}
-*/
-
-trait Exceptions extends TestBase {
-  
-}
-
-
-object Test
-extends App
-with FutureCallbacks
-with FutureCombinators
-/*with FutureProjections*/
-/*with Promises*/
-with Blocking
-with Exceptions
-{
-  System.exit(0)
-}
-
-
diff --git a/test/files/jvm/scala-concurrent-tck.scala b/test/files/jvm/scala-concurrent-tck.scala
index a951c09da2..244ff02da7 100644
--- a/test/files/jvm/scala-concurrent-tck.scala
+++ b/test/files/jvm/scala-concurrent-tck.scala
@@ -11,6 +11,7 @@ import scala.concurrent.{
 import scala.concurrent.future
 import scala.concurrent.promise
 import scala.concurrent.blocking
+import scala.util.{ Try, Success, Failure }
 
 import scala.util.Duration
 
@@ -23,13 +24,13 @@ trait TestBase {
     sv.take()
   }
   
-  def assert(cond: => Boolean) {
-    try {
-      Predef.assert(cond)
-    } catch {
-      case e => e.printStackTrace()
-    }
-  }
+  // def assert(cond: => Boolean) {
+  //   try {
+  //     Predef.assert(cond)
+  //   } catch {
+  //     case e => e.printStackTrace()
+  //   }
+  // }
 
 }
 
@@ -264,10 +265,10 @@ trait FutureProjections extends TestBase {
       throw cause
     }
     f.failed onComplete {
-      case Right(t) =>
+      case Success(t) =>
         assert(t == cause)
         done()
-      case Left(t) =>
+      case Failure(t) =>
         assert(false)
     }
   }
@@ -289,9 +290,9 @@ trait FutureProjections extends TestBase {
     done =>
     val f = future { 0 }
     f.failed onComplete {
-      case Right(t) =>
+      case Success(t) =>
         assert(false)
-      case Left(t) =>
+      case Failure(t) =>
         assert(t.isInstanceOf[NoSuchElementException])
         done()
     }