TestProbe

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

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

abstract def expectMessage[T <: M](max: Duration, hint: String, obj: T): T

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

abstract def expectMessage[T <: M](max: Duration, obj: T): T

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

abstract def expectMessage[T <: M](obj: T): T

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

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

INTERNAL API

abstract def expectNoMessage(): Unit

Assert that no message is received.

abstract def expectNoMessage(max: Duration): Unit

Assert that no message is received for the specified time.

abstract def expectTerminated[U](actorRef: typed.ActorRef[U], max: Duration): Unit

Expect the given actor to be stopped or stop within the given timeout or throw an AssertionError.

abstract def fishForMessage_internal(max: FiniteDuration, hint: String, fisher: (M) ⇒ FishingOutcome): List[M]

INTERNAL API

abstract 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.

abstract def getRemainingOr(duration: Duration): Duration

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

abstract 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.actor.testkit.typed.single-expect-default").

abstract def ref: typed.ActorRef[M]

ActorRef for this TestProbe

implicit abstract def settings: TestKitSettings

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

INTERNAL API

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

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

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

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

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

def clone(): AnyRef

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

def ensuring(cond: (TestProbe[M]) ⇒ Boolean): TestProbe[M]

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

def ensuring(cond: Boolean): TestProbe[M]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def expectMessageClass[T](clazz: Class[T], max: Duration): T

Wait for a message of type M and return it when it arrives, or fail if the max timeout is hit.

def expectMessageClass[T](clazz: Class[T]): T

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

def finalize(): Unit

def fishForMessage(max: Duration, hint: String, fisher: Function[M, FishingOutcome]): List[M]

Same as the other fishForMessageJava but includes the provided hint in all error messages

def fishForMessage(max: Duration, fisher: Function[M, FishingOutcome]): List[M]

Java API: Allows for flexible matching of multiple messages within a timeout, the fisher function is fed each incoming message, and returns one of the following effects to decide on what happens next:

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def getRef(): typed.ActorRef[M]

ActorRef for this TestProbe

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

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

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

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

val ret = within(50 millis) {
  test ! Ping
  expectMessageType[Pong]
}

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