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/pattern/BackoffSupervisorDocSpec.scala

@@ -0,0 +1,102 @@
+/**
+ * Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
+ */
+
+package docs.pattern
+
+import akka.actor.{ ActorSystem, Props, OneForOneStrategy, SupervisorStrategy }
+import akka.pattern.{ Backoff, BackoffSupervisor }
+import akka.testkit.TestActors.EchoActor
+
+class BackoffSupervisorDocSpec {
+
+  class BackoffSupervisorDocSpecExampleStop {
+    val system: ActorSystem = ???
+    import scala.concurrent.duration._
+
+    //#backoff-stop
+    val childProps = Props(classOf[EchoActor])
+
+    val supervisor = BackoffSupervisor.props(
+      Backoff.onStop(
+        childProps,
+        childName = "myEcho",
+        minBackoff = 3.seconds,
+        maxBackoff = 30.seconds,
+        randomFactor = 0.2 // adds 20% "noise" to vary the intervals slightly
+      ))
+
+    system.actorOf(supervisor, name = "echoSupervisor")
+    //#backoff-stop
+  }
+
+  class BackoffSupervisorDocSpecExampleFail {
+    val system: ActorSystem = ???
+    import scala.concurrent.duration._
+
+    //#backoff-fail
+    val childProps = Props(classOf[EchoActor])
+
+    val supervisor = BackoffSupervisor.props(
+      Backoff.onFailure(
+        childProps,
+        childName = "myEcho",
+        minBackoff = 3.seconds,
+        maxBackoff = 30.seconds,
+        randomFactor = 0.2 // adds 20% "noise" to vary the intervals slightly
+      ))
+
+    system.actorOf(supervisor, name = "echoSupervisor")
+    //#backoff-fail
+  }
+
+  class BackoffSupervisorDocSpecExampleStopOptions {
+    val system: ActorSystem = ???
+    import scala.concurrent.duration._
+
+    val childProps = Props(classOf[EchoActor])
+
+    //#backoff-custom-stop
+    val supervisor = BackoffSupervisor.props(
+      Backoff.onStop(
+      childProps,
+      childName = "myEcho",
+      minBackoff = 3.seconds,
+      maxBackoff = 30.seconds,
+      randomFactor = 0.2 // adds 20% "noise" to vary the intervals slightly
+    ).withManualReset // the child must send BackoffSupervisor.Reset to its parent
+      .withDefaultStoppingStrategy // Stop at any Exception thrown
+    )
+    //#backoff-custom-stop
+
+    system.actorOf(supervisor, name = "echoSupervisor")
+  }
+
+  class BackoffSupervisorDocSpecExampleFailureOptions {
+    val system: ActorSystem = ???
+    import scala.concurrent.duration._
+
+    val childProps = Props(classOf[EchoActor])
+
+    //#backoff-custom-fail
+    val supervisor = BackoffSupervisor.props(
+      Backoff.onFailure(
+        childProps,
+        childName = "myEcho",
+        minBackoff = 3.seconds,
+        maxBackoff = 30.seconds,
+        randomFactor = 0.2 // adds 20% "noise" to vary the intervals slightly
+      ).withAutoReset(10.seconds) // reset if the child does not throw any errors within 10 seconds
+        .withSupervisorStrategy(
+          OneForOneStrategy() {
+            case _: MyException => SupervisorStrategy.Restart
+            case _              => SupervisorStrategy.Escalate
+          }))
+    //#backoff-custom-fail
+
+    system.actorOf(supervisor, name = "echoSupervisor")
+  }
+
+  case class MyException(msg: String) extends Exception(msg)
+
+}

akka-docs/src/test/scala/docs/pattern/SchedulerPatternSpec.scala

@@ -0,0 +1,101 @@
+/**
+ * Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
+ */
+
+package docs.pattern
+
+import language.postfixOps
+
+import akka.actor.{ Props, ActorRef, Actor }
+import scala.concurrent.duration._
+import akka.testkit.{ TimingTest, AkkaSpec, filterException }
+import docs.pattern.SchedulerPatternSpec.ScheduleInConstructor
+
+object SchedulerPatternSpec {
+  //#schedule-constructor
+  class ScheduleInConstructor extends Actor {
+    import context.dispatcher
+    val tick =
+      context.system.scheduler.schedule(500 millis, 1000 millis, self, "tick")
+    //#schedule-constructor
+    // this var and constructor is declared here to not show up in the docs
+    var target: ActorRef = null
+    def this(target: ActorRef) = { this(); this.target = target }
+    //#schedule-constructor
+
+    override def postStop() = tick.cancel()
+
+    def receive = {
+      case "tick" =>
+        // do something useful here
+        //#schedule-constructor
+        target ! "tick"
+      case "restart" =>
+        throw new ArithmeticException
+      //#schedule-constructor
+    }
+  }
+  //#schedule-constructor
+
+  //#schedule-receive
+  class ScheduleInReceive extends Actor {
+    import context._
+    //#schedule-receive
+    // this var and constructor is declared here to not show up in the docs
+    var target: ActorRef = null
+    def this(target: ActorRef) = { this(); this.target = target }
+    //#schedule-receive
+
+    override def preStart() =
+      system.scheduler.scheduleOnce(500 millis, self, "tick")
+
+    // override postRestart so we don't call preStart and schedule a new message
+    override def postRestart(reason: Throwable) = {}
+
+    def receive = {
+      case "tick" =>
+        // send another periodic tick after the specified delay
+        system.scheduler.scheduleOnce(1000 millis, self, "tick")
+        // do something useful here
+        //#schedule-receive
+        target ! "tick"
+      case "restart" =>
+        throw new ArithmeticException
+      //#schedule-receive
+    }
+  }
+  //#schedule-receive
+}
+
+class SchedulerPatternSpec extends AkkaSpec {
+
+  def testSchedule(actor: ActorRef, startDuration: FiniteDuration,
+                   afterRestartDuration: FiniteDuration) = {
+
+    filterException[ArithmeticException] {
+      within(startDuration) {
+        expectMsg("tick")
+        expectMsg("tick")
+        expectMsg("tick")
+      }
+      actor ! "restart"
+      within(afterRestartDuration) {
+        expectMsg("tick")
+        expectMsg("tick")
+      }
+      system.stop(actor)
+    }
+  }
+
+  "send periodic ticks from the constructor" taggedAs TimingTest in {
+    testSchedule(
+      system.actorOf(Props(classOf[ScheduleInConstructor], testActor)),
+      3000 millis, 2000 millis)
+  }
+
+  "send ticks from the preStart and receive" taggedAs TimingTest in {
+    testSchedule(
+      system.actorOf(Props(classOf[ScheduleInConstructor], testActor)),
+      3000 millis, 2500 millis)
+  }
+}