@Test(expected = NullPointerException.class) public void doOnNextNull() { just1.doOnNext(null); }
@Override public Observable<Integer> apply(Integer t) { return Observable.range(1, Observable.bufferSize() * 2) .doOnNext(new Consumer<Integer>() { @Override public void accept(Integer t) { count.getAndIncrement(); } }).hide(); } }).subscribe(ts);
@Test public void testDoOnEach() { final AtomicReference<String> r = new AtomicReference<String>(); String output = Observable.just("one").doOnNext(new Consumer<String>() { @Override public void accept(String v) { r.set(v); } }).blockingSingle(); assertEquals("one", output); assertEquals("one", r.get()); }
@Test public void testUpstreamIsProcessedButIgnored() { final int num = 10; final AtomicInteger upstreamCount = new AtomicInteger(); Object count = Observable.range(1, num) .doOnNext(new Consumer<Integer>() { @Override public void accept(Integer t) { upstreamCount.incrementAndGet(); } }) .ignoreElements() .blockingGet(); assertEquals(num, upstreamCount.get()); assertNull(count); }
@Test public void testTakeLastZeroProcessesAllItemsButIgnoresThem() { final AtomicInteger upstreamCount = new AtomicInteger(); final int num = 10; long count = Observable.range(1,num).doOnNext(new Consumer<Integer>() { @Override public void accept(Integer t) { upstreamCount.incrementAndGet(); }}) .takeLast(0).count().blockingGet(); assertEquals(num, upstreamCount.get()); assertEquals(0L, count); }
@SuppressWarnings("unchecked") @Test public void testEagerness9() { final AtomicInteger count = new AtomicInteger(); Observable<Integer> source = Observable.just(1).doOnNext(new Consumer<Integer>() { @Override public void accept(Integer t) { count.getAndIncrement(); } }).hide(); Observable.concatArrayEager(source, source, source, source, source, source, source, source, source).subscribe(ts); Assert.assertEquals(9, count.get()); ts.assertValueCount(count.get()); ts.assertNoErrors(); ts.assertComplete(); }
@SuppressWarnings("unchecked") @Test public void testEagerness3() { final AtomicInteger count = new AtomicInteger(); Observable<Integer> source = Observable.just(1).doOnNext(new Consumer<Integer>() { @Override public void accept(Integer t) { count.getAndIncrement(); } }).hide(); Observable.concatArrayEager(source, source, source).subscribe(ts); Assert.assertEquals(3, count.get()); ts.assertValueCount(count.get()); ts.assertNoErrors(); ts.assertComplete(); }
@SuppressWarnings("unchecked") @Test public void testEagerness8() { final AtomicInteger count = new AtomicInteger(); Observable<Integer> source = Observable.just(1).doOnNext(new Consumer<Integer>() { @Override public void accept(Integer t) { count.getAndIncrement(); } }).hide(); Observable.concatArrayEager(source, source, source, source, source, source, source, source).subscribe(ts); Assert.assertEquals(8, count.get()); ts.assertValueCount(count.get()); ts.assertNoErrors(); ts.assertComplete(); }
@SuppressWarnings("unchecked") @Test public void testEagerness2() { final AtomicInteger count = new AtomicInteger(); Observable<Integer> source = Observable.just(1).doOnNext(new Consumer<Integer>() { @Override public void accept(Integer t) { count.getAndIncrement(); } }).hide(); Observable.concatArrayEager(source, source).subscribe(ts); Assert.assertEquals(2, count.get()); ts.assertValueCount(count.get()); ts.assertNoErrors(); ts.assertComplete(); }
@SuppressWarnings("unchecked") @Test public void testEagerness7() { final AtomicInteger count = new AtomicInteger(); Observable<Integer> source = Observable.just(1).doOnNext(new Consumer<Integer>() { @Override public void accept(Integer t) { count.getAndIncrement(); } }).hide(); Observable.concatArrayEager(source, source, source, source, source, source, source).subscribe(ts); Assert.assertEquals(7, count.get()); ts.assertValueCount(count.get()); ts.assertNoErrors(); ts.assertComplete(); }
@SuppressWarnings("unchecked") @Test public void testEagerness6() { final AtomicInteger count = new AtomicInteger(); Observable<Integer> source = Observable.just(1).doOnNext(new Consumer<Integer>() { @Override public void accept(Integer t) { count.getAndIncrement(); } }).hide(); Observable.concatArrayEager(source, source, source, source, source, source).subscribe(ts); Assert.assertEquals(6, count.get()); ts.assertValueCount(count.get()); ts.assertNoErrors(); ts.assertComplete(); }
@SuppressWarnings("unchecked") @Test public void testEagerness4() { final AtomicInteger count = new AtomicInteger(); Observable<Integer> source = Observable.just(1).doOnNext(new Consumer<Integer>() { @Override public void accept(Integer t) { count.getAndIncrement(); } }).hide(); Observable.concatArrayEager(source, source, source, source).subscribe(ts); Assert.assertEquals(4, count.get()); ts.assertValueCount(count.get()); ts.assertNoErrors(); ts.assertComplete(); }
@SuppressWarnings("unchecked") @Test public void testEagerness5() { final AtomicInteger count = new AtomicInteger(); Observable<Integer> source = Observable.just(1).doOnNext(new Consumer<Integer>() { @Override public void accept(Integer t) { count.getAndIncrement(); } }).hide(); Observable.concatArrayEager(source, source, source, source, source).subscribe(ts); Assert.assertEquals(5, count.get()); ts.assertValueCount(count.get()); ts.assertNoErrors(); ts.assertComplete(); }
@Test public void testUpstreamIsProcessedButIgnoredObservable() { final int num = 10; final AtomicInteger upstreamCount = new AtomicInteger(); long count = Observable.range(1, num) .doOnNext(new Consumer<Integer>() { @Override public void accept(Integer t) { upstreamCount.incrementAndGet(); } }) .ignoreElements() .toObservable() .count().blockingGet(); assertEquals(num, upstreamCount.get()); assertEquals(0, count); }
@Test public void testWithCompletionCausingError() { TestObserver<Notification<Integer>> ts = new TestObserver<Notification<Integer>>(); final RuntimeException ex = new RuntimeException("boo"); Observable.<Integer>empty().materialize().doOnNext(new Consumer<Object>() { @Override public void accept(Object t) { throw ex; } }).subscribe(ts); ts.assertError(ex); ts.assertNoValues(); ts.assertTerminated(); }
@Test public void testWindowUnsubscribeOverlapping() { TestObserver<Integer> ts = new TestObserver<Integer>(); final AtomicInteger count = new AtomicInteger(); Observable.merge(Observable.range(1, 10000).doOnNext(new Consumer<Integer>() { @Override public void accept(Integer t1) { count.incrementAndGet(); } }).window(5, 4).take(2)).subscribe(ts); ts.awaitTerminalEvent(500, TimeUnit.MILLISECONDS); ts.assertTerminated(); // System.out.println(ts.getOnNextEvents()); ts.assertValues(1, 2, 3, 4, 5, 5, 6, 7, 8, 9); assertEquals(9, count.get()); }
@Test public void dispose() { TestHelper.checkDisposed(Observable.just(1).groupBy(Functions.justFunction(1))); Observable.just(1) .groupBy(Functions.justFunction(1)) .doOnNext(new Consumer<GroupedObservable<Integer, Integer>>() { @Override public void accept(GroupedObservable<Integer, Integer> g) throws Exception { TestHelper.checkDisposed(g); } }) .test(); }
@Test public void testReentrantTake() { final PublishSubject<Integer> source = PublishSubject.create(); TestObserver<Integer> ts = new TestObserver<Integer>(); source.take(1).doOnNext(new Consumer<Integer>() { @Override public void accept(Integer v) { source.onNext(2); } }).subscribe(ts); source.onNext(1); ts.assertValue(1); ts.assertNoErrors(); ts.assertComplete(); }
@SuppressWarnings("unchecked") @Test public void errorSkipInner() { @SuppressWarnings("rawtypes") final TestObserver[] to = { null }; Observable.just(1).concatWith(Observable.<Integer>error(new TestException())) .window(2, 3) .doOnNext(new Consumer<Observable<Integer>>() { @Override public void accept(Observable<Integer> w) throws Exception { to[0] = w.test(); } }) .test() .assertError(TestException.class); to[0].assertFailure(TestException.class, 1); }
@Test public void delayError() { Observable.range(1, 5).concatWith(Observable.<Integer>error(new TestException())) .observeOn(Schedulers.computation(), true) .doOnNext(new Consumer<Integer>() { @Override public void accept(Integer v) throws Exception { if (v == 1) { Thread.sleep(100); } } }) .test() .awaitDone(5, TimeUnit.SECONDS) .assertFailure(TestException.class, 1, 2, 3, 4, 5); }