io.reactivex.observers

Class TestObserver<T>

java.lang.Object

io.reactivex.observers.TestObserver<T>

Type Parameters:

T - the value type

All Implemented Interfaces:

CompletableObserver, Disposable, MaybeObserver<T>, Observer<T>, SingleObserver<T>

public class TestObserver<T>
extends java.lang.Object
implements Observer<T>, Disposable, MaybeObserver<T>, SingleObserver<T>, CompletableObserver

An Observer that records events and allows making assertions about them.

You can override the onSubscribe, onNext, onError, onComplete, onSuccess and cancel methods but not the others (this is by design).

The TestObserver implements Disposable for convenience where dispose calls cancel.

Constructor Summary

Constructors

Constructor and Description
TestObserver() Constructs a non-forwarding TestObserver.
TestObserver(Observer<? super T> actual) Constructs a forwarding TestObserver.

Method Summary

Methods

Modifier and Type	Method and Description
TestObserver<T>	assertComplete() Assert that this TestObserver received exactly one onComplete event.
TestObserver<T>	assertEmpty() Assert that the TestObserver has received a Disposable but no other events.
TestObserver<T>	assertError(java.lang.Class<? extends java.lang.Throwable> errorClass) Asserts that this TestObserver received exactly one onError event which is an instance of the specified errorClass class.
TestObserver<T>	assertError(Predicate<java.lang.Throwable> errorPredicate) Asserts that this TestObserver received exactly one onError event for which the provided predicate returns true.
TestObserver<T>	assertError(java.lang.Throwable error) Assert that this TestObserver received exactly the specified onError event value.
TestObserver<T>	assertErrorMessage(java.lang.String message) Assert that there is a single error and it has the given message.
TestObserver<T>	assertFailure(java.lang.Class<? extends java.lang.Throwable> error, T... values) Assert that the upstream signalled the specified values in order and then failed with a specific class or subclass of Throwable.
TestObserver<T>	assertFailure(Predicate<java.lang.Throwable> errorPredicate, T... values) Assert that the upstream signalled the specified values in order and then failed with a Throwable for which the provided predicate returns true.
TestObserver<T>	assertFailureAndMessage(java.lang.Class<? extends java.lang.Throwable> error, java.lang.String message, T... values) Assert that the upstream signalled the specified values in order, then failed with a specific class or subclass of Throwable and with the given exact error message.
TestObserver<T>	assertNoErrors() Assert that this TestObserver has not received any onError event.
TestObserver<T>	assertNotComplete() Assert that this TestObserver has not received any onComplete event.
TestObserver<T>	assertNotSubscribed() Assert that the onSubscribe method hasn't been called at all.
TestObserver<T>	assertNotTerminated() Assert that the TestObserver has not terminated (i.e., the terminal latch is still non-zero).
TestObserver<T>	assertNoValues() Assert that this TestObserver has not received any onNext events.
TestObserver<T>	assertOf(Consumer<? super TestObserver<T>> check) Run a check consumer with this TestObserver instance.
TestObserver<T>	assertResult(T... values) Assert that the upstream signalled the specified values in order and completed normally.
TestObserver<T>	assertSubscribed() Assert that the onSubscribe method was called exactly once.
TestObserver<T>	assertTerminated() Assert that the TestObserver terminated (i.e., the terminal latch reached zero).
TestObserver<T>	assertValue(T value) Assert that this TestObserver received exactly one onNext value which is equal to the given value with respect to Objects.equals.
TestObserver<T>	assertValueCount(int count) Assert that this TestObserver received the specified number onNext events.
TestObserver<T>	assertValues(T... values) Assert that the TestObserver received only the specified values in the specified order.
TestObserver<T>	assertValueSequence(java.lang.Iterable<? extends T> sequence) Assert that the TestObserver received only the specified sequence of values in the same order.
TestObserver<T>	assertValueSet(java.util.Collection<? extends T> expected) Assert that the TestObserver received only the specified values in any order.
TestObserver<T>	await() Awaits until this TestObserver receives an onError or onComplete events.
boolean	await(long time, java.util.concurrent.TimeUnit unit) Awaits the specified amount of time or until this TestObserver receives an onError or onComplete events, whichever happens first.
TestObserver<T>	awaitDone(long time, java.util.concurrent.TimeUnit unit) Awaits until the internal latch is counted down.
boolean	awaitTerminalEvent() Waits until the any terminal event has been received by this TestObserver or returns false if the wait has been interrupted.
boolean	awaitTerminalEvent(long duration, java.util.concurrent.TimeUnit unit) Awaits the specified amount of time or until this TestObserver receives an onError or onComplete events, whichever happens first.
void	cancel() Cancels the TestObserver (before or after the subscription happened).
long	completions() Returns the number of times onComplete was called.
static <T> TestObserver<T>	create() Constructs a non-forwarding TestObserver.
static <T> TestObserver<T>	create(Observer<? super T> delegate) Constructs a forwarding TestObserver.
void	dispose() Dispose the resource, the operation should be idempotent.
int	errorCount() Returns the number of onError exceptions received.
java.util.List<java.lang.Throwable>	errors() Returns a shared list of received onError exceptions.
java.util.List<java.util.List<java.lang.Object>>	getEvents() Returns a list of 3 other lists: the first inner list contains the plain values received; the second list contains the potential errors and the final list contains the potential completions as Notifications.
boolean	hasSubscription() Returns true if this TestObserver received a subscription.
boolean	isCancelled() Returns true if this TestObserver has been cancelled.
boolean	isDisposed() Returns true if this resource has been disposed.
boolean	isTerminated() Returns true if TestObserver received any onError or onComplete events.
java.lang.Thread	lastThread() Returns the last thread which called the onXXX methods of this TestObserver.
void	onComplete() Notifies the Observer that the Observable has finished sending push-based notifications.
void	onError(java.lang.Throwable t) Notifies the Observer that the Observable has experienced an error condition.
void	onNext(T t) Provides the Observer with a new item to observe.
void	onSubscribe(Disposable s) Provides the Observer with the means of cancelling (disposing) the connection (channel) with the Observable in both synchronous (from within Observer.onNext(Object)) and asynchronous manner.
void	onSuccess(T value) Notifies the MaybeObserver with one item and that the Maybe has finished sending push-based notifications.
int	valueCount() Returns the number of onNext values received.
java.util.List<T>	values() Returns a shared list of received onNext values.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

