move code to src/test

* so that it compiles and tests pass
* fix some additional snip references in getting started

akka-docs/src/test/scala/docs/routing/ConsistentHashingRouterDocSpec.scala

@@ -0,0 +1,79 @@
+/**
+ * Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
+ */
+package docs.routing
+
+import akka.testkit.AkkaSpec
+import akka.testkit.ImplicitSender
+import akka.routing.FromConfig
+import akka.actor.ActorRef
+
+object ConsistentHashingRouterDocSpec {
+
+  //#cache-actor
+  import akka.actor.Actor
+  import akka.routing.ConsistentHashingRouter.ConsistentHashable
+
+  class Cache extends Actor {
+    var cache = Map.empty[String, String]
+
+    def receive = {
+      case Entry(key, value) => cache += (key -> value)
+      case Get(key)          => sender() ! cache.get(key)
+      case Evict(key)        => cache -= key
+    }
+  }
+
+  final case class Evict(key: String)
+
+  final case class Get(key: String) extends ConsistentHashable {
+    override def consistentHashKey: Any = key
+  }
+
+  final case class Entry(key: String, value: String)
+  //#cache-actor
+
+}
+
+class ConsistentHashingRouterDocSpec extends AkkaSpec with ImplicitSender {
+
+  import ConsistentHashingRouterDocSpec._
+
+  "demonstrate usage of ConsistentHashableRouter" in {
+
+    def context = system
+
+    //#consistent-hashing-router
+    import akka.actor.Props
+    import akka.routing.ConsistentHashingPool
+    import akka.routing.ConsistentHashingRouter.ConsistentHashMapping
+    import akka.routing.ConsistentHashingRouter.ConsistentHashableEnvelope
+
+    def hashMapping: ConsistentHashMapping = {
+      case Evict(key) => key
+    }
+
+    val cache: ActorRef =
+      context.actorOf(ConsistentHashingPool(10, hashMapping = hashMapping).
+        props(Props[Cache]), name = "cache")
+
+    cache ! ConsistentHashableEnvelope(
+      message = Entry("hello", "HELLO"), hashKey = "hello")
+    cache ! ConsistentHashableEnvelope(
+      message = Entry("hi", "HI"), hashKey = "hi")
+
+    cache ! Get("hello")
+    expectMsg(Some("HELLO"))
+
+    cache ! Get("hi")
+    expectMsg(Some("HI"))
+
+    cache ! Evict("hi")
+    cache ! Get("hi")
+    expectMsg(None)
+
+    //#consistent-hashing-router
+
+  }
+
+}

akka-docs/src/test/scala/docs/routing/CustomRouterDocSpec.scala

