@Override public Publisher<?> apply(Completable c) throws Exception { return c.toFlowable(); } });
@Override public Flowable<Object> apply(Completable c) { return c.toFlowable(); } })
@Override public Flowable<Integer> apply(Completable v) { return v.toFlowable(); } })
@Override public Flowable<Object> apply(Flowable<Object> f) throws Exception { return f.ignoreElements().toFlowable(); } });
@Override public Publisher<Integer> createPublisher(final long elements) { return Flowable.range(1, 1000).ignoreElements().<Integer>toFlowable() ; }
@Test public void testHookSubscribeStart() throws Exception { TestSubscriber<String> ts = new TestSubscriber<String>(); Completable completable = Completable.unsafeCreate(new CompletableSource() { @Override public void subscribe(CompletableObserver observer) { observer.onComplete(); } }); completable.<String>toFlowable().subscribe(ts); verify(onStart, times(1)).apply(eq(completable), any(CompletableObserver.class)); }
@Test public void testIgnoreElementsFlowable() { Flowable<Integer> flowable = Flowable.just(1, 2, 3).ignoreElements().toFlowable(); Subscriber<Object> subscriber = TestHelper.mockSubscriber(); flowable.subscribe(subscriber); verify(subscriber, never()).onNext(any(Integer.class)); verify(subscriber, never()).onError(any(Throwable.class)); verify(subscriber, times(1)).onComplete(); }
@Test public void disposedFlowable() { TestHelper.checkDisposed(Flowable.range(1, 10) .flatMapCompletable(new Function<Integer, CompletableSource>() { @Override public CompletableSource apply(Integer v) throws Exception { return Completable.complete(); } }).toFlowable()); }
@Test public void testErrorObservable() { TestSubscriber<String> subscriber = TestSubscriber.create(); IllegalArgumentException error = new IllegalArgumentException("Error"); Completable cmp = Flowable.<String>error(error).ignoreElements(); cmp.<String>toFlowable().subscribe(subscriber); subscriber.assertError(error); subscriber.assertNoValues(); }
@Test public void normalFlowable() { Flowable.range(1, 10) .flatMapCompletable(new Function<Integer, CompletableSource>() { @Override public CompletableSource apply(Integer v) throws Exception { return Completable.complete(); } }).toFlowable() .test() .assertResult(); }
@Test public void normalDelayErrorFlowable() { Flowable.range(1, 10) .flatMapCompletable(new Function<Integer, CompletableSource>() { @Override public CompletableSource apply(Integer v) throws Exception { return Completable.complete(); } }, true, Integer.MAX_VALUE).toFlowable() .test() .assertResult(); }
@Test(timeout = 5000) public void subscribeSubscriberError() { TestSubscriber<Object> ts = new TestSubscriber<Object>(); error.completable.toFlowable().subscribe(ts); ts.assertNotComplete(); ts.assertNoValues(); ts.assertError(TestException.class); }
@Test public void testNeverObservable() { TestSubscriber<String> subscriber = TestSubscriber.create(); Completable cmp = Flowable.<String>never().ignoreElements(); cmp.<String>toFlowable().subscribe(subscriber); subscriber.assertNotTerminated(); subscriber.assertNoValues(); }
@Test public void testJustTwoEmissionsObservableThrowsError() { TestSubscriber<String> subscriber = TestSubscriber.create(); Completable cmp = Flowable.just("First", "Second").ignoreElements(); cmp.<String>toFlowable().subscribe(subscriber); subscriber.assertNoErrors(); subscriber.assertNoValues(); }
@Test public void dispose() { TestHelper.checkDisposed(Flowable.just(1).ignoreElements()); TestHelper.checkDisposed(Flowable.just(1).ignoreElements().toFlowable()); }
@Test public void testEmptyObservable() { TestSubscriber<String> subscriber = TestSubscriber.create(); Completable cmp = Flowable.<String>empty().ignoreElements(); cmp.<String>toFlowable().subscribe(subscriber); subscriber.assertNoErrors(); subscriber.assertNoValues(); subscriber.assertComplete(); }
@Test public void normalNonDelayErrorOuterFlowable() { Flowable.range(1, 10).concatWith(Flowable.<Integer>error(new TestException())) .flatMapCompletable(new Function<Integer, CompletableSource>() { @Override public CompletableSource apply(Integer v) throws Exception { return Completable.complete(); } }, false, Integer.MAX_VALUE).toFlowable() .test() .assertFailure(TestException.class); }
@Test public void testJustSingleItemObservable() { TestSubscriber<String> subscriber = TestSubscriber.create(); Completable cmp = Flowable.just("Hello World!").ignoreElements(); cmp.<String>toFlowable().subscribe(subscriber); subscriber.assertNoValues(); subscriber.assertComplete(); subscriber.assertNoErrors(); }
@Test public void testErrorReceivedFlowable() { TestSubscriber<Object> ts = new TestSubscriber<Object>(); TestException ex = new TestException("boo"); Flowable.error(ex).ignoreElements().toFlowable().subscribe(ts); ts.assertNoValues(); ts.assertTerminated(); ts.assertError(TestException.class); ts.assertErrorMessage("boo"); }
@Test public void fused() { TestSubscriber<Integer> ts = SubscriberFusion.newTest(QueueFuseable.ANY); Flowable.just(1).hide().ignoreElements().<Integer>toFlowable() .subscribe(ts); ts.assertOf(SubscriberFusion.<Integer>assertFuseable()) .assertOf(SubscriberFusion.<Integer>assertFusionMode(QueueFuseable.ASYNC)) .assertResult(); }