@Override public Integer apply(Integer v) throws Exception { Single.just(1).delay(10, TimeUnit.SECONDS).blockingGet(); return v; } })
@Test public void testOnErrorCalledOnScheduler() throws Exception { final CountDownLatch latch = new CountDownLatch(1); final AtomicReference<Thread> thread = new AtomicReference<Thread>(); Single.<String>error(new Exception()) .delay(0, TimeUnit.MILLISECONDS, Schedulers.newThread()) .doOnError(new Consumer<Throwable>() { @Override public void accept(Throwable throwable) throws Exception { thread.set(Thread.currentThread()); latch.countDown(); } }) .onErrorResumeNext(Single.just("")) .subscribe(); latch.await(); assertNotEquals(Thread.currentThread(), thread.get()); }
@Override public void subscribe(SingleObserver<? super Integer> s1) { Single.unsafeCreate(new SingleSource<Integer>() { @Override public void subscribe(SingleObserver<? super Integer> s2) { throw new IllegalArgumentException("original exception"); } }).subscribe(s1); } }
@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 delay() throws Exception { final AtomicInteger value = new AtomicInteger(); Single.just(1).delay(200, TimeUnit.MILLISECONDS) .subscribe(new BiConsumer<Integer, Throwable>() { @Override public void accept(Integer v, Throwable e) throws Exception { value.set(v); } }); Thread.sleep(100); assertEquals(0, value.get()); Thread.sleep(200); assertEquals(1, value.get()); }
@Test public void onErrorResumeNext() { Single.<Integer>error(new TestException()) .onErrorResumeNext(Single.just(1)) .test() .assertResult(1); }
@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 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 testFirstOrElseOfNoneObservable() { Observable<String> src = Observable.empty(); src.first("default").toObservable().subscribe(w); verify(w, times(1)).onNext(anyString()); verify(w, times(1)).onNext("default"); verify(w, never()).onError(any(Throwable.class)); verify(w, times(1)).onComplete(); }
@Test(timeout = 5000, expected = TestException.class) public void toSingleSupplierError() { error.completable.toSingle(new Callable<Object>() { @Override public Object call() { return 1; } }).blockingGet(); }
@Test public void testFirstOrElseOfNone() { Flowable<String> src = Flowable.empty(); first(src, "default").subscribe(wo); verify(wo, times(1)).onSuccess(anyString()); verify(wo, times(1)).onSuccess("default"); verify(wo, never()).onError(any(Throwable.class)); }
@Test public void error() { Single.<Integer>error(new TestException()) .doAfterSuccess(afterSuccess) .subscribeWith(ts) .assertFailure(TestException.class); assertTrue(values.isEmpty()); }