org.reactivestreams.Subscriber - java examples

Here are the examples of the java api org.reactivestreams.Subscriber taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

155 Examples 7

19 View Complete Implementation : BehaviorSubjectTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testCompletedAfterErrorIsNotSent2() {
    BehaviorSubject<String> subject = BehaviorSubject.createDefault("default");
    Subscriber<String> observer = TestHelper.mockSubscriber();
    subject.subscribe(observer);
    subject.onNext("one");
    subject.onError(testException);
    subject.onNext("two");
    subject.onComplete();
    verify(observer, times(1)).onNext("default");
    verify(observer, times(1)).onNext("one");
    verify(observer, times(1)).onError(testException);
    verify(observer, never()).onNext("two");
    verify(observer, never()).onComplete();
    Subscriber<Object> o2 = TestHelper.mockSubscriber();
    subject.subscribe(o2);
    verify(o2, times(1)).onError(testException);
    verify(o2, never()).onNext(any());
    verify(o2, never()).onComplete();
}

19 View Complete Implementation : BehaviorSubjectTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testThatSubscriberReceivesDefaultValueAndSubsequentEvents() {
    BehaviorSubject<String> subject = BehaviorSubject.createDefault("default");
    Subscriber<String> observer = TestHelper.mockSubscriber();
    subject.subscribe(observer);
    subject.onNext("one");
    subject.onNext("two");
    subject.onNext("three");
    verify(observer, times(1)).onNext("default");
    verify(observer, times(1)).onNext("one");
    verify(observer, times(1)).onNext("two");
    verify(observer, times(1)).onNext("three");
    verify(observer, Mockito.never()).onError(testException);
    verify(observer, Mockito.never()).onComplete();
}

19 View Complete Implementation : OperatorDefaultIfEmptyTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
@Ignore("Subscribers should not throw")
public void testEmptyButClientThrows() {
    final Subscriber<Integer> o = TestHelper.mockSubscriber();
    Observable.<Integer>empty().defaultIfEmpty(1).subscribe(new Observer<Integer>() {

        @Override
        public void onNext(Integer t) {
            throw new TestException();
        }

        @Override
        public void onError(Throwable e) {
            o.onError(e);
        }

        @Override
        public void onComplete() {
            o.onComplete();
        }
    });
    verify(o).onError(any(TestException.clreplaced));
    verify(o, never()).onNext(any(Integer.clreplaced));
    verify(o, never()).onComplete();
}

19 View Complete Implementation : BehaviorSubjectTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testCompletedAfterErrorIsNotSent() {
    BehaviorSubject<String> subject = BehaviorSubject.createDefault("default");
    Subscriber<String> observer = TestHelper.mockSubscriber();
    subject.subscribe(observer);
    subject.onNext("one");
    subject.onError(testException);
    subject.onNext("two");
    subject.onComplete();
    verify(observer, times(1)).onNext("default");
    verify(observer, times(1)).onNext("one");
    verify(observer, times(1)).onError(testException);
    verify(observer, never()).onNext("two");
    verify(observer, never()).onComplete();
}

19 View Complete Implementation : OperatorSkipLastTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testSkipLastWithZeroCount() {
    Observable<String> w = Observable.just("one", "two");
    Observable<String> observable = w.skipLast(0);
    Subscriber<String> observer = TestHelper.mockSubscriber();
    observable.subscribe(observer);
    verify(observer, times(1)).onNext("one");
    verify(observer, times(1)).onNext("two");
    verify(observer, never()).onError(any(Throwable.clreplaced));
    verify(observer, times(1)).onComplete();
}

19 View Complete Implementation : BehaviorSubjectTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testStartEmpty() {
    BehaviorSubject<Integer> source = BehaviorSubject.create();
    final Subscriber<Object> o = TestHelper.mockSubscriber();
    InOrder inOrder = inOrder(o);
    source.subscribe(o);
    inOrder.verify(o, never()).onNext(any());
    inOrder.verify(o, never()).onComplete();
    source.onNext(1);
    source.onComplete();
    source.onNext(2);
    verify(o, never()).onError(any(Throwable.clreplaced));
    inOrder.verify(o).onNext(1);
    inOrder.verify(o).onComplete();
    inOrder.verifyNoMoreInteractions();
}

19 View Complete Implementation : BehaviorSubjectTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testStartEmptyThenAddOne() {
    BehaviorSubject<Integer> source = BehaviorSubject.create();
    final Subscriber<Object> o = TestHelper.mockSubscriber();
    InOrder inOrder = inOrder(o);
    source.onNext(1);
    source.subscribe(o);
    inOrder.verify(o).onNext(1);
    source.onComplete();
    source.onNext(2);
    inOrder.verify(o).onComplete();
    inOrder.verifyNoMoreInteractions();
    verify(o, never()).onError(any(Throwable.clreplaced));
}

19 View Complete Implementation : BehaviorSubjectTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testStartEmptyCompleteWithOne() {
    BehaviorSubject<Integer> source = BehaviorSubject.create();
    final Subscriber<Object> o = TestHelper.mockSubscriber();
    source.onNext(1);
    source.onComplete();
    source.onNext(2);
    source.subscribe(o);
    verify(o).onComplete();
    verify(o, never()).onError(any(Throwable.clreplaced));
    verify(o, never()).onNext(any());
}

19 View Complete Implementation : OperatorTimestampTest.java
Copyright Apache License 2.0
Author : akarnokd
public clreplaced OperatorTimestampTest {

    Subscriber<Object> observer;

    @Before
    public void before() {
        observer = TestHelper.mockSubscriber();
    }

    @Test
    public void timestampWithScheduler() {
        TestScheduler scheduler = new TestScheduler();
        PublishSubject<Integer> source = PublishSubject.create();
        Observable<Timed<Integer>> m = source.timestamp(scheduler);
        m.subscribe(observer);
        source.onNext(1);
        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
        source.onNext(2);
        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
        source.onNext(3);
        InOrder inOrder = inOrder(observer);
        inOrder.verify(observer, times(1)).onNext(new Timed<Integer>(1, 0, TimeUnit.MILLISECONDS));
        inOrder.verify(observer, times(1)).onNext(new Timed<Integer>(2, 100, TimeUnit.MILLISECONDS));
        inOrder.verify(observer, times(1)).onNext(new Timed<Integer>(3, 200, TimeUnit.MILLISECONDS));
        verify(observer, never()).onError(any(Throwable.clreplaced));
        verify(observer, never()).onComplete();
    }

    @Test
    public void timestampWithScheduler2() {
        TestScheduler scheduler = new TestScheduler();
        PublishSubject<Integer> source = PublishSubject.create();
        Observable<Timed<Integer>> m = source.timestamp(scheduler);
        m.subscribe(observer);
        source.onNext(1);
        source.onNext(2);
        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
        source.onNext(3);
        InOrder inOrder = inOrder(observer);
        inOrder.verify(observer, times(1)).onNext(new Timed<Integer>(1, 0, TimeUnit.MILLISECONDS));
        inOrder.verify(observer, times(1)).onNext(new Timed<Integer>(2, 0, TimeUnit.MILLISECONDS));
        inOrder.verify(observer, times(1)).onNext(new Timed<Integer>(3, 200, TimeUnit.MILLISECONDS));
        verify(observer, never()).onError(any(Throwable.clreplaced));
        verify(observer, never()).onComplete();
    }
}

