@Override public Object apply(Flowable<Object> f) throws Exception { return f.singleElement(); } }, false, 1, 1, 1);
@Override public MaybeSource<Object> apply(Flowable<Object> f) throws Exception { return f.singleElement(); } });
@Override public Flowable<Object> apply(Flowable<Object> f) throws Exception { return f.singleElement().toFlowable(); } });
/** * Retries at most times or until the predicate returns false, whichever happens first. * * <dl> * <dt><b>Scheduler:</b></dt> * <dd>{@code retry} does not operate by default on a particular {@link Scheduler}.</dd> * </dl> * @param times the number of times to repeat * @param predicate the predicate called with the failure Throwable and should return true to trigger a retry. * @return the new Maybe instance */ @CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public final Maybe<T> retry(long times, Predicate<? super Throwable> predicate) { return toFlowable().retry(times, predicate).singleElement(); }
@Override public Publisher<Integer> createPublisher(final long elements) { return Flowable.just(1).singleElement().toFlowable() ; }
@Test public void testSingleWithEmpty() { Maybe<Integer> maybe = Flowable.<Integer> empty().singleElement(); MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver(); maybe.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer).onComplete(); inOrder.verify(observer, never()).onError(any(Throwable.class)); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleWithEmptyFlowable() { Flowable<Integer> flowable = Flowable.<Integer> empty().singleElement().toFlowable(); Subscriber<Integer> subscriber = TestHelper.mockSubscriber(); flowable.subscribe(subscriber); InOrder inOrder = inOrder(subscriber); inOrder.verify(subscriber).onComplete(); inOrder.verify(subscriber, never()).onError(any(Throwable.class)); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingle() { Maybe<Integer> maybe = Flowable.just(1).singleElement(); MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver(); maybe.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onSuccess(1); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleFlowable() { Flowable<Integer> flowable = Flowable.just(1).singleElement().toFlowable(); Subscriber<Integer> subscriber = TestHelper.mockSubscriber(); flowable.subscribe(subscriber); InOrder inOrder = inOrder(subscriber); inOrder.verify(subscriber, times(1)).onNext(1); inOrder.verify(subscriber, times(1)).onComplete(); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleWithTooManyElements() { Maybe<Integer> maybe = Flowable.just(1, 2).singleElement(); MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver(); maybe.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onError( isA(IllegalArgumentException.class)); inOrder.verifyNoMoreInteractions(); }
@Test public void testSingleWithTooManyElementsFlowable() { Flowable<Integer> flowable = Flowable.just(1, 2).singleElement().toFlowable(); Subscriber<Integer> subscriber = TestHelper.mockSubscriber(); flowable.subscribe(subscriber); InOrder inOrder = inOrder(subscriber); inOrder.verify(subscriber, times(1)).onError( isA(IllegalArgumentException.class)); inOrder.verifyNoMoreInteractions(); }
@Test public void fromFlowableJust() { Flowable.just(1) .singleElement() .test() .assertResult(1); }
@Test public void fromFlowableEmpty() { Flowable.empty() .singleElement() .test() .assertResult(); }
@Test public void testSingleWithPredicate() { Maybe<Integer> maybe = Flowable.just(1, 2) .filter( new Predicate<Integer>() { @Override public boolean test(Integer t1) { return t1 % 2 == 0; } }) .singleElement(); MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver(); maybe.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onSuccess(2); inOrder.verifyNoMoreInteractions(); }
@Test public void fromFlowableMany() { Flowable.range(1, 2) .singleElement() .test() .assertFailure(IllegalArgumentException.class); }
@Test public void testSingleWithPredicateAndTooManyElements() { Maybe<Integer> maybe = Flowable.just(1, 2, 3, 4) .filter( new Predicate<Integer>() { @Override public boolean test(Integer t1) { return t1 % 2 == 0; } }) .singleElement(); MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver(); maybe.subscribe(observer); InOrder inOrder = inOrder(observer); inOrder.verify(observer, times(1)).onError( isA(IllegalArgumentException.class)); inOrder.verifyNoMoreInteractions(); }
@Test public void fromFlowableError() { Flowable.error(new TestException()) .singleElement() .test() .assertFailure(TestException.class); }
@Test public void flowableMaybeFlowable() { Flowable.just(1).singleElement().toFlowable().test().assertResult(1); }
@Test public void fromObservableValueAndError() { Flowable.just(1).concatWith(Flowable.<Integer>error(new TestException())) .singleElement() .test() .assertFailure(TestException.class); }
@Test public void fromFlowableValueAndError() { Flowable.just(1).concatWith(Flowable.<Integer>error(new TestException())) .singleElement() .test() .assertFailure(TestException.class); }