@Override public Flowable<Object> apply(Flowable<Object> f) throws Exception { return f.observeOn(new TestScheduler()); } });
@Test(expected = IllegalArgumentException.class) public void testMapWithIssue417() { Flowable.just(1).observeOn(Schedulers.computation()) .map(new Function<Integer, Integer>() { @Override public Integer apply(Integer arg0) { throw new IllegalArgumentException("any error"); } }).blockingSingle(); }
@Test(timeout = 500) public void testWithObserveOn() throws InterruptedException { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); Flowable.range(0, Flowable.bufferSize() * 10).onBackpressureDrop().observeOn(Schedulers.io()).subscribe(ts); ts.awaitTerminalEvent(); }
@Test public void workerNotDisposedPrematurelyNormalInAsyncOut() { DisposeTrackingScheduler s = new DisposeTrackingScheduler(); TestSubscriber<Integer> ts = new TestSubscriberFusedCanceling(); Flowable.just(1).hide().observeOn(s).subscribe(ts); assertEquals(1, s.disposedCount.get()); }
@Test public void workerNotDisposedPrematurelySyncInNormalOut() { DisposeTrackingScheduler s = new DisposeTrackingScheduler(); Flowable.concat( Flowable.just(1).observeOn(s), Flowable.just(2) ) .test() .assertResult(1, 2); assertEquals(1, s.disposedCount.get()); }
@Test public void inputSyncFused() { Flowable.range(1, 5) .observeOn(Schedulers.single()) .test() .awaitDone(5, TimeUnit.SECONDS) .assertResult(1, 2, 3, 4, 5); }
@Test public void workerNotDisposedPrematurelySyncInNormalOutConditional() { DisposeTrackingScheduler s = new DisposeTrackingScheduler(); Flowable.concat( Flowable.just(1).observeOn(s).filter(Functions.alwaysTrue()), Flowable.just(2) ) .test() .assertResult(1, 2); assertEquals(1, s.disposedCount.get()); }
@Test public void request1Conditional() { Flowable.range(1, 10).hide() .observeOn(ImmediateThinScheduler.INSTANCE) .filter(Functions.alwaysTrue()) .test(1L) .assertValue(1); }
@Test public void workerNotDisposedPrematurelyNormalInNormalOutConditional() { DisposeTrackingScheduler s = new DisposeTrackingScheduler(); Flowable.concat( Flowable.just(1).hide().observeOn(s).filter(Functions.alwaysTrue()), Flowable.just(2) ) .test() .assertResult(1, 2); assertEquals(1, s.disposedCount.get()); }
@Test public void bufferSizesWork() { for (int i = 1; i <= 1024; i = i * 2) { TestSubscriber<Integer> ts = TestSubscriber.create(); Flowable.range(1, 1000 * 1000).observeOn(Schedulers.computation(), false, i) .subscribe(ts); ts.awaitTerminalEvent(); ts.assertValueCount(1000 * 1000); ts.assertComplete(); ts.assertNoErrors(); } }
@Test public void outputFusedReject() { TestSubscriber<Integer> ts = SubscriberFusion.newTest(QueueFuseable.SYNC); Flowable.range(1, 5).hide() .observeOn(Schedulers.single()) .subscribe(ts); SubscriberFusion.assertFusion(ts, QueueFuseable.NONE) .awaitDone(5, TimeUnit.SECONDS) .assertResult(1, 2, 3, 4, 5); }
@Test public void backFusedErrorConditional() { TestSubscriber<Integer> ts = SubscriberFusion.newTest(QueueFuseable.ANY); Flowable.<Integer>error(new TestException()) .observeOn(ImmediateThinScheduler.INSTANCE) .filter(Functions.alwaysTrue()) .subscribe(ts); SubscriberFusion.assertFusion(ts, QueueFuseable.ASYNC) .assertFailure(TestException.class); }
@Test public void backFusedConditional() { TestSubscriber<Integer> ts = SubscriberFusion.newTest(QueueFuseable.ANY); Flowable.range(1, 100).hide() .observeOn(ImmediateThinScheduler.INSTANCE) .filter(Functions.alwaysTrue()) .subscribe(ts); SubscriberFusion.assertFusion(ts, QueueFuseable.ASYNC) .assertValueCount(100) .assertComplete() .assertNoErrors(); }
@Test public void testErrorDelayedAsync() { Flowable<Integer> source = Flowable.just(1, 2, 3) .concatWith(Flowable.<Integer>error(new TestException())); TestSubscriber<Integer> ts = TestSubscriber.create(); source.observeOn(Schedulers.computation(), true).subscribe(ts); ts.awaitTerminalEvent(2, TimeUnit.SECONDS); ts.assertValues(1, 2, 3); ts.assertError(TestException.class); ts.assertNotComplete(); }
@Test public void testSkipLastWithBackpressure() { Flowable<Integer> f = Flowable.range(0, Flowable.bufferSize() * 2).skipLast(Flowable.bufferSize() + 10); TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); f.observeOn(Schedulers.computation()).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); assertEquals((Flowable.bufferSize()) - 10, ts.valueCount()); }
@Test public void testBackpressure2() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); Flowable.range(1, 100000).takeLast(Flowable.bufferSize() * 4) .observeOn(Schedulers.newThread()).map(newSlowProcessor()).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); assertEquals(Flowable.bufferSize() * 4, ts.valueCount()); }
@Test public void testInnerBackpressureWithAlignedBoundaries() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); Flowable.range(0, Flowable.bufferSize() * 2) .concatWith(Flowable.range(0, Flowable.bufferSize() * 2)) .observeOn(Schedulers.computation()) // observeOn has a backpressured RxRingBuffer .subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); assertEquals(Flowable.bufferSize() * 4, ts.valueCount()); }