19 View Complete Implementation : OperatorSkipUntilTest.java
Copyright Apache License 2.0
Author : akarnokd
public clreplaced OperatorSkipUntilTest {

    Subscriber<Object> observer;

    @Before
    public void before() {
        observer = TestHelper.mockSubscriber();
    }

    @Test
    public void normal1() {
        PublishSubject<Integer> source = PublishSubject.create();
        PublishSubject<Integer> other = PublishSubject.create();
        Observable<Integer> m = source.skipUntil(other);
        m.subscribe(observer);
        source.onNext(0);
        source.onNext(1);
        other.onNext(100);
        source.onNext(2);
        source.onNext(3);
        source.onNext(4);
        source.onComplete();
        verify(observer, never()).onError(any(Throwable.clreplaced));
        verify(observer, times(1)).onNext(2);
        verify(observer, times(1)).onNext(3);
        verify(observer, times(1)).onNext(4);
        verify(observer, times(1)).onComplete();
    }

    @Test
    public void otherNeverFires() {
        PublishSubject<Integer> source = PublishSubject.create();
        Observable<Integer> m = source.skipUntil(Observable.never());
        m.subscribe(observer);
        source.onNext(0);
        source.onNext(1);
        source.onNext(2);
        source.onNext(3);
        source.onNext(4);
        source.onComplete();
        verify(observer, never()).onError(any(Throwable.clreplaced));
        verify(observer, never()).onNext(any());
        verify(observer, times(1)).onComplete();
    }

    @Test
    public void otherEmpty() {
        PublishSubject<Integer> source = PublishSubject.create();
        Observable<Integer> m = source.skipUntil(Observable.empty());
        m.subscribe(observer);
        verify(observer, never()).onError(any(Throwable.clreplaced));
        verify(observer, never()).onNext(any());
        verify(observer, never()).onComplete();
    }

    @Test
    public void otherFiresAndCompletes() {
        PublishSubject<Integer> source = PublishSubject.create();
        PublishSubject<Integer> other = PublishSubject.create();
        Observable<Integer> m = source.skipUntil(other);
        m.subscribe(observer);
        source.onNext(0);
        source.onNext(1);
        other.onNext(100);
        other.onComplete();
        source.onNext(2);
        source.onNext(3);
        source.onNext(4);
        source.onComplete();
        verify(observer, never()).onError(any(Throwable.clreplaced));
        verify(observer, times(1)).onNext(2);
        verify(observer, times(1)).onNext(3);
        verify(observer, times(1)).onNext(4);
        verify(observer, times(1)).onComplete();
    }

    @Test
    public void sourceThrows() {
        PublishSubject<Integer> source = PublishSubject.create();
        PublishSubject<Integer> other = PublishSubject.create();
        Observable<Integer> m = source.skipUntil(other);
        m.subscribe(observer);
        source.onNext(0);
        source.onNext(1);
        other.onNext(100);
        other.onComplete();
        source.onNext(2);
        source.onError(new RuntimeException("Forced failure"));
        verify(observer, times(1)).onNext(2);
        verify(observer, times(1)).onError(any(Throwable.clreplaced));
        verify(observer, never()).onComplete();
    }

    @Test
    public void otherThrowsImmediately() {
        PublishSubject<Integer> source = PublishSubject.create();
        PublishSubject<Integer> other = PublishSubject.create();
        Observable<Integer> m = source.skipUntil(other);
        m.subscribe(observer);
        source.onNext(0);
        source.onNext(1);
        other.onError(new RuntimeException("Forced failure"));
        verify(observer, never()).onNext(any());
        verify(observer, times(1)).onError(any(Throwable.clreplaced));
        verify(observer, never()).onComplete();
    }
}

