TestProbe

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (TestProbe, B)

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def awaitAssert[A](a: ⇒ A, max: Duration = Duration.Undefined, interval: Duration = 100.millis): A

Evaluate the given assert every interval until it does not throw an exception and return the result.

def awaitCond(p: ⇒ Boolean, max: Duration = Duration.Undefined, interval: Duration = 100.millis, message: String = ""): Unit

Await until the given condition evaluates to true or the timeout expires, whichever comes first.

def childActorOf(props: Props): ActorRef

Spawns an actor as a child of this test actor with an auto-generated name and stopping supervisor strategy, returning the child's ActorRef.

def childActorOf(props: Props, name: String): ActorRef

Spawns an actor as a child of this test actor with a stopping supervisor strategy, and returns the child's ActorRef.

def childActorOf(props: Props, supervisorStrategy: SupervisorStrategy): ActorRef

Spawns an actor as a child of this test actor with an auto-generated name, and returns the child's ActorRef.

def childActorOf(props: Props, name: String, supervisorStrategy: SupervisorStrategy): ActorRef

Spawns an actor as a child of this test actor, and returns the child's ActorRef.

def clone(): AnyRef

def ensuring(cond: (TestProbe) ⇒ Boolean, msg: ⇒ Any): TestProbe

def ensuring(cond: (TestProbe) ⇒ Boolean): TestProbe

def ensuring(cond: Boolean, msg: ⇒ Any): TestProbe

def ensuring(cond: Boolean): TestProbe

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def expectMsg[T](max: FiniteDuration, hint: String, obj: T): T

Receive one message from the test actor and assert that it equals the given object.

def expectMsg[T](max: FiniteDuration, obj: T): T

Receive one message from the test actor and assert that it equals the given object.

def expectMsg[T](obj: T): T

Same as expectMsg(remainingOrDefault, obj), but correctly treating the timeFactor.

def expectMsgAllClassOf[T](max: FiniteDuration, obj: Class[_ <: T]*): Seq[T]

Receive a number of messages from the test actor matching the given number of classes and assert that for each given class one is received which is of that class (equality, not conformance).

def expectMsgAllClassOf[T](obj: Class[_ <: T]*): Seq[T]

Same as expectMsgAllClassOf(remainingOrDefault, obj...), but correctly treating the timeFactor.

def expectMsgAllConformingOf[T](max: FiniteDuration, obj: Class[_ <: T]*): Seq[T]

Receive a number of messages from the test actor matching the given number of classes and assert that for each given class one is received which conforms to that class (and vice versa).

def expectMsgAllConformingOf[T](obj: Class[_ <: T]*): Seq[T]

Same as expectMsgAllConformingOf(remainingOrDefault, obj...), but correctly treating the timeFactor.

def expectMsgAllOf[T](max: FiniteDuration, obj: T*): Seq[T]

Receive a number of messages from the test actor matching the given number of objects and assert that for each given object one is received which equals it and vice versa.

  dispatcher ! SomeWork1()
  dispatcher ! SomeWork2()
  expectMsgAllOf(1 second, Result1(), Result2())

def expectMsgAllOf[T](obj: T*): Seq[T]

Same as expectMsgAllOf(remainingOrDefault, obj...), but correctly treating the timeFactor.

def expectMsgAnyClassOf[C](max: FiniteDuration, obj: Class[_ <: C]*): C

Receive one message from the test actor and assert that it conforms to one of the given classes.

def expectMsgAnyClassOf[C](obj: Class[_ <: C]*): C

Same as expectMsgAnyClassOf(remainingOrDefault, obj...), but correctly treating the timeFactor.

def expectMsgAnyOf[T](max: FiniteDuration, obj: T*): T

Receive one message from the test actor and assert that it equals one of the given objects.

def expectMsgAnyOf[T](obj: T*): T

Same as expectMsgAnyOf(remainingOrDefault, obj...), but correctly treating the timeFactor.

def expectMsgClass[C](max: FiniteDuration, c: Class[C]): C

Receive one message from the test actor and assert that it conforms to the given class.

def expectMsgClass[C](c: Class[C]): C

Same as expectMsgClass(remainingOrDefault, c), but correctly treating the timeFactor.

def expectMsgPF[T](max: Duration = Duration.Undefined, hint: String = "")(f: PartialFunction[Any, T]): T

Receive one message from the test actor and assert that the given partial function accepts it.

def expectMsgType[T](max: FiniteDuration)(implicit t: ClassTag[T]): T

Receive one message from the test actor and assert that it conforms to the given type (after erasure).

def expectMsgType[T](implicit t: ClassTag[T]): T

Same as expectMsgType[T](remainingOrDefault), but correctly treating the timeFactor.

