@Override public Observable<?> apply(Completable c) throws Exception { return c.toObservable(); } });
@Test(expected = NullPointerException.class) public void subscribeObserverNull() { normal.completable.toObservable().subscribe((Observer<Object>)null); }
@Override public Object apply(Observable<Integer> o) throws Exception { return o.flatMapCompletable(new Function<Integer, CompletableSource>() { @Override public CompletableSource apply(Integer v) throws Exception { return Completable.complete(); } }).toObservable(); } }, false, 1, null);
@Test public void testIgnoreElementsObservable() { Observable<Integer> o = Observable.just(1, 2, 3).ignoreElements().toObservable(); Observer<Object> observer = TestHelper.mockObserver(); o.subscribe(observer); verify(observer, never()).onNext(any(Integer.class)); verify(observer, never()).onError(any(Throwable.class)); verify(observer, times(1)).onComplete(); }
@Test public void dispose() { TestHelper.checkDisposed(Observable.just(1).ignoreElements()); TestHelper.checkDisposed(Observable.just(1).ignoreElements().toObservable()); } }
@Test(timeout = 5000, expected = TestException.class) public void toObservableError() { error.completable.toObservable().blockingForEach(Functions.emptyConsumer()); }
@Test(timeout = 5000) public void toObservableNormal() { normal.completable.toObservable().blockingForEach(Functions.emptyConsumer()); }
@Test public void testUnsubscribesFromUpstreamObservable() { final AtomicBoolean unsub = new AtomicBoolean(); Observable.range(1, 10).concatWith(Observable.<Integer>never()) .doOnDispose(new Action() { @Override public void run() { unsub.set(true); }}) .ignoreElements() .toObservable() .subscribe() .dispose(); assertTrue(unsub.get()); }
@Test(timeout = 5000) public void subscribeObserverNormal() { TestObserver<Object> to = new TestObserver<Object>(); normal.completable.toObservable().subscribe(to); to.assertComplete(); to.assertNoValues(); to.assertNoErrors(); }
@Test(timeout = 5000) public void subscribeObserverError() { TestObserver<Object> to = new TestObserver<Object>(); error.completable.toObservable().subscribe(to); to.assertNotComplete(); to.assertNoValues(); to.assertError(TestException.class); }
@Test public void testWithNonEmptyObservable() { assertTrue(Observable.just(1, 2, 3).ignoreElements().toObservable().isEmpty().blockingGet()); }
@Test public void disposedObservable() { TestHelper.checkDisposed(Observable.range(1, 10) .flatMapCompletable(new Function<Integer, CompletableSource>() { @Override public CompletableSource apply(Integer v) throws Exception { return Completable.complete(); } }).toObservable()); }
@Test public void normalObservable() { Observable.range(1, 10) .flatMapCompletable(new Function<Integer, CompletableSource>() { @Override public CompletableSource apply(Integer v) throws Exception { return Completable.complete(); } }).toObservable() .test() .assertResult(); }
@Test public void testCompletedOkObservable() { TestObserver<Object> to = new TestObserver<Object>(); Observable.range(1, 10).ignoreElements().toObservable().subscribe(to); to.assertNoErrors(); to.assertNoValues(); to.assertTerminated(); // FIXME no longer testable // ts.assertUnsubscribed(); }
@Test public void normalDelayErrorObservable() { Observable.range(1, 10) .flatMapCompletable(new Function<Integer, CompletableSource>() { @Override public CompletableSource apply(Integer v) throws Exception { return Completable.complete(); } }, true).toObservable() .test() .assertResult(); }
@Test public void cancel() { PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = ps.ignoreElements().<Integer>toObservable().test(); assertTrue(ps.hasObservers()); to.cancel(); assertFalse(ps.hasObservers()); TestHelper.checkDisposed(ps.ignoreElements().<Integer>toObservable()); }
@Test public void testWithEmptyObservable() { assertTrue(Observable.empty().ignoreElements().toObservable().isEmpty().blockingGet()); }
@Test public void testErrorReceivedObservable() { TestObserver<Object> to = new TestObserver<Object>(); TestException ex = new TestException("boo"); Observable.error(ex).ignoreElements().toObservable().subscribe(to); to.assertNoValues(); to.assertTerminated(); // FIXME no longer testable // ts.assertUnsubscribed(); to.assertError(TestException.class); to.assertErrorMessage("boo"); }
@Test public void syncFusedCompletable() { Observable.range(1, 5).hide() .switchMap(Functions.justFunction( Completable.complete().toObservable() )) .test() .assertResult(); }
@Test public void normalNonDelayErrorOuterObservable() { Observable.range(1, 10).concatWith(Observable.<Integer>error(new TestException())) .flatMapCompletable(new Function<Integer, CompletableSource>() { @Override public CompletableSource apply(Integer v) throws Exception { return Completable.complete(); } }, false).toObservable() .test() .assertFailure(TestException.class); }