19 View Complete Implementation : OperatorToMapTest.java
Copyright Apache License 2.0
Author : akarnokd
public clreplaced OperatorToMapTest {

    Subscriber<Object> objectObserver;

    @Before
    public void before() {
        objectObserver = TestHelper.mockSubscriber();
    }

    Function<String, Integer> lengthFunc = new Function<String, Integer>() {

        @Override
        public Integer apply(String t1) {
            return t1.length();
        }
    };

    Function<String, String> duplicate = new Function<String, String>() {

        @Override
        public String apply(String t1) {
            return t1 + t1;
        }
    };

    @Test
    public void testToMap() {
        Observable<String> source = Observable.just("a", "bb", "ccc", "dddd");
        Observable<Map<Integer, String>> mapped = source.toMap(lengthFunc);
        Map<Integer, String> expected = new HashMap<Integer, String>();
        expected.put(1, "a");
        expected.put(2, "bb");
        expected.put(3, "ccc");
        expected.put(4, "dddd");
        mapped.subscribe(objectObserver);
        verify(objectObserver, never()).onError(any(Throwable.clreplaced));
        verify(objectObserver, times(1)).onNext(expected);
        verify(objectObserver, times(1)).onComplete();
    }

    @Test
    public void testToMapWithValueSelector() {
        Observable<String> source = Observable.just("a", "bb", "ccc", "dddd");
        Observable<Map<Integer, String>> mapped = source.toMap(lengthFunc, duplicate);
        Map<Integer, String> expected = new HashMap<Integer, String>();
        expected.put(1, "aa");
        expected.put(2, "bbbb");
        expected.put(3, "cccccc");
        expected.put(4, "dddddddd");
        mapped.subscribe(objectObserver);
        verify(objectObserver, never()).onError(any(Throwable.clreplaced));
        verify(objectObserver, times(1)).onNext(expected);
        verify(objectObserver, times(1)).onComplete();
    }

    @Test
    public void testToMapWithError() {
        Observable<String> source = Observable.just("a", "bb", "ccc", "dddd");
        Function<String, Integer> lengthFuncErr = new Function<String, Integer>() {

            @Override
            public Integer apply(String t1) {
                if ("bb".equals(t1)) {
                    throw new RuntimeException("Forced Failure");
                }
                return t1.length();
            }
        };
        Observable<Map<Integer, String>> mapped = source.toMap(lengthFuncErr);
        Map<Integer, String> expected = new HashMap<Integer, String>();
        expected.put(1, "a");
        expected.put(2, "bb");
        expected.put(3, "ccc");
        expected.put(4, "dddd");
        mapped.subscribe(objectObserver);
        verify(objectObserver, never()).onNext(expected);
        verify(objectObserver, never()).onComplete();
        verify(objectObserver, times(1)).onError(any(Throwable.clreplaced));
    }

    @Test
    public void testToMapWithErrorInValueSelector() {
        Observable<String> source = Observable.just("a", "bb", "ccc", "dddd");
        Function<String, String> duplicateErr = new Function<String, String>() {

            @Override
            public String apply(String t1) {
                if ("bb".equals(t1)) {
                    throw new RuntimeException("Forced failure");
                }
                return t1 + t1;
            }
        };
        Observable<Map<Integer, String>> mapped = source.toMap(lengthFunc, duplicateErr);
        Map<Integer, String> expected = new HashMap<Integer, String>();
        expected.put(1, "aa");
        expected.put(2, "bbbb");
        expected.put(3, "cccccc");
        expected.put(4, "dddddddd");
        mapped.subscribe(objectObserver);
        verify(objectObserver, never()).onNext(expected);
        verify(objectObserver, never()).onComplete();
        verify(objectObserver, times(1)).onError(any(Throwable.clreplaced));
    }

    @Test
    public void testToMapWithFactory() {
        Observable<String> source = Observable.just("a", "bb", "ccc", "dddd");
        Supplier<Map<Integer, String>> mapFactory = new Supplier<Map<Integer, String>>() {

            @Override
            public Map<Integer, String> get() {
                return new LinkedHashMap<Integer, String>() {

                    /**
                     */
                    private static final long serialVersionUID = -3296811238780863394L;

                    @Override
                    protected boolean removeEldestEntry(Map.Entry<Integer, String> eldest) {
                        return size() > 3;
                    }
                };
            }
        };
        Function<String, Integer> lengthFunc = new Function<String, Integer>() {

            @Override
            public Integer apply(String t1) {
                return t1.length();
            }
        };
        Observable<Map<Integer, String>> mapped = source.toMap(lengthFunc, new Function<String, String>() {

            @Override
            public String apply(String v) {
                return v;
            }
        }, mapFactory);
        Map<Integer, String> expected = new LinkedHashMap<Integer, String>();
        expected.put(2, "bb");
        expected.put(3, "ccc");
        expected.put(4, "dddd");
        mapped.subscribe(objectObserver);
        verify(objectObserver, never()).onError(any(Throwable.clreplaced));
        verify(objectObserver, times(1)).onNext(expected);
        verify(objectObserver, times(1)).onComplete();
    }

    @Test
    public void testToMapWithErrorThrowingFactory() {
        Observable<String> source = Observable.just("a", "bb", "ccc", "dddd");
        Supplier<Map<Integer, String>> mapFactory = new Supplier<Map<Integer, String>>() {

            @Override
            public Map<Integer, String> get() {
                throw new RuntimeException("Forced failure");
            }
        };
        Function<String, Integer> lengthFunc = new Function<String, Integer>() {

            @Override
            public Integer apply(String t1) {
                return t1.length();
            }
        };
        Observable<Map<Integer, String>> mapped = source.toMap(lengthFunc, new Function<String, String>() {

            @Override
            public String apply(String v) {
                return v;
            }
        }, mapFactory);
        Map<Integer, String> expected = new LinkedHashMap<Integer, String>();
        expected.put(2, "bb");
        expected.put(3, "ccc");
        expected.put(4, "dddd");
        mapped.subscribe(objectObserver);
        verify(objectObserver, never()).onNext(expected);
        verify(objectObserver, never()).onComplete();
        verify(objectObserver, times(1)).onError(any(Throwable.clreplaced));
    }
}

19 View Complete Implementation : BehaviorSubjectTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testTakeOneSubscriber() {
    BehaviorSubject<Integer> source = BehaviorSubject.createDefault(1);
    final Subscriber<Object> o = TestHelper.mockSubscriber();
    source.take(1).subscribe(o);
    verify(o).onNext(1);
    verify(o).onComplete();
    verify(o, never()).onError(any(Throwable.clreplaced));
    replacedertEquals(0, source.subscriberCount());
    replacedertFalse(source.hreplacedubscribers());
}

19 View Complete Implementation : BehaviorSubjectTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testCompletedAfterErrorIsNotSent3() {
    BehaviorSubject<String> subject = BehaviorSubject.createDefault("default");
    Subscriber<String> observer = TestHelper.mockSubscriber();
    subject.subscribe(observer);
    subject.onNext("one");
    subject.onComplete();
    subject.onNext("two");
    subject.onComplete();
    verify(observer, times(1)).onNext("default");
    verify(observer, times(1)).onNext("one");
    verify(observer, times(1)).onComplete();
    verify(observer, never()).onError(any(Throwable.clreplaced));
    verify(observer, never()).onNext("two");
    Subscriber<Object> o2 = TestHelper.mockSubscriber();
    subject.subscribe(o2);
    verify(o2, times(1)).onComplete();
    verify(o2, never()).onNext(any());
    verify(observer, never()).onError(any(Throwable.clreplaced));
}

19 View Complete Implementation : BehaviorSubjectTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testSubscribeThenOnComplete() {
    BehaviorSubject<String> subject = BehaviorSubject.createDefault("default");
    Subscriber<String> observer = TestHelper.mockSubscriber();
    subject.subscribe(observer);
    subject.onNext("one");
    subject.onComplete();
    verify(observer, times(1)).onNext("default");
    verify(observer, times(1)).onNext("one");
    verify(observer, Mockito.never()).onError(any(Throwable.clreplaced));
    verify(observer, times(1)).onComplete();
}

19 View Complete Implementation : OperatorFinallyTest.java
Copyright Apache License 2.0
Author : akarnokd
public clreplaced OperatorFinallyTest {

    private Runnable aAction0;

    private Subscriber<String> observer;

    // mocking has to be unchecked, unfortunately
    @Before
    public void before() {
        aAction0 = mock(Runnable.clreplaced);
        observer = TestHelper.mockSubscriber();
    }

    private void checkActionCalled(Observable<String> input) {
        input.finallyDo(aAction0).subscribe(observer);
        verify(aAction0, times(1)).run();
    }

    @Test
    public void testFinallyCalledOnComplete() {
        checkActionCalled(Observable.fromArray("1", "2", "3"));
    }

    @Test
    public void testFinallyCalledOnError() {
        checkActionCalled(Observable.<String>error(new RuntimeException("expected")));
    }
}

19 View Complete Implementation : BehaviorSubjectTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testThatSubscriberReceivesLatestAndThenSubsequentEvents() {
    BehaviorSubject<String> subject = BehaviorSubject.createDefault("default");
    subject.onNext("one");
    Subscriber<String> observer = TestHelper.mockSubscriber();
    subject.subscribe(observer);
    subject.onNext("two");
    subject.onNext("three");
    verify(observer, Mockito.never()).onNext("default");
    verify(observer, times(1)).onNext("one");
    verify(observer, times(1)).onNext("two");
    verify(observer, times(1)).onNext("three");
    verify(observer, Mockito.never()).onError(testException);
    verify(observer, Mockito.never()).onComplete();
}

