@Override public Integer apply(Integer v) throws Exception { Maybe.just(1).delay(10, TimeUnit.SECONDS).blockingGet(); return v; } })
@SuppressWarnings("unchecked") @Test(expected = NullPointerException.class) public void zipArrayOneIsNull() { Maybe.zipArray(new Function<Object[], Object>() { @Override public Object apply(Object[] v) { return 1; } }, Maybe.just(1), null) .blockingGet(); }
@SuppressWarnings("unchecked") @Test(expected = NullPointerException.class) public void zipIterableOneIsNull() { Maybe.zip(Arrays.asList(null, Maybe.just(1)), new Function<Object[], Object>() { @Override public Object apply(Object[] v) { return 1; } }) .blockingGet(); }
@Test public void onErrorResumeNextEmpty() { Maybe.empty() .onErrorResumeNext(Maybe.just(1)) .test() .assertNoValues() .assertNoErrors() .assertComplete(); }
@SuppressWarnings("unchecked") @Test public void mergeArrayBackpressuredMixed1() { TestObserver<Integer> ts = Maybe.mergeArray(Maybe.just(1), Maybe.<Integer>empty(), Maybe.just(3)) .test(); ts.assertResult(1, 3); }
@SuppressWarnings("unchecked") @Test public void firstErrors() { TestObserver<Integer> ts = new TestObserver<Integer>(); Maybe.mergeArray(Maybe.<Integer>error(new TestException()), Maybe.<Integer>empty(), Maybe.just(2)) .subscribe(ts); ts.assertFailure(TestException.class); }
@Test public void testFirstOfNone() { Observable<Integer> o = Observable.empty(); o.firstElement().subscribe(wm); verify(wm, never()).onSuccess(anyInt()); verify(wm).onComplete(); verify(wm, never()).onError(any(Throwable.class)); }
@Test public void offlineComplete() { Maybe<Integer> source = Maybe.<Integer>empty().cache(); assertNull(source.blockingGet()); source.test() .assertResult(); }
@Test public void failSingleMaybeBlockingGet() { try { RxJavaCommonPlugins.setFailOnNonBlockingScheduler(true); Maybe.just(1) .subscribeOn(Schedulers.single()) .map(new Function<Integer, Integer>() { @Override public Integer apply(Integer v) throws Exception { Maybe.just(1).delay(10, TimeUnit.SECONDS).blockingGet(); return v; } }) .test() .awaitDone(5, TimeUnit.SECONDS) .assertFailure(IllegalStateException.class); } finally { RxJavaCommonPlugins.reset(); } }
@Test public void offlineSuccess() { Maybe<Integer> source = Maybe.just(1).cache(); assertEquals(1, source.blockingGet().intValue()); source.test() .assertResult(1); }
@SuppressWarnings("unchecked") @Test public void mergeIterableDelayError() { Maybe.mergeDelayError(Arrays.asList(Maybe.empty(), Maybe.just(1), Maybe.error(new TestException()))) .test() .assertFailure(TestException.class, 1); Maybe.mergeDelayError(Arrays.asList(Maybe.error(new TestException()), Maybe.empty(), Maybe.just(1))) .test() .assertFailure(TestException.class, 1); }
@Test public void observeOnSuccess() { String main = Thread.currentThread().getName(); Maybe.just(1) .observeOn(Schedulers.single()) .map(new Function<Integer, String>() { @Override public String apply(Integer v) throws Exception { return v + ": " + Thread.currentThread().getName(); } }) .test() .awaitDone(5, TimeUnit.SECONDS) .assertOf(TestHelper.observerSingleNot("1: " + main)) ; }
@Test public void using() { final AtomicInteger disposeCount = new AtomicInteger(); Maybe.using(Functions.justCallable(1), new Function<Integer, MaybeSource<Integer>>() { @Override public MaybeSource<Integer> apply(Integer v) throws Exception { return Maybe.just(v); } }, new Consumer<Integer>() { @Override public void accept(Integer d) throws Exception { disposeCount.set(d); } }) .map(new Function<Integer, Object>() { @Override public String apply(Integer v) throws Exception { return "" + disposeCount.get() + v * 10; } }) .test() .assertResult("110"); }