@Override public Publisher<Integer> apply(Integer t) { return Flowable.range(t, 2); } })
@Override public Flowable<Integer> apply(Integer v) { return Flowable.range(v, 2); } }).subscribe(ts);
@Override public Publisher<Integer> createPublisher(long elements) { return Flowable.range(0, (int)elements).timeout(1, TimeUnit.DAYS) ; } }
@Override public Publisher<Integer> createPublisher(long elements) { return Flowable.range(0, (int)elements).onBackpressureBuffer() ; } }
@Override public Publisher<Integer> createPublisher(long elements) { return Flowable.range(0, (int)elements).publish().autoConnect() ; } }
@Override public Publisher<Integer> createPublisher(final long elements) { return Flowable.range(1, 1000).reduce(new BiFunction<Integer, Integer, Integer>() { @Override public Integer apply(Integer a, Integer b) throws Exception { return a + b; } }).toFlowable() ; }
@Override public Publisher<Boolean> createPublisher(final long elements) { return Flowable.range(1, 1000).any(new Predicate<Integer>() { @Override public boolean test(Integer e) throws Exception { return e == 500; } }).toFlowable() ; }
@Override public Publisher<Integer> createPublisher(long elements) { return Flowable.range(0, (int)elements).doAfterNext(Functions.emptyConsumer()) ; } }
@SuppressWarnings("unchecked") @Test public void bufferTimeSkipDefault() { Flowable.range(1, 5).buffer(1, 1, TimeUnit.MINUTES) .test() .assertResult(Arrays.asList(1, 2, 3, 4, 5)); }
@Override public Flowable<Integer> apply(Integer t) { return Flowable.range(1, Flowable.bufferSize() * 2) .doOnNext(new Consumer<Integer>() { @Override public void accept(Integer t) { count.getAndIncrement(); } }).hide(); } }).subscribe(ts);
@Test public void range() { Flowable.range(1, 5) .throttleLatest(1, TimeUnit.MINUTES) .test() .assertResult(1); }
@Test public void rangeEmitLatest() { Flowable.range(1, 5) .throttleLatest(1, TimeUnit.MINUTES, true) .test() .assertResult(1, 5); }
@SuppressWarnings("unchecked") @Test public void badParallelismStage() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); Flowable.range(1, 10) .parallel(2) .subscribe(new Subscriber[] { ts }); ts.assertFailure(IllegalArgumentException.class); }
@Test public void awaitCountLess3() { Flowable.range(1, 4).delay(50, TimeUnit.MILLISECONDS) .test() .awaitCount(5, TestWaitStrategy.SLEEP_1MS) .assertResult(1, 2, 3, 4); }
@Test public void timedDefaultScheduler() { Flowable.range(1, 5).take(1, TimeUnit.MINUTES) .test() .awaitDone(5, TimeUnit.SECONDS) .assertResult(1, 2, 3, 4, 5); } }
@Test public void delayErrorCancelBackpressured() { TestSubscriber<Integer> ts = Flowable.range(1, 3) .parallel(1) .sequentialDelayError(1) .test(0); ts .cancel(); ts.assertEmpty(); }
@Test public void emptyInner() { Flowable.range(1, 5) .switchMap(Functions.justFunction(Flowable.empty())) .test() .assertResult(); }
@Test public void simple() { Flowable.range(1, 5) .concatMapCompletable(Functions.justFunction(Completable.complete())) .test() .assertResult(); }
@Test public void rangeSource() { TestSubscriber<Integer> ts = TestSubscriber.create(0); TestingDeferredScalarSubscriber ds = new TestingDeferredScalarSubscriber(ts); ds.subscribeTo(Flowable.range(1, 10)); ts.assertNoValues(); ts.request(1); ts.assertValue(10); ts.assertNoErrors(); ts.assertComplete(); }
@Test public void testBackpressure1() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); Flowable.range(1, 100000).takeLast(1) .observeOn(Schedulers.newThread()) .map(newSlowProcessor()).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); ts.assertValue(100000); }