19 View Complete Implementation : BehaviorSubjectTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testSubscribeToCompletedOnlyEmitsOnComplete() {
    BehaviorSubject<String> subject = BehaviorSubject.createDefault("default");
    subject.onNext("one");
    subject.onComplete();
    Subscriber<String> observer = TestHelper.mockSubscriber();
    subject.subscribe(observer);
    verify(observer, never()).onNext("default");
    verify(observer, never()).onNext("one");
    verify(observer, Mockito.never()).onError(any(Throwable.clreplaced));
    verify(observer, times(1)).onComplete();
}

19 View Complete Implementation : BehaviorSubjectTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testSubscribeToErrorOnlyEmitsOnError() {
    BehaviorSubject<String> subject = BehaviorSubject.createDefault("default");
    subject.onNext("one");
    RuntimeException re = new RuntimeException("test error");
    subject.onError(re);
    Subscriber<String> observer = TestHelper.mockSubscriber();
    subject.subscribe(observer);
    verify(observer, never()).onNext("default");
    verify(observer, never()).onNext("one");
    verify(observer, times(1)).onError(re);
    verify(observer, never()).onComplete();
}

19 View Complete Implementation : OperatorReduceTest.java
Copyright Apache License 2.0
Author : akarnokd
public clreplaced OperatorReduceTest {

    Subscriber<Object> observer;

    @Before
    public void before() {
        observer = TestHelper.mockSubscriber();
    }

    BiFunction<Integer, Integer, Integer> sum = new BiFunction<Integer, Integer, Integer>() {

        @Override
        public Integer apply(Integer t1, Integer t2) {
            return t1 + t2;
        }
    };

    @Test
    public void testAggregateAsIntSum() {
        Observable<Integer> result = Observable.just(1, 2, 3, 4, 5).reduce(0, sum).map(new Function<Integer, Integer>() {

            @Override
            public Integer apply(Integer v) {
                return v;
            }
        });
        result.subscribe(observer);
        verify(observer).onNext(1 + 2 + 3 + 4 + 5);
        verify(observer).onComplete();
        verify(observer, never()).onError(any(Throwable.clreplaced));
    }

    @Test
    public void testAggregateAsIntSumSourceThrows() {
        Observable<Integer> result = Observable.concat(Observable.just(1, 2, 3, 4, 5), Observable.<Integer>error(new TestException())).reduce(0, sum).map(new Function<Integer, Integer>() {

            @Override
            public Integer apply(Integer v) {
                return v;
            }
        });
        result.subscribe(observer);
        verify(observer, never()).onNext(any());
        verify(observer, never()).onComplete();
        verify(observer, times(1)).onError(any(TestException.clreplaced));
    }

    @Test
    public void testAggregateAsIntSumAcreplacedulatorThrows() {
        BiFunction<Integer, Integer, Integer> sumErr = new BiFunction<Integer, Integer, Integer>() {

            @Override
            public Integer apply(Integer t1, Integer t2) {
                throw new TestException();
            }
        };
        Observable<Integer> result = Observable.just(1, 2, 3, 4, 5).reduce(0, sumErr).map(new Function<Integer, Integer>() {

            @Override
            public Integer apply(Integer v) {
                return v;
            }
        });
        result.subscribe(observer);
        verify(observer, never()).onNext(any());
        verify(observer, never()).onComplete();
        verify(observer, times(1)).onError(any(TestException.clreplaced));
    }

    @Test
    public void testAggregateAsIntSumResultSelectorThrows() {
        Function<Integer, Integer> error = new Function<Integer, Integer>() {

            @Override
            public Integer apply(Integer t1) {
                throw new TestException();
            }
        };
        Observable<Integer> result = Observable.just(1, 2, 3, 4, 5).reduce(0, sum).map(error);
        result.subscribe(observer);
        verify(observer, never()).onNext(any());
        verify(observer, never()).onComplete();
        verify(observer, times(1)).onError(any(TestException.clreplaced));
    }

    @Test
    public void testBackpressureWithNoInitialValue() throws InterruptedException {
        Observable<Integer> source = Observable.just(1, 2, 3, 4, 5, 6);
        Observable<Integer> reduced = source.reduce(sum);
        Integer r = reduced.toBlocking().first();
        replacedertEquals(21, r.intValue());
    }

    @Test
    public void testBackpressureWithInitialValue() throws InterruptedException {
        Observable<Integer> source = Observable.just(1, 2, 3, 4, 5, 6);
        Observable<Integer> reduced = source.reduce(0, sum);
        Integer r = reduced.toBlocking().first();
        replacedertEquals(21, r.intValue());
    }
}

19 View Complete Implementation : OperatorSkipLastTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testSkipLastEmpty() {
    Observable<String> observable = Observable.<String>empty().skipLast(2);
    Subscriber<String> observer = TestHelper.mockSubscriber();
    observable.subscribe(observer);
    verify(observer, never()).onNext(any(String.clreplaced));
    verify(observer, never()).onError(any(Throwable.clreplaced));
    verify(observer, times(1)).onComplete();
}

19 View Complete Implementation : OperatorDefaultIfEmptyTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testDefaultIfEmptyWithEmpty() {
    Observable<Integer> source = Observable.empty();
    Observable<Integer> observable = source.defaultIfEmpty(10);
    Subscriber<Integer> observer = TestHelper.mockSubscriber();
    observable.subscribe(observer);
    verify(observer).onNext(10);
    verify(observer).onComplete();
    verify(observer, never()).onError(any(Throwable.clreplaced));
}