@@ -0,0 +1,146 @@
+/**
+ * Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
+ */
+package docs.routing
+
+import akka.testkit.AkkaSpec
+import akka.testkit.ImplicitSender
+import akka.actor.Actor
+import akka.actor.Props
+import CustomRouterDocSpec.RedundancyRoutingLogic
+import scala.collection.immutable
+import akka.actor.ActorSystem
+import akka.routing.FromConfig
+import akka.actor.ActorRef
+
+object CustomRouterDocSpec {
+
+  val config = """
+#//#config
+akka.actor.deployment {
+  /redundancy2 {
+    router = "jdocs.routing.RedundancyGroup"
+    routees.paths = ["/user/s1", "/user/s2", "/user/s3"]
+    nbr-copies = 5
+  }
+}
+#//#config
+"""
+
+  val jconfig = """
+#//#jconfig
+akka.actor.deployment {
+  /redundancy2 {
+    router = "jdocs.routing.RedundancyGroup"
+    routees.paths = ["/user/s1", "/user/s2", "/user/s3"]
+    nbr-copies = 5
+  }
+}
+#//#jconfig
+"""
+
+  //#routing-logic
+  import scala.collection.immutable
+  import java.util.concurrent.ThreadLocalRandom
+  import akka.routing.RoundRobinRoutingLogic
+  import akka.routing.RoutingLogic
+  import akka.routing.Routee
+  import akka.routing.SeveralRoutees
+
+  class RedundancyRoutingLogic(nbrCopies: Int) extends RoutingLogic {
+    val roundRobin = RoundRobinRoutingLogic()
+    def select(message: Any, routees: immutable.IndexedSeq[Routee]): Routee = {
+      val targets = (1 to nbrCopies).map(_ => roundRobin.select(message, routees))
+      SeveralRoutees(targets)
+    }
+  }
+  //#routing-logic
+
+  class Storage extends Actor {
+    def receive = {
+      case x => sender() ! x
+    }
+  }
+
+  //#unit-test-logic
+  final case class TestRoutee(n: Int) extends Routee {
+    override def send(message: Any, sender: ActorRef): Unit = ()
+  }
+
+  //#unit-test-logic
+}
+
+//#group
+import akka.dispatch.Dispatchers
+import akka.routing.Group
+import akka.routing.Router
+import akka.japi.Util.immutableSeq
+import com.typesafe.config.Config
+
+final case class RedundancyGroup(routeePaths: immutable.Iterable[String], nbrCopies: Int) extends Group {
+
+  def this(config: Config) = this(
+    routeePaths = immutableSeq(config.getStringList("routees.paths")),
+    nbrCopies = config.getInt("nbr-copies"))
+
+  override def paths(system: ActorSystem): immutable.Iterable[String] = routeePaths
+
+  override def createRouter(system: ActorSystem): Router =
+    new Router(new RedundancyRoutingLogic(nbrCopies))
+
+  override val routerDispatcher: String = Dispatchers.DefaultDispatcherId
+}
+//#group
+
+class CustomRouterDocSpec extends AkkaSpec(CustomRouterDocSpec.config) with ImplicitSender {
+
+  import CustomRouterDocSpec._
+  import akka.routing.SeveralRoutees
+
+  "unit test routing logic" in {
+    //#unit-test-logic
+    val logic = new RedundancyRoutingLogic(nbrCopies = 3)
+
+    val routees = for (n <- 1 to 7) yield TestRoutee(n)
+
+    val r1 = logic.select("msg", routees)
+    r1.asInstanceOf[SeveralRoutees].routees should be(
+      Vector(TestRoutee(1), TestRoutee(2), TestRoutee(3)))
+
+    val r2 = logic.select("msg", routees)
+    r2.asInstanceOf[SeveralRoutees].routees should be(
+      Vector(TestRoutee(4), TestRoutee(5), TestRoutee(6)))
+
+    val r3 = logic.select("msg", routees)
+    r3.asInstanceOf[SeveralRoutees].routees should be(
+      Vector(TestRoutee(7), TestRoutee(1), TestRoutee(2)))
+    //#unit-test-logic
+
+  }
+
+  "demonstrate usage of custom router" in {
+    //#usage-1
+    for (n <- 1 to 10) system.actorOf(Props[Storage], "s" + n)
+
+    val paths = for (n <- 1 to 10) yield ("/user/s" + n)
+    val redundancy1: ActorRef =
+      system.actorOf(
+        RedundancyGroup(paths, nbrCopies = 3).props(),
+        name = "redundancy1")
+    redundancy1 ! "important"
+    //#usage-1
+
+    for (_ <- 1 to 3) expectMsg("important")
+
+    //#usage-2
+    val redundancy2: ActorRef = system.actorOf(
+      FromConfig.props(),
+      name = "redundancy2")
+    redundancy2 ! "very important"
+    //#usage-2
+
+    for (_ <- 1 to 5) expectMsg("very important")
+
+  }
+
+}

akka-docs/src/test/scala/docs/routing/RouterDocSpec.scala