def expectNoMessage(): Unit

Same as expectNoMessage(remainingOrDefault), but correctly treating the timeFactor.

def expectNoMessage(max: FiniteDuration): Unit

Assert that no message is received for the specified time.

def expectTerminated(target: ActorRef, max: Duration = Duration.Undefined): Terminated

Receive one message from the test actor and assert that it is the Terminated message of the given ActorRef.

def finalize(): Unit

def fishForMessage(max: Duration = Duration.Undefined, hint: String = "")(f: PartialFunction[Any, Boolean]): Any

Hybrid of expectMsgPF and receiveWhile: receive messages while the partial function matches and returns false.

def fishForSpecificMessage[T](max: Duration = Duration.Undefined, hint: String = "")(f: PartialFunction[Any, T]): T

Waits for specific message that partial function matches while ignoring all other messages coming in the meantime.

def formatted(fmtstr: String): String

def forward(actor: ActorRef, msg: Any = lastMessage.msg): Unit

Forward this message as if in the TestActor's receive method with self.forward.

final def getClass(): Class[_]

def hashCode(): Int

def ignoreMsg(f: PartialFunction[Any, Boolean]): Unit

Ignore all messages in the test actor for which the given partial function returns true.

def ignoreNoMsg(): Unit

Stop ignoring messages in the test actor.

final def isInstanceOf[T0]: Boolean

def lastSender: ActorRef

def msgAvailable: Boolean

Query queue status.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def now: FiniteDuration

Obtain current time (System.nanoTime) as Duration.

def receiveN(n: Int, max: FiniteDuration): Seq[AnyRef]

Receive N messages in a row before the given deadline.

def receiveN(n: Int): Seq[AnyRef]

Same as receiveN(n, remaining) but correctly taking into account Duration.timeFactor.

def receiveOne(max: Duration): AnyRef

Receive one message from the internal queue of the TestActor.

def receiveWhile[T](max: Duration = Duration.Undefined, idle: Duration = Duration.Inf, messages: Int = Int.MaxValue)(f: PartialFunction[AnyRef, T]): Seq[T]

Receive a series of messages until one does not match the given partial function or the idle timeout is met (disabled by default) or the overall maximum duration is elapsed or expected messages count is reached.

test ! ScheduleTicks(100 millis)
val series = receiveWhile(750 millis) {
    case Tick(count) => count
}
assert(series == (1 to 7).toList)

def ref: ActorRef

Shorthand to get the testActor.

def remaining: FiniteDuration

Obtain time remaining for execution of the innermost enclosing within block or throw an AssertionError if no within block surrounds this call.

def remainingOr(duration: FiniteDuration): FiniteDuration

Obtain time remaining for execution of the innermost enclosing within block or missing that it returns the given duration.

def remainingOrDefault: FiniteDuration

Obtain time remaining for execution of the innermost enclosing within block or missing that it returns the properly dilated default for this case from settings (key "akka.test.single-expect-default").

def reply(msg: Any): Unit

Send message to the sender of the last dequeued message.

def send(actor: ActorRef, msg: Any): Unit

Send message to an actor while using the probe's TestActor as the sender.

def sender(): ActorRef

Get sender of last received message.

def setAutoPilot(pilot: AutoPilot): Unit

Install an AutoPilot to drive the testActor: the AutoPilot will be run for each received message and can be used to send or forward messages, etc.

def shutdown(actorSystem: ActorSystem = system, duration: Duration = 10.seconds.dilated.min(10.seconds), verifySystemShutdown: Boolean = false): Unit

Shut down an actor system and wait for termination.

final def synchronized[T0](arg0: ⇒ T0): T0

implicit val system: ActorSystem

val testActor: ActorRef

ActorRef of the test actor.

def testActorName: String

Defines the testActor name.

val testKitSettings: TestKitSettings

def toString(): String

def unwatch(ref: ActorRef): ActorRef

Have the testActor stop watching someone (i.e.

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def watch(ref: ActorRef): ActorRef

Have the testActor watch someone (i.e.

def within[T](max: FiniteDuration)(f: ⇒ T): T

Same as calling within(0 seconds, max)(f).

def within[T](min: FiniteDuration, max: FiniteDuration)(f: ⇒ T): T

Execute code block while bounding its execution time between min and max.

val ret = within(50 millis) {
  test ! "ping"
  expectMsgClass(classOf[String])
}

def →[B](y: B): (TestProbe, B)

def expectNoMsg(max: FiniteDuration): Unit

Assert that no message is received for the specified time.

def expectNoMsg(): Unit

Same as expectNoMsg(remainingOrDefault), but correctly treating the timeFactor.