19 View Complete Implementation : OperatorDoOnEachTest.java
Copyright Apache License 2.0
Author : akarnokd
public clreplaced OperatorDoOnEachTest {

    Subscriber<String> subscribedObserver;

    Subscriber<String> sideEffectObserver;

    @Before
    public void before() {
        subscribedObserver = TestHelper.mockSubscriber();
        sideEffectObserver = TestHelper.mockSubscriber();
    }

    @Test
    public void testDoOnEach() {
        Observable<String> base = Observable.just("a", "b", "c");
        Observable<String> doOnEach = base.doOnEach(sideEffectObserver);
        doOnEach.subscribe(subscribedObserver);
        // ensure the leaf observer is still getting called
        verify(subscribedObserver, never()).onError(any(Throwable.clreplaced));
        verify(subscribedObserver, times(1)).onNext("a");
        verify(subscribedObserver, times(1)).onNext("b");
        verify(subscribedObserver, times(1)).onNext("c");
        verify(subscribedObserver, times(1)).onComplete();
        // ensure our injected observer is getting called
        verify(sideEffectObserver, never()).onError(any(Throwable.clreplaced));
        verify(sideEffectObserver, times(1)).onNext("a");
        verify(sideEffectObserver, times(1)).onNext("b");
        verify(sideEffectObserver, times(1)).onNext("c");
        verify(sideEffectObserver, times(1)).onComplete();
    }

    @Test
    public void testDoOnEachWithError() {
        Observable<String> base = Observable.just("one", "fail", "two", "three", "fail");
        Observable<String> errs = base.map(new Function<String, String>() {

            @Override
            public String apply(String s) {
                if ("fail".equals(s)) {
                    throw new RuntimeException("Forced Failure");
                }
                return s;
            }
        });
        Observable<String> doOnEach = errs.doOnEach(sideEffectObserver);
        doOnEach.subscribe(subscribedObserver);
        verify(subscribedObserver, times(1)).onNext("one");
        verify(subscribedObserver, never()).onNext("two");
        verify(subscribedObserver, never()).onNext("three");
        verify(subscribedObserver, never()).onComplete();
        verify(subscribedObserver, times(1)).onError(any(Throwable.clreplaced));
        verify(sideEffectObserver, times(1)).onNext("one");
        verify(sideEffectObserver, never()).onNext("two");
        verify(sideEffectObserver, never()).onNext("three");
        verify(sideEffectObserver, never()).onComplete();
        verify(sideEffectObserver, times(1)).onError(any(Throwable.clreplaced));
    }

    @Test
    public void testDoOnEachWithErrorInCallback() {
        Observable<String> base = Observable.just("one", "two", "fail", "three");
        Observable<String> doOnEach = base.doOnNext(new Consumer<String>() {

            @Override
            public void accept(String s) {
                if ("fail".equals(s)) {
                    throw new RuntimeException("Forced Failure");
                }
            }
        });
        doOnEach.subscribe(subscribedObserver);
        verify(subscribedObserver, times(1)).onNext("one");
        verify(subscribedObserver, times(1)).onNext("two");
        verify(subscribedObserver, never()).onNext("three");
        verify(subscribedObserver, never()).onComplete();
        verify(subscribedObserver, times(1)).onError(any(Throwable.clreplaced));
    }

    @Test
    public void testIssue1451Case1() {
        // https://github.com/Netflix/RxJava/issues/1451
        final int expectedCount = 3;
        final AtomicInteger count = new AtomicInteger();
        for (int i = 0; i < expectedCount; i++) {
            Observable.just(Boolean.TRUE, Boolean.FALSE).takeWhile(new Predicate<Boolean>() {

                @Override
                public boolean test(Boolean value) {
                    return value;
                }
            }).toList().doOnNext(new Consumer<List<Boolean>>() {

                @Override
                public void accept(List<Boolean> booleans) {
                    count.incrementAndGet();
                }
            }).subscribe();
        }
        replacedertEquals(expectedCount, count.get());
    }

    @Test
    public void testIssue1451Case2() {
        // https://github.com/Netflix/RxJava/issues/1451
        final int expectedCount = 3;
        final AtomicInteger count = new AtomicInteger();
        for (int i = 0; i < expectedCount; i++) {
            Observable.just(Boolean.TRUE, Boolean.FALSE, Boolean.FALSE).takeWhile(new Predicate<Boolean>() {

                @Override
                public boolean test(Boolean value) {
                    return value;
                }
            }).toList().doOnNext(new Consumer<List<Boolean>>() {

                @Override
                public void accept(List<Boolean> booleans) {
                    count.incrementAndGet();
                }
            }).subscribe();
        }
        replacedertEquals(expectedCount, count.get());
    }
    // FIXME crashing publisher can't propagate to a subscriber
    // @Test
    // public void testFatalError() {
    // try {
    // Observable.just(1, 2, 3)
    // .flatMap(new Function<Integer, Observable<?>>() {
    // @Override
    // public Observable<?> apply(Integer integer) {
    // return Observable.create(new Publisher<Object>() {
    // @Override
    // public void subscribe(Subscriber<Object> o) {
    // throw new NullPointerException("Test NPE");
    // }
    // });
    // }
    // })
    // .doOnNext(new Consumer<Object>() {
    // @Override
    // public void accept(Object o) {
    // System.out.println("Won't come here");
    // }
    // })
    // .subscribe();
    // fail("should have thrown an exception");
    // } catch (OnErrorNotImplementedException e) {
    // replacedertTrue(e.getCause() instanceof NullPointerException);
    // replacedertEquals(e.getCause().getMessage(), "Test NPE");
    // System.out.println("Received exception: " + e);
    // }
    // }
}

