@Override public Observable<Object> apply(Completable c) { return c.toObservable(); } });
@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);
/** * Returns a Completable that repeatedly subscribes to this Completable until cancelled. * <dl> * <dt><b>Scheduler:</b></dt> * <dd>{@code repeat} does not operate by default on a particular {@link Scheduler}.</dd> * </dl> * @return the new Completable instance */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Completable repeat() { return fromObservable(toObservable().repeat()); }
/** * Returns a Completable that retries this Completable as long as it emits an onError event. * <dl> * <dt><b>Scheduler:</b></dt> * <dd>{@code retry} does not operate by default on a particular {@link Scheduler}.</dd> * </dl> * @return the new Completable instance */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Completable retry() { return fromObservable(toObservable().retry()); }
/** * Returns a Completable that retries this Completable as long as it emits an onError event. * <dl> * <dt><b>Scheduler:</b></dt> * <dd>{@code retry} does not operate by default on a particular {@link Scheduler}.</dd> * </dl> * @return the new Completable instance */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Completable retry() { return fromObservable(toObservable().retry()); }
@Test(expected = NullPointerException.class) public void subscribeObserverNull() { normal.completable.toObservable().subscribe((Observer<Object>)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(timeout = 5000) public void toObservableNormal() { normal.completable.toObservable().blockingForEach(Functions.emptyConsumer()); }
@Test(timeout = 5000, expected = TestException.class) public void toObservableError() { error.completable.toObservable().blockingForEach(Functions.emptyConsumer()); }
@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 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> pp = PublishSubject.create(); TestObserver<Integer> ts = pp.ignoreElements().<Integer>toObservable().test(); assertTrue(pp.hasObservers()); ts.cancel(); assertFalse(pp.hasObservers()); TestHelper.checkDisposed(pp.ignoreElements().<Integer>toObservable()); }
@Test(timeout = 5000) public void subscribeObserverNormal() { TestObserver<Object> ts = new TestObserver<Object>(); normal.completable.toObservable().subscribe(ts); ts.assertComplete(); ts.assertNoValues(); ts.assertNoErrors(); }
@Test(timeout = 5000) public void subscribeObserverError() { TestObserver<Object> ts = new TestObserver<Object>(); error.completable.toObservable().subscribe(ts); ts.assertNotComplete(); ts.assertNoValues(); ts.assertError(TestException.class); }
@Test public void normalAsyncObservable() { Observable.range(1, 1000) .flatMapCompletable(new Function<Integer, CompletableSource>() { @Override public CompletableSource apply(Integer v) throws Exception { return Observable.range(1, 100).subscribeOn(Schedulers.computation()).ignoreElements(); } }).toObservable() .test() .awaitDone(5, TimeUnit.SECONDS) .assertResult(); }
@Test public void dispose() { TestHelper.checkDisposed(Observable.just(1).ignoreElements()); TestHelper.checkDisposed(Observable.just(1).ignoreElements().toObservable()); } }
@Test public void testCompletedOkObservable() { TestObserver<Object> ts = new TestObserver<Object>(); Observable.range(1, 10).ignoreElements().toObservable().subscribe(ts); ts.assertNoErrors(); ts.assertNoValues(); ts.assertTerminated(); // FIXME no longer testable // ts.assertUnsubscribed(); }
@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); }
@Test public void testErrorReceivedObservable() { TestObserver<Object> ts = new TestObserver<Object>(); TestException ex = new TestException("boo"); Observable.error(ex).ignoreElements().toObservable().subscribe(ts); ts.assertNoValues(); ts.assertTerminated(); // FIXME no longer testable // ts.assertUnsubscribed(); ts.assertError(TestException.class); ts.assertErrorMessage("boo"); }