@@ -0,0 +1,626 @@
+/**
+ * Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
+ */
+package docs.routing
+
+import scala.concurrent.duration._
+import akka.testkit._
+import akka.actor.{ ActorRef, Props, Actor }
+import akka.actor.Terminated
+import akka.routing.FromConfig
+import akka.routing.RoundRobinPool
+import akka.routing.RandomPool
+import akka.routing.RoundRobinGroup
+import akka.routing.SmallestMailboxPool
+import akka.routing.BroadcastPool
+import akka.routing.BroadcastGroup
+import akka.routing.ConsistentHashingGroup
+import akka.routing.ConsistentHashingPool
+import akka.routing.DefaultResizer
+import akka.routing.ScatterGatherFirstCompletedGroup
+import akka.routing.RandomGroup
+import akka.routing.ScatterGatherFirstCompletedPool
+import akka.routing.BalancingPool
+import akka.routing.TailChoppingGroup
+import akka.routing.TailChoppingPool
+
+object RouterDocSpec {
+
+  val config = """
+#//#config-round-robin-pool
+akka.actor.deployment {
+  /parent/router1 {
+    router = round-robin-pool
+    nr-of-instances = 5
+  }
+}
+#//#config-round-robin-pool
+
+#//#config-round-robin-group
+akka.actor.deployment {
+  /parent/router3 {
+    router = round-robin-group
+    routees.paths = ["/user/workers/w1", "/user/workers/w2", "/user/workers/w3"]
+  }
+}
+#//#config-round-robin-group
+
+#//#config-random-pool
+akka.actor.deployment {
+  /parent/router5 {
+    router = random-pool
+    nr-of-instances = 5
+  }
+}
+#//#config-random-pool
+
+#//#config-random-group
+akka.actor.deployment {
+  /parent/router7 {
+    router = random-group
+    routees.paths = ["/user/workers/w1", "/user/workers/w2", "/user/workers/w3"]
+  }
+}
+#//#config-random-group
+
+#//#config-balancing-pool
+akka.actor.deployment {
+  /parent/router9 {
+    router = balancing-pool
+    nr-of-instances = 5
+  }
+}
+#//#config-balancing-pool
+
+#//#config-balancing-pool2
+akka.actor.deployment {
+  /parent/router9b {
+    router = balancing-pool
+    nr-of-instances = 5
+    pool-dispatcher {
+      attempt-teamwork = off
+    }
+  }
+}
+#//#config-balancing-pool2
+
+#//#config-balancing-pool3
+akka.actor.deployment {
+  /parent/router10b {
+    router = balancing-pool
+    nr-of-instances = 5
+    pool-dispatcher {
+      executor = "thread-pool-executor"
+
+      # allocate exactly 5 threads for this pool
+      thread-pool-executor {
+        core-pool-size-min = 5
+        core-pool-size-max = 5
+      }
+    }
+  }
+}
+#//#config-balancing-pool3
+
+#//#config-balancing-pool4
+akka.actor.deployment {
+  /parent/router10c {
+    router = balancing-pool
+    nr-of-instances = 5
+    pool-dispatcher {
+      mailbox = myapp.myprioritymailbox
+    }
+  }
+}
+#//#config-balancing-pool4
+
+#//#config-smallest-mailbox-pool
+akka.actor.deployment {
+  /parent/router11 {
+    router = smallest-mailbox-pool
+    nr-of-instances = 5
+  }
+}
+#//#config-smallest-mailbox-pool
+
+#//#config-broadcast-pool
+akka.actor.deployment {
+  /parent/router13 {
+    router = broadcast-pool
+    nr-of-instances = 5
+  }
+}
+#//#config-broadcast-pool
+
+#//#config-broadcast-group
+akka.actor.deployment {
+  /parent/router15 {
+    router = broadcast-group
+    routees.paths = ["/user/workers/w1", "/user/workers/w2", "/user/workers/w3"]
+  }
+}
+#//#config-broadcast-group
+
+#//#config-scatter-gather-pool
+akka.actor.deployment {
+  /parent/router17 {
+    router = scatter-gather-pool
+    nr-of-instances = 5
+    within = 10 seconds
+  }
+}
+#//#config-scatter-gather-pool
+
+#//#config-scatter-gather-group
+akka.actor.deployment {
+  /parent/router19 {
+    router = scatter-gather-group
+    routees.paths = ["/user/workers/w1", "/user/workers/w2", "/user/workers/w3"]
+    within = 10 seconds
+  }
+}
+#//#config-scatter-gather-group
+
+#//#config-tail-chopping-pool
+akka.actor.deployment {
+  /parent/router21 {
+    router = tail-chopping-pool
+    nr-of-instances = 5
+    within = 10 seconds
+    tail-chopping-router.interval = 20 milliseconds
+  }
+}
+#//#config-tail-chopping-pool
+
+#//#config-tail-chopping-group
+akka.actor.deployment {
+  /parent/router23 {
+    router = tail-chopping-group
+    routees.paths = ["/user/workers/w1", "/user/workers/w2", "/user/workers/w3"]
+    within = 10 seconds
+    tail-chopping-router.interval = 20 milliseconds
+  }
+}
+#//#config-tail-chopping-group
+
+#//#config-consistent-hashing-pool
+akka.actor.deployment {
+  /parent/router25 {
+    router = consistent-hashing-pool
+    nr-of-instances = 5
+    virtual-nodes-factor = 10
+  }
+}
+#//#config-consistent-hashing-pool
+
+#//#config-consistent-hashing-group
+akka.actor.deployment {
+  /parent/router27 {
+    router = consistent-hashing-group
+    routees.paths = ["/user/workers/w1", "/user/workers/w2", "/user/workers/w3"]
+    virtual-nodes-factor = 10
+  }
+}
+#//#config-consistent-hashing-group
+
+#//#config-remote-round-robin-pool
+akka.actor.deployment {
+  /parent/remotePool {
+    router = round-robin-pool
+    nr-of-instances = 10
+    target.nodes = ["akka.tcp://app@10.0.0.2:2552", "akka.tcp://app@10.0.0.3:2552"]
+  }
+}
+#//#config-remote-round-robin-pool
+
+#//#config-remote-round-robin-pool-artery
+akka.actor.deployment {
+  /parent/remotePool {
+    router = round-robin-pool
+    nr-of-instances = 10
+    target.nodes = ["tcp://app@10.0.0.2:2552", "akka://app@10.0.0.3:2552"]
+  }
+}
+#//#config-remote-round-robin-pool-artery
+
+#//#config-remote-round-robin-group
+akka.actor.deployment {
+  /parent/remoteGroup {
+    router = round-robin-group
+    routees.paths = [
+      "akka.tcp://app@10.0.0.1:2552/user/workers/w1",
+      "akka.tcp://app@10.0.0.2:2552/user/workers/w1",
+      "akka.tcp://app@10.0.0.3:2552/user/workers/w1"]
+  }
+}
+#//#config-remote-round-robin-group
+
+#//#config-remote-round-robin-group-artery
+akka.actor.deployment {
+  /parent/remoteGroup2 {
+    router = round-robin-group
+    routees.paths = [
+      "akka://app@10.0.0.1:2552/user/workers/w1",
+      "akka://app@10.0.0.2:2552/user/workers/w1",
+      "akka://app@10.0.0.3:2552/user/workers/w1"]
+  }
+}
+#//#config-remote-round-robin-group-artery
+
+#//#config-resize-pool
+akka.actor.deployment {
+  /parent/router29 {
+    router = round-robin-pool
+    resizer {
+      lower-bound = 2
+      upper-bound = 15
+      messages-per-resize = 100
+    }
+  }
+}
+#//#config-resize-pool
+
+#//#config-optimal-size-exploring-resize-pool
+akka.actor.deployment {
+  /parent/router31 {
+    router = round-robin-pool
+    optimal-size-exploring-resizer {
+      enabled = on
+      action-interval = 5s
+      downsize-after-underutilized-for = 72h
+    }
+  }
+}
+#//#config-optimal-size-exploring-resize-pool
+
+#//#config-pool-dispatcher
+akka.actor.deployment {
+  /poolWithDispatcher {
+    router = random-pool
+    nr-of-instances = 5
+    pool-dispatcher {
+      fork-join-executor.parallelism-min = 5
+      fork-join-executor.parallelism-max = 5
+    }
+  }
+}
+#//#config-pool-dispatcher
+
+router-dispatcher {}
+"""
+
+  final case class Work(payload: String)
+
+  //#router-in-actor
+  import akka.routing.{ ActorRefRoutee, RoundRobinRoutingLogic, Router }
+
+  class Master extends Actor {
+    var router = {
+      val routees = Vector.fill(5) {
+        val r = context.actorOf(Props[Worker])
+        context watch r
+        ActorRefRoutee(r)
+      }
+      Router(RoundRobinRoutingLogic(), routees)
+    }
+
+    def receive = {
+      case w: Work =>
+        router.route(w, sender())
+      case Terminated(a) =>
+        router = router.removeRoutee(a)
+        val r = context.actorOf(Props[Worker])
+        context watch r
+        router = router.addRoutee(r)
+    }
+  }
+  //#router-in-actor
+
+  class Worker extends Actor {
+    def receive = {
+      case _ =>
+    }
+  }
+
+  //#create-worker-actors
+  class Workers extends Actor {
+    context.actorOf(Props[Worker], name = "w1")
+    context.actorOf(Props[Worker], name = "w2")
+    context.actorOf(Props[Worker], name = "w3")
+    // ...
+    //#create-worker-actors
+
+    def receive = {
+      case _ =>
+    }
+  }
+
+  class Parent extends Actor {
+
+    //#paths
+    val paths = List("/user/workers/w1", "/user/workers/w2", "/user/workers/w3")
+    //#paths
+
+    //#round-robin-pool-1
+    val router1: ActorRef =
+      context.actorOf(FromConfig.props(Props[Worker]), "router1")
+    //#round-robin-pool-1
+
+    //#round-robin-pool-2
+    val router2: ActorRef =
+      context.actorOf(RoundRobinPool(5).props(Props[Worker]), "router2")
+    //#round-robin-pool-2
+
+    //#round-robin-group-1
+    val router3: ActorRef =
+      context.actorOf(FromConfig.props(), "router3")
+    //#round-robin-group-1
+
+    //#round-robin-group-2
+    val router4: ActorRef =
+      context.actorOf(RoundRobinGroup(paths).props(), "router4")
+    //#round-robin-group-2
+
+    //#random-pool-1
+    val router5: ActorRef =
+      context.actorOf(FromConfig.props(Props[Worker]), "router5")
+    //#random-pool-1
+
+    //#random-pool-2
+    val router6: ActorRef =
+      context.actorOf(RandomPool(5).props(Props[Worker]), "router6")
+    //#random-pool-2
+
+    //#random-group-1
+    val router7: ActorRef =
+      context.actorOf(FromConfig.props(), "router7")
+    //#random-group-1
+
+    //#random-group-2
+    val router8: ActorRef =
+      context.actorOf(RandomGroup(paths).props(), "router8")
+    //#random-group-2
+
+    //#balancing-pool-1
+    val router9: ActorRef =
+      context.actorOf(FromConfig.props(Props[Worker]), "router9")
+    //#balancing-pool-1
+
+    //#balancing-pool-2
+    val router10: ActorRef =
+      context.actorOf(BalancingPool(5).props(Props[Worker]), "router10")
+    //#balancing-pool-2
+
+    // #balancing-pool-3
+    val router10b: ActorRef =
+      context.actorOf(BalancingPool(20).props(Props[Worker]), "router10b")
+    //#balancing-pool-3
+    import scala.collection.JavaConversions._
+    for (i <- 1 to 100) router10b ! i
+    val threads10b = Thread.getAllStackTraces.keySet.filter { _.getName contains "router10b" }
+    val threads10bNr = threads10b.size
+    require(threads10bNr == 5, s"Expected 5 threads for router10b, had $threads10bNr! Got: ${threads10b.map(_.getName)}")
+
+    //#smallest-mailbox-pool-1
+    val router11: ActorRef =
+      context.actorOf(FromConfig.props(Props[Worker]), "router11")
+    //#smallest-mailbox-pool-1
+
+    //#smallest-mailbox-pool-2
+    val router12: ActorRef =
+      context.actorOf(SmallestMailboxPool(5).props(Props[Worker]), "router12")
+    //#smallest-mailbox-pool-2
+
+    //#broadcast-pool-1
+    val router13: ActorRef =
+      context.actorOf(FromConfig.props(Props[Worker]), "router13")
+    //#broadcast-pool-1
+
+    //#broadcast-pool-2
+    val router14: ActorRef =
+      context.actorOf(BroadcastPool(5).props(Props[Worker]), "router14")
+    //#broadcast-pool-2
+
+    //#broadcast-group-1
+    val router15: ActorRef =
+      context.actorOf(FromConfig.props(), "router15")
+    //#broadcast-group-1
+
+    //#broadcast-group-2
+    val router16: ActorRef =
+      context.actorOf(BroadcastGroup(paths).props(), "router16")
+    //#broadcast-group-2
+
+    //#scatter-gather-pool-1
+    val router17: ActorRef =
+      context.actorOf(FromConfig.props(Props[Worker]), "router17")
+    //#scatter-gather-pool-1
+
+    //#scatter-gather-pool-2
+    val router18: ActorRef =
+      context.actorOf(ScatterGatherFirstCompletedPool(5, within = 10.seconds).
+        props(Props[Worker]), "router18")
+    //#scatter-gather-pool-2
+
+    //#scatter-gather-group-1
+    val router19: ActorRef =
+      context.actorOf(FromConfig.props(), "router19")
+    //#scatter-gather-group-1
+
+    //#scatter-gather-group-2
+    val router20: ActorRef =
+      context.actorOf(ScatterGatherFirstCompletedGroup(
+        paths,
+        within = 10.seconds).props(), "router20")
+    //#scatter-gather-group-2
+
+    //#tail-chopping-pool-1
+    val router21: ActorRef =
+      context.actorOf(FromConfig.props(Props[Worker]), "router21")
+    //#tail-chopping-pool-1
+
+    //#tail-chopping-pool-2
+    val router22: ActorRef =
+      context.actorOf(TailChoppingPool(5, within = 10.seconds, interval = 20.millis).
+        props(Props[Worker]), "router22")
+    //#tail-chopping-pool-2
+
+    //#tail-chopping-group-1
+    val router23: ActorRef =
+      context.actorOf(FromConfig.props(), "router23")
+    //#tail-chopping-group-1
+
+    //#tail-chopping-group-2
+    val router24: ActorRef =
+      context.actorOf(TailChoppingGroup(
+        paths,
+        within = 10.seconds, interval = 20.millis).props(), "router24")
+    //#tail-chopping-group-2
+
+    //#consistent-hashing-pool-1
+    val router25: ActorRef =
+      context.actorOf(FromConfig.props(Props[Worker]), "router25")
+    //#consistent-hashing-pool-1
+
+    //#consistent-hashing-pool-2
+    val router26: ActorRef =
+      context.actorOf(
+        ConsistentHashingPool(5).props(Props[Worker]),
+        "router26")
+    //#consistent-hashing-pool-2
+
+    //#consistent-hashing-group-1
+    val router27: ActorRef =
+      context.actorOf(FromConfig.props(), "router27")
+    //#consistent-hashing-group-1
+
+    //#consistent-hashing-group-2
+    val router28: ActorRef =
+      context.actorOf(ConsistentHashingGroup(paths).props(), "router28")
+    //#consistent-hashing-group-2
+
+    //#resize-pool-1
+    val router29: ActorRef =
+      context.actorOf(FromConfig.props(Props[Worker]), "router29")
+    //#resize-pool-1
+
+    //#resize-pool-2
+    val resizer = DefaultResizer(lowerBound = 2, upperBound = 15)
+    val router30: ActorRef =
+      context.actorOf(
+        RoundRobinPool(5, Some(resizer)).props(Props[Worker]),
+        "router30")
+    //#resize-pool-2
+
+    //#optimal-size-exploring-resize-pool
+    val router31: ActorRef =
+      context.actorOf(FromConfig.props(Props[Worker]), "router31")
+    //#optimal-size-exploring-resize-pool
+
+    def receive = {
+      case _ =>
+    }
+
+  }
+
+  class Echo extends Actor {
+    def receive = {
+      case m => sender() ! m
+    }
+  }
+}
+
+class RouterDocSpec extends AkkaSpec(RouterDocSpec.config) with ImplicitSender {
+
+  import RouterDocSpec._
+
+  //#create-workers
+  system.actorOf(Props[Workers], "workers")
+  //#create-workers
+
+  //#create-parent
+  system.actorOf(Props[Parent], "parent")
+  //#create-parent
+
+  "demonstrate dispatcher" in {
+    //#dispatchers
+    val router: ActorRef = system.actorOf(
+      // “head” router actor will run on "router-dispatcher" dispatcher
+      // Worker routees will run on "pool-dispatcher" dispatcher
+      RandomPool(5, routerDispatcher = "router-dispatcher").props(Props[Worker]),
+      name = "poolWithDispatcher")
+    //#dispatchers
+  }
+
+  "demonstrate broadcast" in {
+    val router = system.actorOf(RoundRobinPool(nrOfInstances = 5).props(Props[Echo]))
+    //#broadcastDavyJonesWarning
+    import akka.routing.Broadcast
+    router ! Broadcast("Watch out for Davy Jones' locker")
+    //#broadcastDavyJonesWarning
+    receiveN(5, 5.seconds.dilated) should have length (5)
+  }
+
+  "demonstrate PoisonPill" in {
+    val router = watch(system.actorOf(RoundRobinPool(nrOfInstances = 5).props(Props[Echo])))
+    //#poisonPill
+    import akka.actor.PoisonPill
+    router ! PoisonPill
+    //#poisonPill
+    expectTerminated(router)
+  }
+
+  "demonstrate broadcast of PoisonPill" in {
+    val router = watch(system.actorOf(RoundRobinPool(nrOfInstances = 5).props(Props[Echo])))
+    //#broadcastPoisonPill
+    import akka.actor.PoisonPill
+    import akka.routing.Broadcast
+    router ! Broadcast(PoisonPill)
+    //#broadcastPoisonPill
+    expectTerminated(router)
+  }
+
+  "demonstrate Kill" in {
+    val router = watch(system.actorOf(RoundRobinPool(nrOfInstances = 5).props(Props[Echo])))
+    //#kill
+    import akka.actor.Kill
+    router ! Kill
+    //#kill
+    expectTerminated(router)
+  }
+
+  "demonstrate broadcast of Kill" in {
+    val router = watch(system.actorOf(RoundRobinPool(nrOfInstances = 5).props(Props[Echo])))
+    //#broadcastKill
+    import akka.actor.Kill
+    import akka.routing.Broadcast
+    router ! Broadcast(Kill)
+    //#broadcastKill
+    expectTerminated(router)
+  }
+
+  "demonstrate remote deploy" in {
+    //#remoteRoutees
+    import akka.actor.{ Address, AddressFromURIString }
+    import akka.remote.routing.RemoteRouterConfig
+    val addresses = Seq(
+      Address("akka.tcp", "remotesys", "otherhost", 1234),
+      AddressFromURIString("akka.tcp://othersys@anotherhost:1234"))
+    val routerRemote = system.actorOf(
+      RemoteRouterConfig(RoundRobinPool(5), addresses).props(Props[Echo]))
+    //#remoteRoutees
+  }
+
+  // only compile test
+  def demonstrateRemoteDeployWithArtery(): Unit = {
+    //#remoteRoutees-artery
+    import akka.actor.{ Address, AddressFromURIString }
+    import akka.remote.routing.RemoteRouterConfig
+    val addresses = Seq(
+      Address("akka", "remotesys", "otherhost", 1234),
+      AddressFromURIString("akka://othersys@anotherhost:1234"))
+    val routerRemote = system.actorOf(
+      RemoteRouterConfig(RoundRobinPool(5), addresses).props(Props[Echo]))
+    //#remoteRoutees-artery
+  }
+}