@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; } }); } })
/** * 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 @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)); }
/** * 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 @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(expected = NullPointerException.class) public void mapNull() { Single.just(1).map(null); }
@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 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 testAggregateAsIntSumResultSelectorThrows() { Function<Integer, Integer> error = new Function<Integer, Integer>() { @Override public Integer apply(Integer t1) { throw new TestException(); } }; Single<Integer> result = reduce(Flowable.just(1, 2, 3, 4, 5) , 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 testAggregateAsIntSum() { Single<Integer> result = reduce(Flowable.just(1, 2, 3, 4, 5), 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 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 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 = reduce(Flowable.just(1, 2, 3, 4, 5) , 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 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)); }
@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 testAggregateAsIntSumSourceThrows() { Single<Integer> result = reduce(Flowable.concat(Flowable.just(1, 2, 3, 4, 5), Flowable.<Integer> error(new TestException())) , 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() { TestObserver<String> ts = new TestObserver<String>(); Single.just("A") .map(new Function<String, String>() { @Override public String apply(String s) { return s + "B"; } }) .toObservable().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."); }
@Test public void failSingleSingleBlockingGet() { try { RxJavaCommonPlugins.setFailOnNonBlockingScheduler(true); Single.just(1) .subscribeOn(Schedulers.single()) .map(new Function<Integer, Integer>() { @Override public Integer apply(Integer v) throws Exception { Single.just(1).delay(10, TimeUnit.SECONDS).blockingGet(); return v; } }) .test() .awaitDone(5, TimeUnit.SECONDS) .assertFailure(IllegalStateException.class); } finally { RxJavaCommonPlugins.reset(); } }