@Override public Publisher<Integer> apply(Flowable<Integer> f) throws Exception { return f.subscribeOn(Schedulers.single()); } });
@Override public Publisher<Integer> apply(Integer i) { return incrementingIntegers(new AtomicInteger()) .take(10) .subscribeOn(Schedulers.computation()); } }
@Override public Flowable<Integer> apply(Integer t1) { return composer(Flowable.range(t1 * 10, 2), subscriptionCount, m) .subscribeOn(Schedulers.computation()); } }, m);
@Override public Flowable<Integer> apply(Integer t1) { return composer(Flowable.range(t1 * 10, 2), subscriptionCount, m) .subscribeOn(Schedulers.computation()); } }, new BiFunction<Integer, Integer, Integer>() {
@Override public Flowable<Integer> apply(Integer t) { return Flowable.just(1).subscribeOn(Schedulers.computation()); } }).subscribe(ts);
@Override public Flowable<Integer> apply(Integer t) { return Flowable.range(1, 1000).subscribeOn(Schedulers.computation()); } }).observeOn(Schedulers.single())
@Override public Flowable<String> apply(Integer id) { return Flowable.fromIterable(Arrays.asList("a-" + id, "b-" + id)).subscribeOn(getScheduler()) .map(new Function<String, String>() { @Override public String apply(String s) { return "names=>" + s; } }); }
@Test(/* timeout = 1000, */expected = RuntimeException.class) public void testHasNextThrows() { TestScheduler scheduler = new TestScheduler(); Flowable<Long> source = Flowable.<Long> error(new RuntimeException("Forced failure!")).subscribeOn(scheduler); Iterable<Long> iter = source.blockingLatest(); Iterator<Long> it = iter.iterator(); scheduler.advanceTimeBy(1, TimeUnit.SECONDS); it.hasNext(); }
@Test(timeout = 1000, expected = RuntimeException.class) public void testNextThrows() { TestScheduler scheduler = new TestScheduler(); Flowable<Long> source = Flowable.<Long> error(new RuntimeException("Forced failure!")).subscribeOn(scheduler); Iterable<Long> iter = source.blockingLatest(); Iterator<Long> it = iter.iterator(); scheduler.advanceTimeBy(1, TimeUnit.SECONDS); it.next(); }
@Override public CompletableSource apply(Integer v) throws Exception { return Flowable.range(1, 100).subscribeOn(Schedulers.computation()).ignoreElements(); } }, false, 3)
@Override public CompletableSource apply(Integer v) throws Exception { return Flowable.range(1, 100).subscribeOn(Schedulers.computation()).ignoreElements(); } }).toFlowable()
@Override public CompletableSource apply(Integer v) throws Exception { return Flowable.range(1, 100).subscribeOn(Schedulers.computation()).ignoreElements(); } }, false, 3).toFlowable()
@Override public CompletableSource apply(Integer v) throws Exception { return Flowable.range(1, 100).subscribeOn(Schedulers.computation()).ignoreElements(); } })
@Test public void blockingFirstDefault() { assertEquals(1, Flowable.<Integer>empty() .subscribeOn(Schedulers.computation()).blockingFirst(1).intValue()); }
@Test public void blockingFirst() { assertEquals(1, Flowable.range(1, 10) .subscribeOn(Schedulers.computation()).blockingFirst().intValue()); }
@Test(timeout = 2000) public void testRepeatTake() { Flowable<Integer> xs = Flowable.just(1, 2); Object[] ys = xs.repeat().subscribeOn(Schedulers.newThread()).take(4).toList().blockingGet().toArray(); assertArrayEquals(new Object[] { 1, 2, 1, 2 }, ys); }
@Test public void inputOutputSubscribeRace2() { Flowable<Integer> source = Flowable.just(1).subscribeOn(Schedulers.single()) .publish(Functions.<Flowable<Integer>>identity()); for (int i = 0; i < 500; i++) { source.test() .awaitDone(5, TimeUnit.SECONDS) .assertResult(1); } }
@Test public void longSequenceEquals() { Flowable<Integer> source = Flowable.range(1, Flowable.bufferSize() * 4).subscribeOn(Schedulers.computation()); Flowable.sequenceEqual(source, source) .test() .awaitDone(5, TimeUnit.SECONDS) .assertResult(true); }
@Test(timeout = 1000) public void testRaceConditions() { Scheduler comp = Schedulers.computation(); Scheduler limited = comp.when(new Function<Flowable<Flowable<Completable>>, Completable>() { @Override public Completable apply(Flowable<Flowable<Completable>> t) { return Completable.merge(Flowable.merge(t, 10)); } }); merge(just(just(1).subscribeOn(limited).observeOn(comp)).repeat(1000)).blockingSubscribe(); }
@Test public void repeatScheduled() { TestSubscriber<Integer> ts = TestSubscriber.create(); Flowable.just(1).subscribeOn(Schedulers.computation()).repeat(5).subscribe(ts); ts.awaitTerminalEvent(5, TimeUnit.SECONDS); ts.assertValues(1, 1, 1, 1, 1); ts.assertNoErrors(); ts.assertComplete(); }