@Override public Flowable<Integer> apply(Integer v) { return Flowable.just(v); } });
@Override public Flowable<Integer> apply(Object v) throws Exception { return Flowable.just(1); } }, 16));
@SuppressWarnings("unchecked") @Test public void concatIterableDelayErrorWithError() { Flowable.concatDelayError( Arrays.asList(Flowable.just(1), Flowable.just(2), Flowable.just(3).concatWith(Flowable.<Integer>error(new TestException())), Flowable.just(4))) .test() .assertFailure(TestException.class, 1, 2, 3, 4); }
@Override public Publisher<Integer> apply(Flowable<Object> f) throws Exception { return f.concatMapDelayError(Functions.justFunction(Flowable.just(2))); } });
@Test public void testSkipAndCountGaplessBuffers() { Flowable<String> source = Flowable.just("one", "two", "three", "four", "five"); Flowable<List<String>> buffered = source.buffer(3, 3); buffered.subscribe(subscriber); InOrder inOrder = Mockito.inOrder(subscriber); inOrder.verify(subscriber, Mockito.times(1)).onNext(list("one", "two", "three")); inOrder.verify(subscriber, Mockito.times(1)).onNext(list("four", "five")); inOrder.verify(subscriber, Mockito.never()).onNext(Mockito.<String>anyList()); inOrder.verify(subscriber, Mockito.never()).onError(Mockito.any(Throwable.class)); inOrder.verify(subscriber, Mockito.times(1)).onComplete(); }
@SuppressWarnings("unchecked") @Test public void skipSingleResult() { Flowable.just(1) .buffer(2, 3) .test() .assertResult(Arrays.asList(1)); }
@Test public void testUnsubscribeSource() throws Exception { Action unsubscribe = mock(Action.class); Flowable<Integer> f = Flowable.just(1).doOnCancel(unsubscribe).cache(); f.subscribe(); f.subscribe(); f.subscribe(); verify(unsubscribe, never()).run(); }
@Test(timeout = 5000) public void testIssue1935NoUnsubscribeDownstreamFlowable() { Flowable<Integer> source = Flowable.just(1).isEmpty() .flatMapPublisher(new Function<Boolean, Publisher<Integer>>() { @Override public Publisher<Integer> apply(Boolean t1) { return Flowable.just(2).delay(500, TimeUnit.MILLISECONDS); } }); assertEquals((Object)2, source.blockingFirst()); }
@Test public void concatMapJustSourceDelayError() { Flowable.just(0).hide() .concatMapDelayError(new Function<Object, Flowable<Integer>>() { @Override public Flowable<Integer> apply(Object v) throws Exception { return Flowable.just(1); } }, 16, false) .test() .assertResult(1); }
@Test public void concatMapEmptyDelayError() { Flowable.just(1).hide() .concatMapDelayError(Functions.justFunction(Flowable.empty())) .test() .assertResult(); }
@Test public void fusedCrash() { Flowable.range(1, 2) .map(new Function<Integer, Object>() { @Override public Object apply(Integer v) throws Exception { throw new TestException(); } }) .concatMap(Functions.justFunction(Flowable.just(1))) .test() .assertFailure(TestException.class); }
@Test public void callableCrashDelayError() { Flowable.just(1).hide() .concatMapDelayError(Functions.justFunction(Flowable.fromCallable(new Callable<Object>() { @Override public Object call() throws Exception { throw new TestException(); } }))) .test() .assertFailure(TestException.class); }
@Test public void error() { Flowable.error(new TestException()) .concatMapDelayError(Functions.justFunction(Flowable.just(2)), 16, false) .test() .assertFailure(TestException.class); }
@SuppressWarnings("unchecked") @Test public void testInnerError() { Flowable.concatArrayEager(Flowable.just(1), Flowable.error(new TestException())).subscribe(ts); ts.assertValue(1); ts.assertError(TestException.class); ts.assertNotComplete(); }
@Test public void concatMapInnerError() { Flowable.just(1).hide() .concatMap(Functions.justFunction(Flowable.error(new TestException()))) .test() .assertFailure(TestException.class); }
@Test public void scalarAndEmptyBackpressured() { TestSubscriber<Integer> ts = TestSubscriber.create(0); Flowable.just(1).concatWith(Flowable.<Integer>empty()).subscribe(ts); ts.assertNoValues(); ts.request(5); ts.assertValue(1); ts.assertComplete(); ts.assertNoErrors(); }