19 View Complete Implementation : OnSubscribeTimerTest.java
Copyright Apache License 2.0
Author : akarnokd
public clreplaced OnSubscribeTimerTest {

    @Mock
    Subscriber<Object> observer;

    @Mock
    Subscriber<Long> observer2;

    TestScheduler scheduler;

    @Before
    public void before() {
        observer = TestHelper.mockSubscriber();
        observer2 = TestHelper.mockSubscriber();
        scheduler = new TestScheduler();
    }

    @Test
    public void testTimerOnce() {
        Observable.timer(100, TimeUnit.MILLISECONDS, scheduler).subscribe(observer);
        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
        verify(observer, times(1)).onNext(0L);
        verify(observer, times(1)).onComplete();
        verify(observer, never()).onError(any(Throwable.clreplaced));
    }

    @Test
    public void testTimerPeriodically() {
        TestSubscriber<Long> ts = new TestSubscriber<Long>();
        Observable.interval(100, 100, TimeUnit.MILLISECONDS, scheduler).subscribe(ts);
        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
        ts.replacedertValue(0L);
        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
        ts.replacedertValues(0L, 1L);
        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
        ts.replacedertValues(0L, 1L, 2L);
        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
        ts.replacedertValues(0L, 1L, 2L, 3L);
        ts.dispose();
        scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
        ts.replacedertValues(0L, 1L, 2L, 3L);
        ts.replacedertNotComplete();
        ts.replacedertNoErrors();
    }

    @Test
    public void testInterval() {
        Observable<Long> w = Observable.interval(1, TimeUnit.SECONDS, scheduler);
        TestSubscriber<Long> ts = new TestSubscriber<Long>();
        w.subscribe(ts);
        ts.replacedertNoValues();
        ts.replacedertNoErrors();
        ts.replacedertNotComplete();
        scheduler.advanceTimeTo(2, TimeUnit.SECONDS);
        ts.replacedertValues(0L, 1L);
        ts.replacedertNoErrors();
        ts.replacedertNotComplete();
        ts.dispose();
        scheduler.advanceTimeTo(4, TimeUnit.SECONDS);
        ts.replacedertValues(0L, 1L);
        ts.replacedertNoErrors();
        ts.replacedertNotComplete();
    }

    @Test
    public void testWithMultipleSubscribersStartingAtSameTime() {
        Observable<Long> w = Observable.interval(1, TimeUnit.SECONDS, scheduler);
        TestSubscriber<Long> ts1 = new TestSubscriber<Long>();
        TestSubscriber<Long> ts2 = new TestSubscriber<Long>();
        w.subscribe(ts1);
        w.subscribe(ts2);
        ts1.replacedertNoValues();
        ts2.replacedertNoValues();
        scheduler.advanceTimeTo(2, TimeUnit.SECONDS);
        ts1.replacedertValues(0L, 1L);
        ts1.replacedertNoErrors();
        ts1.replacedertNotComplete();
        ts2.replacedertValues(0L, 1L);
        ts2.replacedertNoErrors();
        ts2.replacedertNotComplete();
        ts1.dispose();
        ts2.dispose();
        scheduler.advanceTimeTo(4, TimeUnit.SECONDS);
        ts1.replacedertValues(0L, 1L);
        ts1.replacedertNoErrors();
        ts1.replacedertNotComplete();
        ts2.replacedertValues(0L, 1L);
        ts2.replacedertNoErrors();
        ts2.replacedertNotComplete();
    }

    @Test
    public void testWithMultipleStaggeredSubscribers() {
        Observable<Long> w = Observable.interval(1, TimeUnit.SECONDS, scheduler);
        TestSubscriber<Long> ts1 = new TestSubscriber<Long>();
        w.subscribe(ts1);
        ts1.replacedertNoErrors();
        scheduler.advanceTimeTo(2, TimeUnit.SECONDS);
        TestSubscriber<Long> ts2 = new TestSubscriber<Long>();
        w.subscribe(ts2);
        ts1.replacedertValues(0L, 1L);
        ts1.replacedertNoErrors();
        ts1.replacedertNotComplete();
        ts2.replacedertNoValues();
        scheduler.advanceTimeTo(4, TimeUnit.SECONDS);
        ts1.replacedertValues(0L, 1L, 2L, 3L);
        ts2.replacedertValues(0L, 1L);
        ts1.dispose();
        ts2.dispose();
        ts1.replacedertValues(0L, 1L, 2L, 3L);
        ts1.replacedertNoErrors();
        ts1.replacedertNotComplete();
        ts2.replacedertValues(0L, 1L);
        ts2.replacedertNoErrors();
        ts2.replacedertNotComplete();
    }

    @Test
    public void testWithMultipleStaggeredSubscribersAndPublish() {
        ConnectableObservable<Long> w = Observable.interval(1, TimeUnit.SECONDS, scheduler).publish();
        TestSubscriber<Long> ts1 = new TestSubscriber<Long>();
        w.subscribe(ts1);
        w.connect();
        ts1.replacedertNoValues();
        scheduler.advanceTimeTo(2, TimeUnit.SECONDS);
        TestSubscriber<Long> ts2 = new TestSubscriber<Long>();
        w.subscribe(ts2);
        ts1.replacedertValues(0L, 1L);
        ts1.replacedertNoErrors();
        ts1.replacedertNotComplete();
        ts2.replacedertNoValues();
        scheduler.advanceTimeTo(4, TimeUnit.SECONDS);
        ts1.replacedertValues(0L, 1L, 2L, 3L);
        ts2.replacedertValues(2L, 3L);
        ts1.dispose();
        ts2.dispose();
        ts1.replacedertValues(0L, 1L, 2L, 3L);
        ts1.replacedertNoErrors();
        ts1.replacedertNotComplete();
        ts2.replacedertValues(2L, 3L);
        ts2.replacedertNoErrors();
        ts2.replacedertNotComplete();
    }

    @Test
    public void testOnceObserverThrows() {
        Observable<Long> source = Observable.timer(100, TimeUnit.MILLISECONDS, scheduler);
        source.safeSubscribe(new Observer<Long>() {

            @Override
            public void onNext(Long t) {
                throw new TestException();
            }

            @Override
            public void onError(Throwable e) {
                observer.onError(e);
            }

            @Override
            public void onComplete() {
                observer.onComplete();
            }
        });
        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
        verify(observer).onError(any(TestException.clreplaced));
        verify(observer, never()).onNext(anyLong());
        verify(observer, never()).onComplete();
    }

    @Test
    public void testPeriodicObserverThrows() {
        Observable<Long> source = Observable.interval(100, 100, TimeUnit.MILLISECONDS, scheduler);
        InOrder inOrder = inOrder(observer);
        source.safeSubscribe(new Observer<Long>() {

            @Override
            public void onNext(Long t) {
                if (t > 0) {
                    throw new TestException();
                }
                observer.onNext(t);
            }

            @Override
            public void onError(Throwable e) {
                observer.onError(e);
            }

            @Override
            public void onComplete() {
                observer.onComplete();
            }
        });
        scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
        inOrder.verify(observer).onNext(0L);
        inOrder.verify(observer).onError(any(TestException.clreplaced));
        inOrder.verifyNoMoreInteractions();
        verify(observer, never()).onComplete();
    }
}

19 View Complete Implementation : OperatorDefaultIfEmptyTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testDefaultIfEmpty() {
    Observable<Integer> source = Observable.just(1, 2, 3);
    Observable<Integer> observable = source.defaultIfEmpty(10);
    Subscriber<Integer> observer = TestHelper.mockSubscriber();
    observable.subscribe(observer);
    verify(observer, never()).onNext(10);
    verify(observer).onNext(1);
    verify(observer).onNext(2);
    verify(observer).onNext(3);
    verify(observer).onComplete();
    verify(observer, never()).onError(any(Throwable.clreplaced));
}

18 View Complete Implementation : OperatorFirstTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testFirstOrDefaultWithPredicateAndEmpty() {
    Observable<Integer> observable = Observable.just(1).filter(new Predicate<Integer>() {

        @Override
        public boolean test(Integer t1) {
            return t1 % 2 == 0;
        }
    }).first(2);
    Subscriber<Integer> observer = TestHelper.mockSubscriber();
    observable.subscribe(observer);
    InOrder inOrder = inOrder(observer);
    inOrder.verify(observer, times(1)).onNext(2);
    inOrder.verify(observer, times(1)).onComplete();
    inOrder.verifyNoMoreInteractions();
}

18 View Complete Implementation : AsyncSubjectTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testError() {
    AsyncSubject<String> subject = AsyncSubject.create();
    Subscriber<String> observer = TestHelper.mockSubscriber();
    subject.subscribe(observer);
    subject.onNext("one");
    subject.onNext("two");
    subject.onNext("three");
    subject.onError(testException);
    subject.onNext("four");
    subject.onError(new Throwable());
    subject.onComplete();
    verify(observer, Mockito.never()).onNext(anyString());
    verify(observer, times(1)).onError(testException);
    verify(observer, Mockito.never()).onComplete();
}

18 View Complete Implementation : PublishSubjectTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testSubscribeMidSequence() {
    PublishSubject<String> subject = PublishSubject.create();
    Subscriber<String> observer = TestHelper.mockSubscriber();
    subject.subscribe(observer);
    subject.onNext("one");
    subject.onNext("two");
    replacedertObservedUntilTwo(observer);
    Subscriber<String> anotherSubscriber = TestHelper.mockSubscriber();
    subject.subscribe(anotherSubscriber);
    subject.onNext("three");
    subject.onComplete();
    replacedertCompletedSubscriber(observer);
    replacedertCompletedStartingWithThreeSubscriber(anotherSubscriber);
}

