@Test(timeout = 5000) public void ambIterableOneThrows() { Completable.amb(Collections.singleton(error.completable)) .test() .assertError(TestException.class); }
@Test(timeout = 5000) public void ambIterableManyOneThrows() { Completable.amb(Arrays.asList(error.completable, normal.completable)) .test() .assertError(TestException.class); }
@Test public void callbackThrows() { Completable.create(new CompletableOnSubscribe() { @Override public void subscribe(CompletableEmitter e) throws Exception { throw new TestException(); } }) .test() .assertFailure(TestException.class); }
@Test(timeout = 5000) public void ambArraySingleError() { Completable.ambArray(error.completable) .test() .assertError(TestException.class); }
@Test(timeout = 5000) public void ambMultipleOneIsNull() { Completable.ambArray(null, normal.completable) .test() .assertError(NullPointerException.class); }
@Test public void ambIterableIterableThrows() { Completable.amb(new Iterable<Completable>() { @Override public Iterator<Completable> iterator() { throw new TestException(); } }).test().assertError(TestException.class); }
@Test public void fromPublisher() { Completable.fromPublisher(Flowable.just(1)) .test() .assertResult(); }
@Test public void fromPublisherEmpty() { Completable.fromPublisher(Flowable.empty()) .test() .assertResult(); }
@Test public void fromMaybeEmpty() { Completable.fromMaybe(Maybe.<Integer>empty()) .test() .assertResult(); }
@Test public void errorToCompletable() { Maybe.error(new TestException()) .ignoreElement() .test() .assertFailure(TestException.class); }
@Test public void normalError() { Completable.error(new TestException()) .doFinally(this) .test() .assertFailure(TestException.class); assertEquals(1, calls); }
@Test public void simple() { Observable.range(1, 5) .concatMapCompletable(Functions.justFunction(Completable.complete())) .test() .assertResult(); }
@Test public void unboundedIn() { Completable.concat(Flowable.just(Completable.complete()).hide(), Integer.MAX_VALUE) .test() .assertResult(); }
@Test public void asyncFusedUnboundedIn() { UnicastProcessor<Completable> up = UnicastProcessor.create(); up.onNext(Completable.complete()); up.onComplete(); Completable.concat(up, Integer.MAX_VALUE) .test() .assertResult(); }
@Test public void innerError() { Flowable.just(1) .concatMapCompletable(Functions.justFunction(Completable.error(new TestException()))) .test() .assertFailure(TestException.class); }
@Test public void scalarEmptySource() { CompletableSubject cs = CompletableSubject.create(); Observable.empty() .switchMapCompletable(Functions.justFunction(cs)) .test() .assertResult(); assertFalse(cs.hasObservers()); }
@Test public void andThenCompletableCompleteError() { Completable.complete() .andThen(Completable.error(new TestException("test"))) .test() .assertNotComplete() .assertNoValues() .assertError(TestException.class) .assertErrorMessage("test"); }
@Test public void andThenCompletableErrorComplete() { Completable.error(new TestException("bla")) .andThen(Completable.complete()) .test() .assertNotComplete() .assertNoValues() .assertError(TestException.class) .assertErrorMessage("bla"); }
@Test public void dispose() { PublishProcessor<Integer> pp1 = PublishProcessor.create(); PublishProcessor<Integer> pp2 = PublishProcessor.create(); TestObserver<Void> to = Completable.amb(Arrays.asList(pp1.ignoreElements(), pp2.ignoreElements())) .test(); assertTrue(pp1.hasSubscribers()); assertTrue(pp2.hasSubscribers()); to.dispose(); assertFalse(pp1.hasSubscribers()); assertFalse(pp2.hasSubscribers()); }
@Test public void untilCompletableOtherOnComplete() { CompletableSubject main = CompletableSubject.create(); CompletableSubject other = CompletableSubject.create(); TestObserver<Void> to = main.ambWith(other).test(); assertTrue("Main no observers?", main.hasObservers()); assertTrue("Other no observers?", other.hasObservers()); other.onComplete(); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasObservers()); to.assertResult(); }