Probe

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (Probe[T], B)

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def cancel(): Self

def clone(): AnyRef

def ensureSubscription(): Self

Asserts that a subscription has been received or will be received

def ensuring(cond: (Probe[T]) ⇒ Boolean, msg: ⇒ Any): Probe[T]

def ensuring(cond: (Probe[T]) ⇒ Boolean): Probe[T]

def ensuring(cond: Boolean, msg: ⇒ Any): Probe[T]

def ensuring(cond: Boolean): Probe[T]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def expectComplete(): Self

Fluent DSL

def expectError(cause: Throwable): Self

Fluent DSL

def expectError(): Throwable

Expect and return the signalled Throwable.

def expectEvent(event: SubscriberEvent): Self

Fluent DSL

def expectEvent(max: FiniteDuration): SubscriberEvent

Expect and return SubscriberEvent (any of: OnSubscribe, OnNext, OnError or OnComplete).

def expectEvent(): SubscriberEvent

Expect and return SubscriberEvent (any of: OnSubscribe, OnNext, OnError or OnComplete).

def expectEventPF[T](f: PartialFunction[SubscriberEvent, T]): T

def expectEventWithTimeoutPF[T](max: Duration, f: PartialFunction[SubscriberEvent, T]): T

def expectNext(e1: T, e2: T, es: T*): Self

Fluent DSL

def expectNext(d: FiniteDuration, element: T): Self

Fluent DSL

def expectNext(element: T): Self

Fluent DSL

def expectNext(d: FiniteDuration): T

Expect and return a stream element during specified time or timeout.

def expectNext(): T

Expect and return a stream element.

def expectNextChainingPF(f: PartialFunction[Any, Any]): Self

Expect a stream element during specified time or timeout and test it with partial function.

def expectNextChainingPF(max: Duration, f: PartialFunction[Any, Any]): Self

Expect a stream element during specified time or timeout and test it with partial function.

def expectNextN(all: Seq[T]): Self

Fluent DSL Expect the given elements to be signalled in order.

def expectNextN(n: Long): Seq[T]

Expect and return the next n stream elements.

def expectNextOrComplete(element: T): Self

Fluent DSL

def expectNextOrComplete(): Either[OnComplete.type, T]

Expect next element or stream completion - returning whichever was signalled.

def expectNextOrError(element: T, cause: Throwable): Either[Throwable, T]

Fluent DSL Expect given next element or error signal.

def expectNextOrError(): Either[Throwable, T]

Fluent DSL

def expectNextPF[T](f: PartialFunction[Any, T]): T

Expect a stream element and test it with partial function.

def expectNextUnordered(e1: T, e2: T, es: T*): Self

Fluent DSL

def expectNextUnorderedN(all: Seq[T]): Self

Fluent DSL Expect the given elements to be signalled in any order.

def expectNextWithTimeoutPF[T](max: Duration, f: PartialFunction[Any, T]): T

Expect a stream element and test it with partial function.

def expectNoMessage(remaining: Duration): Self

Java API: Assert that no message is received for the specified time.

def expectNoMessage(remaining: FiniteDuration): Self

Fluent DSL

def expectSubscription(): Subscription

Expect and return a org.reactivestreams.Subscription.

def expectSubscriptionAndComplete(signalDemand: Boolean): Self

Fluent DSL

def expectSubscriptionAndComplete(): Self

Fluent DSL

def expectSubscriptionAndError(cause: Throwable, signalDemand: Boolean): Self

Fluent DSL

def expectSubscriptionAndError(cause: Throwable): Self

Fluent DSL

def expectSubscriptionAndError(signalDemand: Boolean): Throwable

Expect subscription to be followed immediately by an error signal.

def expectSubscriptionAndError(): Throwable

Expect subscription to be followed immediately by an error signal.

def finalize(): Unit

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

def onComplete(): Unit

def onError(cause: Throwable): Unit

def onNext(element: T): Unit

def onSubscribe(subscription: Subscription): Unit

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

Receive messages for a given duration or until one does not match a given partial function.

def receiveWithin(max: FiniteDuration, messages: Int = Int.MaxValue): Seq[T]

Drains a given number of messages

def request(n: Long): Self

def requestNext(d: FiniteDuration): T

Request and expect a stream element during the specified time or timeout.

def requestNext(): T

Request and expect a stream element.

def requestNext(element: T): Self

Request and expect a stream element.

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

def toStrict(atMost: FiniteDuration): Seq[T]

Attempt to drain the stream into a strict collection (by requesting Long.MaxValue elements).

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"
  expectMsgClass(classOf[String])
}

def →[B](y: B): (Probe[T], B)

def expectNoMsg(remaining: FiniteDuration): Self

Fluent DSL

def expectNoMsg(): Self

Fluent DSL