@Override public Publisher<Integer> createPublisher(long elements) { return Flowable.just(1).repeat(elements); } }
@Test(timeout = 2000) public void testRepeatOne() { Subscriber<Object> subscriber = TestHelper.mockSubscriber(); Flowable.just(1).repeat(1).subscribe(subscriber); verify(subscriber).onComplete(); verify(subscriber, times(1)).onNext(any()); verify(subscriber, never()).onError(any(Throwable.class)); }
@Test(timeout = 2000) public void testRepeatError() { Subscriber<Object> subscriber = TestHelper.mockSubscriber(); Flowable.error(new TestException()).repeat(10).subscribe(subscriber); verify(subscriber).onError(any(TestException.class)); verify(subscriber, never()).onNext(any()); verify(subscriber, never()).onComplete(); }
@Test(timeout = 2000) public void testRepeatZero() { Subscriber<Object> subscriber = TestHelper.mockSubscriber(); Flowable.just(1).repeat(0).subscribe(subscriber); verify(subscriber).onComplete(); verify(subscriber, never()).onNext(any()); verify(subscriber, never()).onError(any(Throwable.class)); }
@Test(timeout = 2000) public void testRepeatLimited() { Subscriber<Object> subscriber = TestHelper.mockSubscriber(); Flowable.just(1).repeat(10).subscribe(subscriber); verify(subscriber, times(10)).onNext(1); verify(subscriber).onComplete(); verify(subscriber, never()).onError(any(Throwable.class)); }
@Test(timeout = 2000) public void testRepeatAndTake() { Subscriber<Object> subscriber = TestHelper.mockSubscriber(); Flowable.just(1).repeat().take(10).subscribe(subscriber); verify(subscriber, times(10)).onNext(1); verify(subscriber).onComplete(); verify(subscriber, never()).onError(any(Throwable.class)); }
@Test public void repeatLongPredicateInvalid() { try { Flowable.just(1).repeat(-99); fail("Should have thrown"); } catch (IllegalArgumentException ex) { assertEquals("times >= 0 required but it was -99", ex.getMessage()); } }
@Test(timeout = 2000) public void bufferWithSizeSkipTake1() { Flowable<Integer> source = Flowable.just(1).repeat(); Flowable<List<Integer>> result = source.buffer(2, 3).take(1); Subscriber<Object> subscriber = TestHelper.mockSubscriber(); result.subscribe(subscriber); verify(subscriber).onNext(Arrays.asList(1, 1)); verify(subscriber).onComplete(); verify(subscriber, never()).onError(any(Throwable.class)); }
@Test(timeout = 2000) public void bufferWithSizeTake1() { Flowable<Integer> source = Flowable.just(1).repeat(); Flowable<List<Integer>> result = source.buffer(2).take(1); Subscriber<Object> subscriber = TestHelper.mockSubscriber(); result.subscribe(subscriber); verify(subscriber).onNext(Arrays.asList(1, 1)); verify(subscriber).onComplete(); verify(subscriber, never()).onError(any(Throwable.class)); }
@Test public void noCancelPreviousRepeat() { final AtomicInteger counter = new AtomicInteger(); Flowable<Integer> source = Flowable.just(1).doOnCancel(new Action() { @Override public void run() throws Exception { counter.getAndIncrement(); } }); source.repeat(5) .test() .assertResult(1, 1, 1, 1, 1); assertEquals(0, counter.get()); }
@Test(timeout = 5000) public void concatObservableMany() { Completable c = Completable.concat(Flowable.just(normal.completable).repeat(3)); c.blockingAwait(); normal.assertSubscriptions(3); }
@Test(timeout = 5000) public void mergeObservableMany() { Completable c = Completable.merge(Flowable.just(normal.completable).repeat(3)); c.blockingAwait(); normal.assertSubscriptions(3); }
@Test(timeout = 5000) public void mergeDelayErrorObservableMany() { Completable c = Completable.mergeDelayError(Flowable.just(normal.completable).repeat(3)); c.blockingAwait(); normal.assertSubscriptions(3); }
@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(timeout = 2000) public void testRepetition() { int num = 10; final AtomicInteger count = new AtomicInteger(); int value = Flowable.unsafeCreate(new Publisher<Integer>() { @Override public void subscribe(final Subscriber<? super Integer> subscriber) { subscriber.onNext(count.incrementAndGet()); subscriber.onComplete(); } }).repeat().subscribeOn(Schedulers.computation()) .take(num).blockingLast(); assertEquals(num, value); }
@Test(timeout = 20000) public void testNoStackOverFlow() { Flowable.just(1).repeat().subscribeOn(Schedulers.newThread()).take(100000).blockingLast(); }
@Test public void testRepeatObservableThrowsError() { TestSubscriber<String> subscriber = TestSubscriber.create(); Single<String> single = Flowable.just("First", "Second").repeat().single(""); single.toFlowable().subscribe(subscriber); subscriber.assertError(IllegalArgumentException.class); }
/** Issue #2587. */ @Test public void testRepeatAndDistinctUnbounded() { Flowable<Integer> src = Flowable.fromIterable(Arrays.asList(1, 2, 3, 4, 5)) .take(3) .repeat(3) .distinct(); TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); src.subscribe(ts); ts.assertNoErrors(); ts.assertTerminated(); ts.assertValues(1, 2, 3); }
@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(); }