@Override public ObservableSource<Object> apply(Observable<Object> o) throws Exception { return o.observeOn(new TestScheduler()); } });
@Override public ObservableSource<R> apply(Observable<T> t) throws Exception { ObservableSource<R> apply = ObjectHelper.requireNonNull(selector.apply(t), "The selector returned a null ObservableSource"); return Observable.wrap(apply).observeOn(scheduler); } }
@Override public ObservableSource<? extends Object> apply(Integer v) throws Exception { return Observable.just(2).hide() .observeOn(Schedulers.single()) .map(new Function<Integer, Object>() { @Override public Object apply(Integer w) throws Exception { return Thread.currentThread().getName(); } }); } })
/** * This is testing a no-op path since it uses Schedulers.immediate() which will not do scheduling. */ @Test public void testObserveOn() { Observer<Integer> observer = TestHelper.mockObserver(); Observable.just(1, 2, 3).observeOn(ImmediateThinScheduler.INSTANCE).subscribe(observer); verify(observer, times(1)).onNext(1); verify(observer, times(1)).onNext(2); verify(observer, times(1)).onNext(3); verify(observer, times(1)).onComplete(); }
@Test(expected = IllegalArgumentException.class) public void testMapWithIssue417() { Observable.just(1).observeOn(Schedulers.computation()) .map(new Function<Integer, Integer>() { @Override public Integer apply(Integer arg0) { throw new IllegalArgumentException("any error"); } }).blockingSingle(); }
@Test public void testDelayedErrorDeliveryWhenSafeSubscriberUnsubscribes() { TestScheduler testScheduler = new TestScheduler(); Observable<Integer> source = Observable.concat(Observable.<Integer> error(new TestException()), Observable.just(1)); Observer<Integer> o = TestHelper.mockObserver(); InOrder inOrder = inOrder(o); source.observeOn(testScheduler).subscribe(o); inOrder.verify(o, never()).onError(any(TestException.class)); testScheduler.advanceTimeBy(1, TimeUnit.SECONDS); inOrder.verify(o).onError(any(TestException.class)); inOrder.verify(o, never()).onNext(anyInt()); inOrder.verify(o, never()).onComplete(); }
@Test public void workerNotDisposedPrematurelyNormalInAsyncOut() { DisposeTrackingScheduler s = new DisposeTrackingScheduler(); TestObserver<Integer> to = new TestObserverFusedCanceling(); Observable.just(1).hide().observeOn(s).subscribe(to); assertEquals(1, s.disposedCount.get()); }
@Test public void trampolineScheduler() { Observable.just(1) .observeOn(Schedulers.trampoline()) .test() .assertResult(1); }
@Test public void workerNotDisposedPrematurelySyncInNormalOut() { DisposeTrackingScheduler s = new DisposeTrackingScheduler(); Observable.concat( Observable.just(1).observeOn(s), Observable.just(2) ) .test() .assertResult(1, 2); assertEquals(1, s.disposedCount.get()); }
@Test public void workerNotDisposedPrematurelyNormalInNormalOut() { DisposeTrackingScheduler s = new DisposeTrackingScheduler(); Observable.concat( Observable.just(1).hide().observeOn(s), Observable.just(2) ) .test() .assertResult(1, 2); assertEquals(1, s.disposedCount.get()); }
@Test public void testBackpressure1() { TestObserver<Integer> to = new TestObserver<Integer>(); Observable.range(1, 100000).takeLast(1) .observeOn(Schedulers.newThread()) .map(newSlowProcessor()).subscribe(to); to.awaitTerminalEvent(); to.assertNoErrors(); to.assertValue(100000); }
@Test public void testAsynchronousRun() { Observable.range(1, 2).concatMapEager(new Function<Integer, Observable<Integer>>() { @Override public Observable<Integer> apply(Integer t) { return Observable.range(1, 1000).subscribeOn(Schedulers.computation()); } }).observeOn(Schedulers.newThread()).subscribe(to); to.awaitTerminalEvent(5, TimeUnit.SECONDS); to.assertNoErrors(); to.assertValueCount(2000); }
@Test public void asyncFused() { Observable.just(1).hide() .switchMap(Functions.justFunction( Observable.range(1, 5) .observeOn(ImmediateThinScheduler.INSTANCE) )) .test() .assertResult(1, 2, 3, 4, 5); }
@Test public void outputFused() { TestObserver<Integer> to = ObserverFusion.newTest(QueueFuseable.ANY); Observable.range(1, 5).hide() .observeOn(Schedulers.single()) .subscribe(to); ObserverFusion.assertFusion(to, QueueFuseable.ASYNC) .awaitDone(5, TimeUnit.SECONDS) .assertResult(1, 2, 3, 4, 5); }
@Test public void outputFusedReject() { TestObserver<Integer> to = ObserverFusion.newTest(QueueFuseable.SYNC); Observable.range(1, 5).hide() .observeOn(Schedulers.single()) .subscribe(to); ObserverFusion.assertFusion(to, QueueFuseable.NONE) .awaitDone(5, TimeUnit.SECONDS) .assertResult(1, 2, 3, 4, 5); }
@Test public void inputSyncFused() { Observable.range(1, 5) .observeOn(Schedulers.single()) .test() .awaitDone(5, TimeUnit.SECONDS) .assertResult(1, 2, 3, 4, 5); }
@Test public void testBackpressure2() { TestObserver<Integer> to = new TestObserver<Integer>(); Observable.range(1, 100000).takeLast(Flowable.bufferSize() * 4) .observeOn(Schedulers.newThread()).map(newSlowProcessor()).subscribe(to); to.awaitTerminalEvent(); to.assertNoErrors(); assertEquals(Flowable.bufferSize() * 4, to.valueCount()); }
@Test public void testSkipLastWithBackpressure() { Observable<Integer> o = Observable.range(0, Flowable.bufferSize() * 2).skipLast(Flowable.bufferSize() + 10); TestObserver<Integer> to = new TestObserver<Integer>(); o.observeOn(Schedulers.computation()).subscribe(to); to.awaitTerminalEvent(); to.assertNoErrors(); assertEquals((Flowable.bufferSize()) - 10, to.valueCount()); }
@Test public void observeOn() { Observable.range(1, 1000) .takeLast(1, TimeUnit.DAYS) .take(500) .observeOn(Schedulers.single(), true, 1) .test() .awaitDone(5, TimeUnit.SECONDS) .assertSubscribed() .assertValueCount(500) .assertNoErrors() .assertComplete(); }