TestObserver

public TestObserver()

Constructs a non-forwarding TestObserver.

TestObserver

public TestObserver(Observer<? super T> actual)

Constructs a forwarding TestObserver.

Parameters:

actual - the actual Observer to forward events to

Method Detail

create

public static <T> TestObserver<T> create()

Constructs a non-forwarding TestObserver.

Type Parameters:

T - the value type received

Returns:

the new TestObserver instance

create

public static <T> TestObserver<T> create(Observer<? super T> delegate)

Constructs a forwarding TestObserver.

Type Parameters:

T - the value type received

Parameters:

delegate - the actual Observer to forward events to

Returns:

the new TestObserver instance

onSubscribe

public void onSubscribe(Disposable s)

Description copied from interface: Observer

Provides the Observer with the means of cancelling (disposing) the connection (channel) with the Observable in both synchronous (from within Observer.onNext(Object)) and asynchronous manner.

Specified by:

onSubscribe in interface CompletableObserver

Specified by:

onSubscribe in interface MaybeObserver<T>

Specified by:

onSubscribe in interface Observer<T>

Specified by:

onSubscribe in interface SingleObserver<T>

Parameters:

s - the Disposable instance whose Disposable.dispose() can be called anytime to cancel the connection

onNext

public void onNext(T t)

Description copied from interface: Observer

Provides the Observer with a new item to observe.

The Observable may call this method 0 or more times.

The Observable will not call this method again after it calls either Observer.onComplete() or Observer.onError(java.lang.Throwable).

Specified by:

onNext in interface Observer<T>

Parameters:

t - the item emitted by the Observable

onError

public void onError(java.lang.Throwable t)

Description copied from interface: Observer

Notifies the Observer that the Observable has experienced an error condition.

If the Observable calls this method, it will not thereafter call Observer.onNext(T) or Observer.onComplete().

Specified by:

onError in interface CompletableObserver

Specified by:

onError in interface MaybeObserver<T>

Specified by:

onError in interface Observer<T>

Specified by:

onError in interface SingleObserver<T>

Parameters:

t - the exception encountered by the Observable

onComplete

public void onComplete()

Description copied from interface: Observer

Notifies the Observer that the Observable has finished sending push-based notifications.

The Observable will not call this method if it calls Observer.onError(java.lang.Throwable).

Specified by:

onComplete in interface CompletableObserver

Specified by:

onComplete in interface MaybeObserver<T>

Specified by:

onComplete in interface Observer<T>

isCancelled

public final boolean isCancelled()

Returns true if this TestObserver has been cancelled.

Returns:

true if this TestObserver has been cancelled

cancel

public final void cancel()

Cancels the TestObserver (before or after the subscription happened).

This operation is thread-safe.

This method is provided as a convenience when converting Flowable tests that cancel.

dispose

public final void dispose()

