Merged with Viktors work with removing client managed actors. Also removed actor.id, added actor.address

akka-actor-tests/src/test/scala/akka/actor/supervisor/SupervisorSpec.scala

@@ -60,7 +60,11 @@ object SupervisorSpec {
   class Master extends Actor {
     self.faultHandler = OneForOneStrategy(List(classOf[Exception]), 5, testMillis(1 second).toInt)
 
-    val temp = self.spawnLink[TemporaryActor]
+    val temp = {
+      val a = actorOf[TemporaryActor]
+      self link a
+      a.start
+    }
 
     override def receive = {
       case Die => temp !! (Die, TimeoutMillis)

akka-actor-tests/src/test/scala/akka/dataflow/DataFlowSpec.scala

@@ -1,165 +0,0 @@
-/**
- * Copyright (C) 2009-2011 Scalable Solutions AB <http://scalablesolutions.se>
- */
-
-package akka.dataflow
-
-import org.scalatest.Spec
-import org.scalatest.Assertions
-import org.scalatest.matchers.ShouldMatchers
-import org.scalatest.BeforeAndAfterAll
-import org.scalatest.junit.JUnitRunner
-import org.junit.runner.RunWith
-
-import akka.dispatch.DefaultCompletableFuture
-import java.util.concurrent.{TimeUnit, CountDownLatch}
-import annotation.tailrec
-import java.util.concurrent.atomic.{AtomicLong, AtomicReference, AtomicInteger}
-import akka.actor.ActorRegistry
-
-@RunWith(classOf[JUnitRunner])
-class DataFlowTest extends Spec with ShouldMatchers with BeforeAndAfterAll {
-    describe("DataflowVariable") {
-      it("should be able to set the value of one variable from other variables") {
-        import DataFlow._
-
-        val latch = new CountDownLatch(1)
-        val result = new AtomicInteger(0)
-        val x, y, z = new DataFlowVariable[Int]
-        thread {
-          z << x() + y()
-          result.set(z())
-          latch.countDown
-        }
-        thread { x << 40 }
-        thread { y << 2 }
-
-        latch.await(10,TimeUnit.SECONDS) should equal (true)
-        result.get should equal (42)
-        List(x,y,z).foreach(_.shutdown)
-      }
-
-      it("should be able to sum a sequence of ints") {
-        import DataFlow._
-
-        def ints(n: Int, max: Int): List[Int] =
-          if (n == max) Nil
-          else n :: ints(n + 1, max)
-
-        def sum(s: Int, stream: List[Int]): List[Int] = stream match {
-          case Nil => s :: Nil
-          case h :: t => s :: sum(h + s, t)
-        }
-
-        val latch = new CountDownLatch(1)
-        val result = new AtomicReference[List[Int]](Nil)
-        val x = new DataFlowVariable[List[Int]]
-        val y = new DataFlowVariable[List[Int]]
-        val z = new DataFlowVariable[List[Int]]
-
-        thread { x << ints(0, 1000) }
-        thread { y << sum(0, x())   }
-
-        thread { z << y()
-          result.set(z())
-          latch.countDown
-        }
-
-        latch.await(10,TimeUnit.SECONDS) should equal (true)
-        result.get should equal (sum(0,ints(0,1000)))
-        List(x,y,z).foreach(_.shutdown)
-      }
-/*
-    it("should be able to join streams") {
-      import DataFlow._
-      Actor.registry.local.shutdownAll
-
-      def ints(n: Int, max: Int, stream: DataFlowStream[Int]): Unit = if (n != max) {
-        stream <<< n
-        ints(n + 1, max, stream)
-      }
-
-      def sum(s: Int, in: DataFlowStream[Int], out: DataFlowStream[Int]): Unit = {
-        out <<< s
-        sum(in() + s, in, out)
-      }
-
-      val producer = new DataFlowStream[Int]
-      val consumer = new DataFlowStream[Int]
-      val latch = new CountDownLatch(1)
-      val result = new AtomicInteger(0)
-
-      val t1 = thread { ints(0, 1000, producer) }
-      val t2 = thread {
-        Thread.sleep(1000)
-        result.set(producer.map(x => x * x).foldLeft(0)(_ + _))
-        latch.countDown
-      }
-
-      latch.await(3,TimeUnit.SECONDS) should equal (true)
-      result.get should equal (332833500)
-    }
-
-    it("should be able to sum streams recursively") {
-      import DataFlow._
-
-      def ints(n: Int, max: Int, stream: DataFlowStream[Int]): Unit = if (n != max) {
-        stream <<< n
-        ints(n + 1, max, stream)
-      }
-
-      def sum(s: Int, in: DataFlowStream[Int], out: DataFlowStream[Int]): Unit = {
-        out <<< s
-        sum(in() + s, in, out)
-      }
-
-      val result = new AtomicLong(0)
-
-      val producer = new DataFlowStream[Int]
-      val consumer = new DataFlowStream[Int]
-      val latch = new CountDownLatch(1)
-
-      @tailrec def recurseSum(stream: DataFlowStream[Int]): Unit = {
-        val x = stream()
-
-        if(result.addAndGet(x) == 166666500)
-          latch.countDown
-
-        recurseSum(stream)
-      }
-
-      thread { ints(0, 1000, producer) }
-      thread { sum(0, producer, consumer) }
-      thread { recurseSum(consumer) }
-
-      latch.await(15,TimeUnit.SECONDS) should equal (true)
-    }
-*/
-  /* Test not ready for prime time, causes some sort of deadlock */
-  /*  it("should be able to conditionally set variables") {
-
-      import DataFlow._
-      Actor.registry.local.shutdownAll
-
-      val latch  = new CountDownLatch(1)
-      val x, y, z, v = new DataFlowVariable[Int]
-
-      val main = thread {
-        x << 1
-        z << Math.max(x(),y())
-        latch.countDown
-      }
-
-      val setY = thread {
-       // Thread.sleep(2000)
-        y << 2
-      }
-
-      val setV = thread {
-        v << y
-      }
-      List(x,y,z,v) foreach (_.shutdown)
-      latch.await(2,TimeUnit.SECONDS) should equal (true)
-    }*/
-  }
-}

akka-actor-tests/src/test/scala/akka/dispatch/FutureSpec.scala

@@ -134,81 +134,6 @@ class FutureSpec extends JUnitSuite {
     actor.stop
   }
 
-  @Test def shouldFutureAwaitEitherLeft = {
-    val actor1 = actorOf[TestActor].start
-    val actor2 = actorOf[TestActor].start
-    val future1 = actor1 !!! "Hello"
-    val future2 = actor2 !!! "NoReply"
-    val result = Futures.awaitEither(future1, future2)
-    assert(result.isDefined)
-    assert("World" === result.get)
-    actor1.stop
-    actor2.stop
-  }
-
-  @Test def shouldFutureAwaitEitherRight = {
-    val actor1 = actorOf[TestActor].start
-    val actor2 = actorOf[TestActor].start
-    val future1 = actor1 !!! "NoReply"
-    val future2 = actor2 !!! "Hello"
-    val result = Futures.awaitEither(future1, future2)
-    assert(result.isDefined)
-    assert("World" === result.get)
-    actor1.stop
-    actor2.stop
-  }
-
-  @Test def shouldFutureAwaitOneLeft = {
-    val actor1 = actorOf[TestActor].start
-    val actor2 = actorOf[TestActor].start
-    val future1 = actor1 !!! "NoReply"
-    val future2 = actor2 !!! "Hello"
-    val result = Futures.awaitOne(List(future1, future2))
-    assert(result.result.isDefined)
-    assert("World" === result.result.get)
-    actor1.stop
-    actor2.stop
-  }
-
-  @Test def shouldFutureAwaitOneRight = {
-    val actor1 = actorOf[TestActor].start
-    val actor2 = actorOf[TestActor].start
-    val future1 = actor1 !!! "Hello"
-    val future2 = actor2 !!! "NoReply"
-    val result = Futures.awaitOne(List(future1, future2))
-    assert(result.result.isDefined)
-    assert("World" === result.result.get)
-    actor1.stop
-    actor2.stop
-  }
-
-  @Test def shouldFutureAwaitAll = {
-    val actor1 = actorOf[TestActor].start
-    val actor2 = actorOf[TestActor].start
-    val future1 = actor1 !!! "Hello"
-    val future2 = actor2 !!! "Hello"
-    Futures.awaitAll(List(future1, future2))
-    assert(future1.result.isDefined)
-    assert("World" === future1.result.get)
-    assert(future2.result.isDefined)
-    assert("World" === future2.result.get)
-    actor1.stop
-    actor2.stop
-  }
-
-  @Test def shouldFuturesAwaitMapHandleEmptySequence {
-    assert(Futures.awaitMap[Nothing,Unit](Nil)(x => ()) === Nil)
-  }
-
-  @Test def shouldFuturesAwaitMapHandleNonEmptySequence {
-    val latches = (1 to 3) map (_ => new StandardLatch)
-    val actors = latches map (latch => actorOf(new TestDelayActor(latch)).start)
-    val futures = actors map (actor => (actor.!!![String]("Hello")))
-    latches foreach { _.open }
-
-    assert(Futures.awaitMap(futures)(_.result.map(_.length).getOrElse(0)).sum === (latches.size * "World".length))
-  }
-
   @Test def shouldFoldResults {
     val actors = (1 to 10).toList map { _ =>
       actorOf(new Actor {