TestProbe

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

abstract def expectMessage[T <: M](max: FiniteDuration, 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: FiniteDuration, 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

abstract def expectNoMessage(): Unit

Assert that no message is received.

abstract def expectNoMessage(max: FiniteDuration): Unit

Assert that no message is received for the specified time.

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

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

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

abstract def ref: typed.ActorRef[M]

ActorRef for this TestProbe

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

abstract def remainingOr(duration: FiniteDuration): FiniteDuration

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

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

implicit abstract def settings: TestKitSettings

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

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 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 expectMessageType[T <: M](max: FiniteDuration)(implicit t: ClassTag[T]): T

Expect a message of type T to arrive within max or fail.

def expectMessageType[T <: M](implicit t: ClassTag[T]): T

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

def finalize(): Unit

def fishForMessage(max: FiniteDuration)(fisher: (M) ⇒ FishingOutcome): Seq[M]

Same as the other fishForMessage but with no hint

def fishForMessage(max: FiniteDuration, hint: String)(fisher: (M) ⇒ FishingOutcome): Seq[M]

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 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: 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
  expectMessageType[Pong]
}

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