Description copied from interface: Disposable

Dispose the resource, the operation should be idempotent.

Specified by:

dispose in interface Disposable

isDisposed

public final boolean isDisposed()

Description copied from interface: Disposable

Returns true if this resource has been disposed.

Specified by:

isDisposed in interface Disposable

Returns:

true if this resource has been disposed

lastThread

public final java.lang.Thread lastThread()

Returns the last thread which called the onXXX methods of this TestObserver.

Returns:

the last thread which called the onXXX methods

values

public final java.util.List<T> values()

Returns a shared list of received onNext values.

Returns:

a list of received onNext values

errors

public final java.util.List<java.lang.Throwable> errors()

Returns a shared list of received onError exceptions.

Returns:

a list of received events onError exceptions

completions

public final long completions()

Returns the number of times onComplete was called.

Returns:

the number of times onComplete was called

isTerminated

public final boolean isTerminated()

Returns true if TestObserver received any onError or onComplete events.

Returns:

true if TestObserver received any onError or onComplete events

valueCount

public final int valueCount()

Returns the number of onNext values received.

Returns:

the number of onNext values received

errorCount

public final int errorCount()

Returns the number of onError exceptions received.

Returns:

the number of onError exceptions received

hasSubscription

public final boolean hasSubscription()

Returns true if this TestObserver received a subscription.

Returns:

true if this TestObserver received a subscription

await

public final TestObserver<T> await()
                            throws java.lang.InterruptedException

Awaits until this TestObserver receives an onError or onComplete events.

Returns:

this

Throws:

java.lang.InterruptedException - if the current thread is interrupted while waiting

See Also:

awaitTerminalEvent()

await

public final boolean await(long time,
            java.util.concurrent.TimeUnit unit)
                    throws java.lang.InterruptedException

Awaits the specified amount of time or until this TestObserver receives an onError or onComplete events, whichever happens first.

Parameters:

time - the waiting time

unit - the time unit of the waiting time

Returns:

true if the TestObserver terminated, false if timeout happened

Throws:

java.lang.InterruptedException - if the current thread is interrupted while waiting

See Also:

awaitTerminalEvent(long, TimeUnit)

assertComplete

public final TestObserver<T> assertComplete()

Assert that this TestObserver received exactly one onComplete event.

Returns:

this;

assertNotComplete

public final TestObserver<T> assertNotComplete()

Assert that this TestObserver has not received any onComplete event.

Returns:

this;

assertNoErrors

public final TestObserver<T> assertNoErrors()

Assert that this TestObserver has not received any onError event.

Returns:

this;

assertError

public final TestObserver<T> assertError(java.lang.Throwable error)

Assert that this TestObserver received exactly the specified onError event value.

The comparison is performed via Objects.equals(); since most exceptions don't implement equals(), this assertion may fail. Use the assertError(Class) overload to test against the class of an error instead of an instance of an error or assertError(Predicate) to test with different condition.

Parameters:

error - the error to check

Returns:

this;

See Also:

assertError(Class), assertError(Predicate)

assertError

public final TestObserver<T> assertError(java.lang.Class<? extends java.lang.Throwable> errorClass)

Asserts that this TestObserver received exactly one onError event which is an instance of the specified errorClass class.

Parameters:

errorClass - the error class to expect

Returns:

this;

assertError

public final TestObserver<T> assertError(Predicate<java.lang.Throwable> errorPredicate)

Asserts that this TestObserver received exactly one onError event for which the provided predicate returns true.

Parameters:

errorPredicate - the predicate that receives the error Throwable and should return true for expected errors.

Returns:

this

assertValue

public final TestObserver<T> assertValue(T value)

Assert that this TestObserver received exactly one onNext value which is equal to the given value with respect to Objects.equals.

Parameters:

value - the value to expect

Returns:

this;

assertValueCount

public final TestObserver<T> assertValueCount(int count)

Assert that this TestObserver received the specified number onNext events.

Parameters:

count - the expected number of onNext events

Returns:

this;

assertNoValues

public final TestObserver<T> assertNoValues()

Assert that this TestObserver has not received any onNext events.

Returns:

this;

assertValues

public final TestObserver<T> assertValues(T... values)

Assert that the TestObserver received only the specified values in the specified order.

Parameters:

values - the values expected

Returns:

this;

See Also:

assertValueSet(Collection)

assertValueSet

public final TestObserver<T> assertValueSet(java.util.Collection<? extends T> expected)

Assert that the TestObserver received only the specified values in any order.

This helps asserting when the order of the values is not guaranteed, i.e., when merging asynchronous streams.

Parameters:

expected - the collection of values expected in any order

