@Override public SingleSource<Object> apply(Single<Integer> f) { return f.map(new Function<Integer, Object>() { @Override public Object apply(Integer v) throws Exception { return v + 1; } }); } })
@PostMapping("/rxjava2-single") @SuppressWarnings("deprecation") public io.reactivex.Completable createWithRxJava2Single(@RequestBody io.reactivex.Single<Person> single) { return single.map(persons::add).toCompletable(); }
@PostMapping("/rxjava2-single") public io.reactivex.Single<Person> transformRxJava2Single(@RequestBody io.reactivex.Single<Person> personFuture) { return personFuture.map(person -> new Person(person.getName().toUpperCase())); }
@Test public void testAggregateAsIntSumResultSelectorThrows() { Function<Integer, Integer> error = new Function<Integer, Integer>() { @Override public Integer apply(Integer t1) { throw new TestException(); } }; Single<Integer> result = Observable.just(1, 2, 3, 4, 5) .reduce(0, sum).map(error); result.subscribe(singleObserver); verify(singleObserver, never()).onSuccess(any()); verify(singleObserver, times(1)).onError(any(TestException.class)); }
@Test public void testAggregateAsIntSum() { Single<Integer> result = Observable.just(1, 2, 3, 4, 5).reduce(0, sum) .map(new Function<Integer, Integer>() { @Override public Integer apply(Integer v) { return v; } }); result.subscribe(singleObserver); verify(singleObserver).onSuccess(1 + 2 + 3 + 4 + 5); verify(singleObserver, never()).onError(any(Throwable.class)); }
@Test public void testAggregateAsIntSumResultSelectorThrows() { Function<Integer, Integer> error = new Function<Integer, Integer>() { @Override public Integer apply(Integer t1) { throw new TestException(); } }; Single<Integer> result = Flowable.just(1, 2, 3, 4, 5) .reduce(0, sum).map(error); result.subscribe(singleObserver); verify(singleObserver, never()).onSuccess(any()); verify(singleObserver, times(1)).onError(any(TestException.class)); }
@Test(expected = NullPointerException.class) public void mapNull() { Single.just(1).map(null); }
@Test public void testAggregateAsIntSumAccumulatorThrows() { BiFunction<Integer, Integer, Integer> sumErr = new BiFunction<Integer, Integer, Integer>() { @Override public Integer apply(Integer t1, Integer t2) { throw new TestException(); } }; Single<Integer> result = Observable.just(1, 2, 3, 4, 5) .reduce(0, sumErr).map(new Function<Integer, Integer>() { @Override public Integer apply(Integer v) { return v; } }); result.subscribe(singleObserver); verify(singleObserver, never()).onSuccess(any()); verify(singleObserver, times(1)).onError(any(TestException.class)); }
@Test public void testAggregateAsIntSum() { Single<Integer> result = Flowable.just(1, 2, 3, 4, 5).reduce(0, sum) .map(new Function<Integer, Integer>() { @Override public Integer apply(Integer v) { return v; } }); result.subscribe(singleObserver); verify(singleObserver).onSuccess(1 + 2 + 3 + 4 + 5); verify(singleObserver, never()).onError(any(Throwable.class)); }
@Test public void testAggregateAsIntSumObservable() { Observable<Integer> result = Observable.just(1, 2, 3, 4, 5).reduce(0, sum) .map(new Function<Integer, Integer>() { @Override public Integer apply(Integer v) { return v; } }).toObservable(); result.subscribe(observer); verify(observer).onNext(1 + 2 + 3 + 4 + 5); verify(observer).onComplete(); verify(observer, never()).onError(any(Throwable.class)); }
@Test public void testAggregateAsIntSumSourceThrows() { Single<Integer> result = Observable.concat(Observable.just(1, 2, 3, 4, 5), Observable.<Integer> error(new TestException())) .reduce(0, sum).map(new Function<Integer, Integer>() { @Override public Integer apply(Integer v) { return v; } }); result.subscribe(singleObserver); verify(singleObserver, never()).onSuccess(any()); verify(singleObserver, times(1)).onError(any(TestException.class)); }
@Test public void testAggregateAsIntSumAccumulatorThrows() { BiFunction<Integer, Integer, Integer> sumErr = new BiFunction<Integer, Integer, Integer>() { @Override public Integer apply(Integer t1, Integer t2) { throw new TestException(); } }; Single<Integer> result = Flowable.just(1, 2, 3, 4, 5) .reduce(0, sumErr).map(new Function<Integer, Integer>() { @Override public Integer apply(Integer v) { return v; } }); result.subscribe(singleObserver); verify(singleObserver, never()).onSuccess(any()); verify(singleObserver, times(1)).onError(any(TestException.class)); }
@Test public void mapError() { RuntimeException exception = new RuntimeException("test"); Single.error(exception).map(new Function<Object, Object>() { @Override public Object apply(final Object integer) throws Exception { return new Object(); } }) .test() .assertError(exception); } }
@Test public void testAggregateAsIntSumSourceThrowsObservable() { Observable<Integer> result = Observable.concat(Observable.just(1, 2, 3, 4, 5), Observable.<Integer> error(new TestException())) .reduce(0, sum).map(new Function<Integer, Integer>() { @Override public Integer apply(Integer v) { return v; } }).toObservable(); result.subscribe(observer); verify(observer, never()).onNext(any()); verify(observer, never()).onComplete(); verify(observer, times(1)).onError(any(TestException.class)); }
/** * Casts the success value of the current Single into the target type or signals a * ClassCastException if not compatible. * <dl> * <dt><b>Scheduler:</b></dt> * <dd>{@code cast} does not operate by default on a particular {@link Scheduler}.</dd> * </dl> * @param <U> the target type * @param clazz the type token to use for casting the success result from the current Single * @return the new Single instance * @since 2.0 */ @CheckReturnValue @NonNull @SchedulerSupport(SchedulerSupport.NONE) public final <U> Single<U> cast(final Class<? extends U> clazz) { ObjectHelper.requireNonNull(clazz, "clazz is null"); return map(Functions.castFunction(clazz)); }
@Test public void testAggregateAsIntSumSourceThrows() { Single<Integer> result = Flowable.concat(Flowable.just(1, 2, 3, 4, 5), Flowable.<Integer> error(new TestException())) .reduce(0, sum).map(new Function<Integer, Integer>() { @Override public Integer apply(Integer v) { return v; } }); result.subscribe(singleObserver); verify(singleObserver, never()).onSuccess(any()); verify(singleObserver, times(1)).onError(any(TestException.class)); }
@Test public void mapValue() { Single.just(1).map(new Function<Integer, Integer>() { @Override public Integer apply(final Integer integer) throws Exception { if (integer == 1) { return 2; } return 1; } }) .test() .assertResult(2); }
@Test public void mapValueErrorThrown() { Single.just(1).map(new Function<Integer, SingleSource<Integer>>() { @Override public SingleSource<Integer> apply(final Integer integer) throws Exception { throw new RuntimeException("something went terribly wrong!"); } }) .test() .assertNoValues() .assertError(RuntimeException.class) .assertErrorMessage("something went terribly wrong!"); }
@Test public void testMap() { TestSubscriber<String> ts = new TestSubscriber<String>(); Single.just("A") .map(new Function<String, String>() { @Override public String apply(String s) { return s + "B"; } }) .toFlowable().subscribe(ts); ts.assertValueSequence(Arrays.asList("AB")); }
@Test public void mapValueNull() { Single.just(1).map(new Function<Integer, SingleSource<Integer>>() { @Override public SingleSource<Integer> apply(final Integer integer) throws Exception { return null; } }) .test() .assertNoValues() .assertError(NullPointerException.class) .assertErrorMessage("The mapper function returned a null value."); }