18 View Complete Implementation : OperatorSkipTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testSkipError() {
    Exception e = new Exception();
    Observable<String> ok = Observable.just("one");
    Observable<String> error = Observable.error(e);
    Observable<String> skip = Observable.concat(ok, error).lift(new OperatorSkip<String>(100));
    Subscriber<String> observer = TestHelper.mockSubscriber();
    skip.subscribe(observer);
    verify(observer, never()).onNext(any(String.clreplaced));
    verify(observer, times(1)).onError(e);
    verify(observer, never()).onComplete();
}

18 View Complete Implementation : OperatorDematerializeTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testDematerialize3() {
    Exception exception = new Exception("test");
    Observable<Integer> observable = Observable.error(exception);
    Observable<Integer> dematerialize = observable.materialize().dematerialize();
    Subscriber<Integer> observer = TestHelper.mockSubscriber();
    dematerialize.subscribe(observer);
    verify(observer, times(1)).onError(exception);
    verify(observer, times(0)).onComplete();
    verify(observer, times(0)).onNext(any(Integer.clreplaced));
}

18 View Complete Implementation : QueueDrainSubscriber.java
Copyright Apache License 2.0
Author : akarnokd
protected final void fastpathEmit(U value, boolean delayError) {
    final Subscriber<? super V> s = actual;
    final Queue<U> q = queue;
    if (wip == 0 && WIP.compareAndSet(this, 0, 1)) {
        long r = requested;
        if (r != 0L) {
            if (accept(s, value)) {
                if (r != Long.MAX_VALUE) {
                    produced(1);
                }
            }
            if (leave(-1) == 0) {
                return;
            }
        }
        q.offer(value);
    } else {
        q.offer(value);
        if (!enter()) {
            return;
        }
    }
    QueueDrainHelper.drainLoop(q, s, delayError, this);
}

18 View Complete Implementation : OperatorFirstTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testFirstOrDefault() {
    Observable<Integer> observable = Observable.just(1, 2, 3).first(4);
    Subscriber<Integer> observer = TestHelper.mockSubscriber();
    observable.subscribe(observer);
    InOrder inOrder = inOrder(observer);
    inOrder.verify(observer, times(1)).onNext(1);
    inOrder.verify(observer, times(1)).onComplete();
    inOrder.verifyNoMoreInteractions();
}

18 View Complete Implementation : OperatorSkipTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testSkipEmptyStream() {
    Observable<String> w = Observable.empty();
    Observable<String> skip = w.lift(new OperatorSkip<String>(1));
    Subscriber<String> observer = TestHelper.mockSubscriber();
    skip.subscribe(observer);
    verify(observer, never()).onNext(any(String.clreplaced));
    verify(observer, never()).onError(any(Throwable.clreplaced));
    verify(observer, times(1)).onComplete();
}

18 View Complete Implementation : OperatorSkipLastTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
@Ignore("Null values not allowed")
public void testSkipLastWithNull() {
    Observable<String> observable = Observable.fromIterable(Arrays.asList("one", null, "two")).skipLast(1);
    Subscriber<String> observer = TestHelper.mockSubscriber();
    observable.subscribe(observer);
    verify(observer, times(1)).onNext("one");
    verify(observer, times(1)).onNext(null);
    verify(observer, never()).onNext("two");
    verify(observer, never()).onError(any(Throwable.clreplaced));
    verify(observer, times(1)).onComplete();
}

18 View Complete Implementation : OperatorFirstTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testFirstWithPredicate() {
    Observable<Integer> observable = Observable.just(1, 2, 3, 4, 5, 6).filter(new Predicate<Integer>() {

        @Override
        public boolean test(Integer t1) {
            return t1 % 2 == 0;
        }
    }).first();
    Subscriber<Integer> observer = TestHelper.mockSubscriber();
    observable.subscribe(observer);
    InOrder inOrder = inOrder(observer);
    inOrder.verify(observer, times(1)).onNext(2);
    inOrder.verify(observer, times(1)).onComplete();
    inOrder.verifyNoMoreInteractions();
}

18 View Complete Implementation : OperatorTakeUntilPredicateTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void sourceThrows() {
    Subscriber<Object> o = TestHelper.mockSubscriber();
    Observable.just(1).concatWith(Observable.<Integer>error(new TestException())).concatWith(Observable.just(2)).takeUntil(new Predicate<Integer>() {

        @Override
        public boolean test(Integer v) {
            return false;
        }
    }).subscribe(o);
    verify(o).onNext(1);
    verify(o, never()).onNext(2);
    verify(o).onError(any(TestException.clreplaced));
    verify(o, never()).onComplete();
}

18 View Complete Implementation : AsyncSubjectTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testEmptySubjectCompleted() {
    AsyncSubject<String> subject = AsyncSubject.create();
    Subscriber<String> observer = TestHelper.mockSubscriber();
    subject.subscribe(observer);
    subject.onComplete();
    InOrder inOrder = inOrder(observer);
    inOrder.verify(observer, never()).onNext(null);
    inOrder.verify(observer, never()).onNext(any(String.clreplaced));
    inOrder.verify(observer, times(1)).onComplete();
    inOrder.verifyNoMoreInteractions();
}

18 View Complete Implementation : OperatorDematerializeTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testDematerialize2() {
    Throwable exception = new Throwable("test");
    Observable<Integer> observable = Observable.error(exception);
    Observable<Integer> dematerialize = observable.materialize().dematerialize();
    Subscriber<Integer> observer = TestHelper.mockSubscriber();
    dematerialize.subscribe(observer);
    verify(observer, times(1)).onError(exception);
    verify(observer, times(0)).onComplete();
    verify(observer, times(0)).onNext(any(Integer.clreplaced));
}

18 View Complete Implementation : OperatorSkipTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testSkipZeroElements() {
    Observable<String> skip = Observable.just("one", "two", "three").lift(new OperatorSkip<String>(0));
    Subscriber<String> observer = TestHelper.mockSubscriber();
    skip.subscribe(observer);
    verify(observer, times(1)).onNext("one");
    verify(observer, times(1)).onNext("two");
    verify(observer, times(1)).onNext("three");
    verify(observer, never()).onError(any(Throwable.clreplaced));
    verify(observer, times(1)).onComplete();
}

18 View Complete Implementation : OperatorSkipTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testSkipTwoElements() {
    Observable<String> skip = Observable.just("one", "two", "three").lift(new OperatorSkip<String>(2));
    Subscriber<String> observer = TestHelper.mockSubscriber();
    skip.subscribe(observer);
    verify(observer, never()).onNext("one");
    verify(observer, never()).onNext("two");
    verify(observer, times(1)).onNext("three");
    verify(observer, never()).onError(any(Throwable.clreplaced));
    verify(observer, times(1)).onComplete();
}