Returns:

this;

assertValueSequence

public final TestObserver<T> assertValueSequence(java.lang.Iterable<? extends T> sequence)

Assert that the TestObserver received only the specified sequence of values in the same order.

Parameters:

sequence - the sequence of expected values in order

Returns:

this;

assertTerminated

public final TestObserver<T> assertTerminated()

Assert that the TestObserver terminated (i.e., the terminal latch reached zero).

Returns:

this;

assertNotTerminated

public final TestObserver<T> assertNotTerminated()

Assert that the TestObserver has not terminated (i.e., the terminal latch is still non-zero).

Returns:

this;

assertSubscribed

public final TestObserver<T> assertSubscribed()

Assert that the onSubscribe method was called exactly once.

Returns:

this;

assertNotSubscribed

public final TestObserver<T> assertNotSubscribed()

Assert that the onSubscribe method hasn't been called at all.

Returns:

this;

awaitTerminalEvent

public final boolean awaitTerminalEvent()

Waits until the any terminal event has been received by this TestObserver or returns false if the wait has been interrupted.

Returns:

true if the TestObserver terminated, false if the wait has been interrupted

awaitTerminalEvent

public final boolean awaitTerminalEvent(long duration,
                         java.util.concurrent.TimeUnit unit)

Awaits the specified amount of time or until this TestObserver receives an onError or onComplete events, whichever happens first.

Parameters:

duration - the waiting time

unit - the time unit of the waiting time

Returns:

true if the TestObserver terminated, false if timeout or interrupt happened

assertErrorMessage

public final TestObserver<T> assertErrorMessage(java.lang.String message)

Assert that there is a single error and it has the given message.

Parameters:

message - the message expected

Returns:

this

getEvents

public final java.util.List<java.util.List<java.lang.Object>> getEvents()

Returns a list of 3 other lists: the first inner list contains the plain values received; the second list contains the potential errors and the final list contains the potential completions as Notifications.

Returns:

a list of (values, errors, completion-notifications)

assertOf

public final TestObserver<T> assertOf(Consumer<? super TestObserver<T>> check)

Run a check consumer with this TestObserver instance.

Parameters:

check - the check consumer to run

Returns:

this

assertResult

public final TestObserver<T> assertResult(T... values)

Assert that the upstream signalled the specified values in order and completed normally.

Parameters:

values - the expected values, asserted in order

Returns:

this

See Also:

assertFailure(Class, Object...), assertFailure(Predicate, Object...), assertFailureAndMessage(Class, String, Object...)

assertFailure

public final TestObserver<T> assertFailure(java.lang.Class<? extends java.lang.Throwable> error,
                            T... values)

Assert that the upstream signalled the specified values in order and then failed with a specific class or subclass of Throwable.

Parameters:

error - the expected exception (parent) class

values - the expected values, asserted in order

Returns:

this

assertFailure

public final TestObserver<T> assertFailure(Predicate<java.lang.Throwable> errorPredicate,
                            T... values)

Assert that the upstream signalled the specified values in order and then failed with a Throwable for which the provided predicate returns true.

Parameters:

errorPredicate - the predicate that receives the error Throwable and should return true for expected errors.

values - the expected values, asserted in order

Returns:

this

assertFailureAndMessage

public final TestObserver<T> assertFailureAndMessage(java.lang.Class<? extends java.lang.Throwable> error,
                                      java.lang.String message,
                                      T... values)

Assert that the upstream signalled the specified values in order, then failed with a specific class or subclass of Throwable and with the given exact error message.

Parameters:

error - the expected exception (parent) class

message - the expected failure message

values - the expected values, asserted in order

Returns:

this

awaitDone

public final TestObserver<T> awaitDone(long time,
                        java.util.concurrent.TimeUnit unit)

Awaits until the internal latch is counted down.

If the wait times out or gets interrupted, the TestObserver is cancelled.

Parameters:

time - the waiting time

unit - the time unit of the waiting time

Returns:

this

Throws:

java.lang.RuntimeException - wrapping an InterruptedException if the wait is interrupted

assertEmpty

public final TestObserver<T> assertEmpty()

Assert that the TestObserver has received a Disposable but no other events.

Returns:

this

onSuccess

public void onSuccess(T value)

Description copied from interface: MaybeObserver

Notifies the MaybeObserver with one item and that the Maybe has finished sending push-based notifications.

The Maybe will not call this method if it calls MaybeObserver.onError(java.lang.Throwable).

Specified by:

onSuccess in interface MaybeObserver<T>

Specified by:

onSuccess in interface SingleObserver<T>

Parameters:

value - the item emitted by the Maybe