TestKit

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def awaitAssert[A](max: Duration, interval: Duration, a: Supplier[A]): A

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

def awaitAssert[A](max: Duration, a: Supplier[A]): A

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

def awaitAssert[A](a: Supplier[A]): A

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

def awaitCond(max: Duration, interval: Duration, message: String, p: Supplier[Boolean]): Unit

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

def awaitCond(max: Duration, interval: Duration, p: Supplier[Boolean]): Unit

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

def awaitCond(max: Duration, p: Supplier[Boolean]): Unit

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

def awaitCond(p: Supplier[Boolean]): 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 dilated(duration: Duration): Duration

Java timeouts (durations) during tests with the configured

def duration(s: String): FiniteDuration

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

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

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

def ensuring(cond: Boolean): TestKit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

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

def expectMsg[T](max: Duration, 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 expectMsgAllOf[T](max: Duration, objs: T*): List[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.

def expectMsgAllOf[T](objs: T*): List[T]

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

def expectMsgAnyClassOf[T](max: Duration, objs: Class[_]*): T

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

def expectMsgAnyClassOf[T](objs: Class[_]*): T

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

def expectMsgAnyOf[T](max: Duration, objs: T*): T

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

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

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

def expectMsgClass[T](max: Duration, c: Class[T]): T

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

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

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

def expectMsgEquals[T](max: Duration, obj: T): T

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

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

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

def expectMsgPF[T](max: Duration, hint: String, f: Function[Any, T]): T

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

def expectMsgPF[T](max: Duration, hint: String, f: Function[Any, T]): T

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

def expectMsgPF[T](hint: String, f: Function[Any, T]): T

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

def expectNoMessage(max: Duration): Unit

Assert that no message is received for the specified time.

def expectNoMessage(): Unit

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

def expectTerminated(target: ActorRef): Terminated

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

def expectTerminated(max: Duration, target: ActorRef): Terminated

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

def expectTerminated(max: Duration, target: ActorRef): 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, hint: String, f: Function[Any, Boolean]): Any

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

def fishForSpecificMessage[T](max: Duration, hint: String, f: Function[Any, T]): T

Same as fishForMessage, but gets a different partial function and returns properly typed message.

def formatted(fmtstr: String): String

def forward(actor: ActorRef): Unit

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

final def getClass(): Class[_]

def getLastSender: ActorRef

Get the last sender of the TestProbe

def getRef: ActorRef

Shorthand to get the testActor.

def getRemaining: Duration

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

def getRemainingOr(duration: Duration): Duration

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

def getRemainingOrDefault: Duration

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 getSystem: ActorSystem

def getTestActor: ActorRef

ActorRef of the test actor.

def hashCode(): Int

def ignoreMsg(pf: Function[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 msgAvailable: Boolean

Query queue status.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def receiveN(n: Int, max: Duration): List[AnyRef]

Receive N messages in a row before the given deadline.

def receiveN(n: Int): List[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, f: Function[AnyRef, T]): List[T]

def receiveWhile[T](max: Duration, idle: Duration, messages: Int, f: Function[AnyRef, T]): List[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.

def reply(msg: AnyRef): Unit

Send message to the sender of the last dequeued message.

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

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

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.

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

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: Duration, f: Supplier[T]): T

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

within(java.time.Duration.ofMillis(50), () -> {
  test.tell("ping");
  return expectMsgClass(String.class);
});

def within[T](min: Duration, max: Duration, f: Supplier[T]): T

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

within(java.time.Duration.ofMillis(50), () -> {
  test.tell("ping");
  return expectMsgClass(String.class);
});

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

def awaitAssert[A](max: Duration, interval: Duration, a: Supplier[A]): A

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

def awaitAssert[A](max: Duration, a: Supplier[A]): A

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

def awaitCond(max: Duration, interval: Duration, message: String, p: Supplier[Boolean]): Unit

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

def awaitCond(max: Duration, interval: Duration, p: Supplier[Boolean]): Unit

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

def awaitCond(max: Duration, p: Supplier[Boolean]): Unit

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

def dilated(d: FiniteDuration): FiniteDuration

Scale timeouts (durations) during tests with the configured

def expectMsg[T](max: FiniteDuration, obj: T, hint: String): 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 expectMsgAllOf[T](max: FiniteDuration, objs: T*): List[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.

def expectMsgAnyClassOf[T](max: FiniteDuration, objs: Class[_]*): T

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

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

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

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

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

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

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

def expectNoMessage(max: FiniteDuration): Unit

Assert that no message is received for the specified time.

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.

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

Receive N messages in a row before the given deadline.

def receiveOne(max: Duration): AnyRef

Receive one message from the internal queue of the TestActor.

def receiveWhile[T](max: Duration, f: Function[AnyRef, T]): List[T]

def receiveWhile[T](max: Duration, idle: Duration, messages: Int, f: Function[AnyRef, T]): List[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.

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(fd: 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 within[T](max: FiniteDuration, f: Supplier[T]): T

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

within(duration("50 millis"), () -> {
  test.tell("ping");
  return expectMsgClass(String.class);
});

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

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

within(duration("50 millis"), () -> {
  test.tell("ping");
  return expectMsgClass(String.class);
});