com.github.davidmoten.rx.testing.TestSubscriber2 Maven / Gradle / Ivy

Go to download
package com.github.davidmoten.rx.testing;

import java.util.List;
import java.util.concurrent.TimeUnit;

import rx.Observable;
import rx.Producer;
import rx.Subscriber;
import rx.functions.Func1;
import rx.observers.TestSubscriber;

public class TestSubscriber2 extends Subscriber {

    private final TestSubscriber ts;
    
    private TestSubscriber2(TestSubscriber ts) {
        this.ts = ts;
    }

    public static  TestSubscriber2 createWithRequest(long initialRequest) {
        TestSubscriber t1 = new TestSubscriber(initialRequest);
        TestSubscriber2 t2 = new TestSubscriber2(t1);
        t2.add(t1);
        return t2;
    }

    static  Func1, TestSubscriber2> test() {
        return testWithRequest(Long.MAX_VALUE);
    }
    
    static  Func1, TestSubscriber2> testWithRequest(
            final long initialRequest) {
        return new Func1, TestSubscriber2>() {

            @Override
            public TestSubscriber2 call(Observable o) {
                TestSubscriber2 ts2 = createWithRequest(initialRequest);
                o.subscribe(ts2.ts);
                return ts2;
            }

        };
    }
    
    public void onStart() {
        ts.onStart();
    }

    public void onCompleted() {
        ts.onCompleted();
    }

    public void setProducer(Producer p) {
        ts.setProducer(p);
    }

    public final int getCompletions() {
        return ts.getCompletions();
    }

    public void onError(Throwable e) {
        ts.onError(e);
    }

    public List getOnErrorEvents() {
        return ts.getOnErrorEvents();
    }

    public void onNext(T t) {
        ts.onNext(t);
    }

    public String toString() {
        return ts.toString();
    }

    public final int getValueCount() {
        return ts.getValueCount();
    }

    public TestSubscriber2 requestMore(long n) {
        ts.requestMore(n);
        return this;
    }

    public List getOnNextEvents() {
        return ts.getOnNextEvents();
    }

    public TestSubscriber2 assertReceivedOnNext(List items) {
        ts.assertReceivedOnNext(items);
        return this;
    }

    public final boolean awaitValueCount(int expected, long timeout, TimeUnit unit) {
        return ts.awaitValueCount(expected, timeout, unit);
    }

    public TestSubscriber2 assertTerminalEvent() {
        ts.assertTerminalEvent();
        return this;
    }

    public TestSubscriber2 assertUnsubscribed() {
        ts.assertUnsubscribed();
        return this;
    }

    public TestSubscriber2 assertNoErrors() {
        ts.assertNoErrors();
        return this;
    }

    public TestSubscriber2 awaitTerminalEvent() {
        ts.awaitTerminalEvent();
        return this;
    }

    public TestSubscriber2 awaitTerminalEvent(long timeout, TimeUnit unit) {
        ts.awaitTerminalEvent(timeout, unit);
        return this;
    }

    public TestSubscriber2 awaitTerminalEventAndUnsubscribeOnTimeout(long timeout,
            TimeUnit unit) {
        ts.awaitTerminalEventAndUnsubscribeOnTimeout(timeout, unit);
        return this;
    }

    public Thread getLastSeenThread() {
        return ts.getLastSeenThread();
    }

    public TestSubscriber2 assertCompleted() {
        ts.assertCompleted();
        return this;
    }

    public TestSubscriber2 assertNotCompleted() {
        ts.assertNotCompleted();
        return this;
    }

    public TestSubscriber2 assertError(Class clazz) {
        ts.assertError(clazz);
        return this;
    }

    public TestSubscriber2 assertError(Throwable throwable) {
        ts.assertError(throwable);
        return this;
    }

    public TestSubscriber2 assertNoTerminalEvent() {
        ts.assertNoTerminalEvent();
        return this;
    }

    public TestSubscriber2 assertNoValues() {
        ts.assertNoValues();
        return this;
    }

    public TestSubscriber2 assertValueCount(int count) {
        ts.assertValueCount(count);
        return this;
    }

    public TestSubscriber2 assertValues(T... values) {
        ts.assertValues(values);
        return this;
    }

    public TestSubscriber2 assertValue(T value) {
        ts.assertValue(value);
        return this;
    }

    public final TestSubscriber2 assertValuesAndClear(T expectedFirstValue,
            T... expectedRestValues) {
        ts.assertValuesAndClear(expectedFirstValue, expectedRestValues);
        return this;
    }

}