18 View Complete Implementation : OperatorFirstTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testFirstOrDefaultWithPredicateAndOneElement() {
    Observable<Integer> observable = Observable.just(1, 2).filter(new Predicate<Integer>() {

        @Override
        public boolean test(Integer t1) {
            return t1 % 2 == 0;
        }
    }).first(4);
    Subscriber<Integer> observer = TestHelper.mockSubscriber();
    observable.subscribe(observer);
    InOrder inOrder = inOrder(observer);
    inOrder.verify(observer, times(1)).onNext(2);
    inOrder.verify(observer, times(1)).onComplete();
    inOrder.verifyNoMoreInteractions();
}

18 View Complete Implementation : OperatorFirstTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testFirstWithOneElement() {
    Observable<Integer> observable = Observable.just(1).first();
    Subscriber<Integer> observer = TestHelper.mockSubscriber();
    observable.subscribe(observer);
    InOrder inOrder = inOrder(observer);
    inOrder.verify(observer, times(1)).onNext(1);
    inOrder.verify(observer, times(1)).onComplete();
    inOrder.verifyNoMoreInteractions();
}

18 View Complete Implementation : AsyncSubjectTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testSubscribeAfterCompleted() {
    AsyncSubject<String> subject = AsyncSubject.create();
    Subscriber<String> observer = TestHelper.mockSubscriber();
    subject.onNext("one");
    subject.onNext("two");
    subject.onNext("three");
    subject.onComplete();
    subject.subscribe(observer);
    verify(observer, times(1)).onNext("three");
    verify(observer, Mockito.never()).onError(any(Throwable.clreplaced));
    verify(observer, times(1)).onComplete();
}

18 View Complete Implementation : PublishSubjectTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testError() {
    PublishSubject<String> subject = PublishSubject.create();
    Subscriber<String> observer = TestHelper.mockSubscriber();
    subject.subscribe(observer);
    subject.onNext("one");
    subject.onNext("two");
    subject.onNext("three");
    subject.onError(testException);
    Subscriber<String> anotherSubscriber = TestHelper.mockSubscriber();
    subject.subscribe(anotherSubscriber);
    subject.onNext("four");
    subject.onError(new Throwable());
    subject.onComplete();
    replacedertErrorSubscriber(observer);
// todo bug?            replacedertNeverSubscriber(anotherSubscriber);
}

18 View Complete Implementation : BehaviorSubjectTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test(timeout = 1000)
public void testUnsubscriptionCase() {
    // FIXME was plain null which is not allowed
    BehaviorSubject<String> src = BehaviorSubject.createDefault("null");
    for (int i = 0; i < 10; i++) {
        final Subscriber<Object> o = TestHelper.mockSubscriber();
        InOrder inOrder = inOrder(o);
        String v = "" + i;
        src.onNext(v);
        System.out.printf("Turn: %d%n", i);
        src.first().flatMap(new Function<String, Observable<String>>() {

            @Override
            public Observable<String> apply(String t1) {
                return Observable.just(t1 + ", " + t1);
            }
        }).subscribe(new Observer<String>() {

            @Override
            public void onNext(String t) {
                o.onNext(t);
            }

            @Override
            public void onError(Throwable e) {
                o.onError(e);
            }

            @Override
            public void onComplete() {
                o.onComplete();
            }
        });
        inOrder.verify(o).onNext(v + ", " + v);
        inOrder.verify(o).onComplete();
        verify(o, never()).onError(any(Throwable.clreplaced));
    }
}

18 View Complete Implementation : OperatorFirstTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testFirstWithPredicateAndEmpty() {
    Observable<Integer> observable = Observable.just(1).filter(new Predicate<Integer>() {

        @Override
        public boolean test(Integer t1) {
            return t1 % 2 == 0;
        }
    }).first();
    Subscriber<Integer> observer = TestHelper.mockSubscriber();
    observable.subscribe(observer);
    InOrder inOrder = inOrder(observer);
    inOrder.verify(observer, times(1)).onError(isA(NoSuchElementException.clreplaced));
    inOrder.verifyNoMoreInteractions();
}

18 View Complete Implementation : AsyncSubjectTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testSubscribeAfterError() {
    AsyncSubject<String> subject = AsyncSubject.create();
    Subscriber<String> observer = TestHelper.mockSubscriber();
    subject.onNext("one");
    subject.onNext("two");
    subject.onNext("three");
    RuntimeException re = new RuntimeException("failed");
    subject.onError(re);
    subject.subscribe(observer);
    verify(observer, times(1)).onError(re);
    verify(observer, Mockito.never()).onNext(any(String.clreplaced));
    verify(observer, Mockito.never()).onComplete();
}

18 View Complete Implementation : OperatorTakeUntilPredicateTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void takeAll() {
    Subscriber<Object> o = TestHelper.mockSubscriber();
    Observable.just(1, 2).takeUntil(new Predicate<Integer>() {

        @Override
        public boolean test(Integer v) {
            return false;
        }
    }).subscribe(o);
    verify(o).onNext(1);
    verify(o).onNext(2);
    verify(o, never()).onError(any(Throwable.clreplaced));
    verify(o).onComplete();
}

18 View Complete Implementation : OperatorSkipTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testSkipMultipleObservers() {
    Observable<String> skip = Observable.just("one", "two", "three").skip(2);
    Subscriber<String> observer1 = TestHelper.mockSubscriber();
    skip.subscribe(observer1);
    Subscriber<String> observer2 = TestHelper.mockSubscriber();
    skip.subscribe(observer2);
    verify(observer1, times(1)).onNext(any(String.clreplaced));
    verify(observer1, never()).onError(any(Throwable.clreplaced));
    verify(observer1, times(1)).onComplete();
    verify(observer2, times(1)).onNext(any(String.clreplaced));
    verify(observer2, never()).onError(any(Throwable.clreplaced));
    verify(observer2, times(1)).onComplete();
}

18 View Complete Implementation : OperatorFirstTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testFirstOrDefaultWithOneElement() {
    Observable<Integer> observable = Observable.just(1).first(2);
    Subscriber<Integer> observer = TestHelper.mockSubscriber();
    observable.subscribe(observer);
    InOrder inOrder = inOrder(observer);
    inOrder.verify(observer, times(1)).onNext(1);
    inOrder.verify(observer, times(1)).onComplete();
    inOrder.verifyNoMoreInteractions();
}

18 View Complete Implementation : OperatorCastTest.java
Copyright Apache License 2.0
Author : akarnokd
@Test
public void testCast() {
    Observable<?> source = Observable.just(1, 2);
    Observable<Integer> observable = source.cast(Integer.clreplaced);
    Subscriber<Integer> observer = TestHelper.mockSubscriber();
    observable.subscribe(observer);
    verify(observer, times(1)).onNext(1);
    verify(observer, times(1)).onNext(1);
    verify(observer, never()).onError(org.mockito.Matchers.any(Throwable.clreplaced));
    verify(observer, times(1)).onComplete();
}