@Test(expected = NullPointerException.class) public void subscribeOnNull() { just1.subscribeOn(null); }
@Override public SingleSource<Integer> apply(Integer v) throws Exception { return Single.just(v).subscribeOn(Schedulers.computation()); } }, false, 3)
@Override public SingleSource<Integer> apply(Integer v) throws Exception { return Single.just(v).subscribeOn(Schedulers.computation()); } }, false, 1)
@Override public SingleSource<Integer> apply(Integer v) throws Exception { return Single.just(v).subscribeOn(Schedulers.computation()); } })
@Override public SingleSource<Integer> apply(Integer v) throws Exception { return Single.just(v).subscribeOn(Schedulers.computation()); } })
@Override public SingleSource<Integer> apply(Integer v) throws Exception { return Single.just(v).subscribeOn(Schedulers.computation()); } })
@Override public Single<String> apply(String s) { return Single.just(s + " World!").subscribeOn(Schedulers.computation()); } }
@Override public SingleSource<Integer> apply(Integer v) throws Exception { return Single.just(1).subscribeOn(Schedulers.computation()); } })
@Override public SingleSource<Integer> apply(Integer v) throws Exception { return Single.just(v).subscribeOn(Schedulers.computation()); } })
@Override public SingleSource<Integer> apply(Integer v) throws Exception { return Single.just(1).subscribeOn(Schedulers.computation()); } })
@Test public void singleMaybe() throws Exception { List<Throwable> errors = TestHelper.trackPluginErrors(); try { TestObserver<Integer> to = Single.just(1) .subscribeOn(Schedulers.io()) .flatMapMaybe(new Function<Integer, Maybe<Integer>>() { @Override public Maybe<Integer> apply(Integer v) throws Exception { sleep(); return Maybe.<Integer>error(new TestException()); } }) .test(); cb.await(); beforeCancelSleep(to); to.cancel(); Thread.sleep(SLEEP_AFTER_CANCEL); to.assertEmpty(); assertTrue(errors.toString(), errors.isEmpty()); } finally { RxJavaPlugins.reset(); } }
@Test public void singleSingle() throws Exception { List<Throwable> errors = TestHelper.trackPluginErrors(); try { TestObserver<Integer> to = Single.just(1) .subscribeOn(Schedulers.io()) .flatMap(new Function<Integer, Single<Integer>>() { @Override public Single<Integer> apply(Integer v) throws Exception { sleep(); return Single.<Integer>error(new TestException()); } }) .test(); cb.await(); beforeCancelSleep(to); to.cancel(); Thread.sleep(SLEEP_AFTER_CANCEL); to.assertEmpty(); assertTrue(errors.toString(), errors.isEmpty()); } finally { RxJavaPlugins.reset(); } }
@Test public void singleCompletable() throws Exception { List<Throwable> errors = TestHelper.trackPluginErrors(); try { TestObserver<Void> to = Single.just(1) .subscribeOn(Schedulers.io()) .flatMapCompletable(new Function<Integer, Completable>() { @Override public Completable apply(Integer v) throws Exception { sleep(); return Completable.error(new TestException()); } }) .test(); cb.await(); beforeCancelSleep(to); to.cancel(); Thread.sleep(SLEEP_AFTER_CANCEL); to.assertEmpty(); assertTrue(errors.toString(), errors.isEmpty()); } finally { RxJavaPlugins.reset(); } }
@Test public void dispose() { TestHelper.checkDisposed(PublishSubject.create().singleOrError().subscribeOn(new TestScheduler())); }
@Test public void normal() { List<Throwable> list = TestHelper.trackPluginErrors(); try { TestScheduler scheduler = new TestScheduler(); TestObserver<Integer> to = Single.just(1) .subscribeOn(scheduler) .test(); scheduler.advanceTimeBy(1, TimeUnit.SECONDS); to.assertResult(1); assertTrue(list.toString(), list.isEmpty()); } finally { RxJavaPlugins.reset(); } }
@Test public void error() { Single.error(new TestException()) .subscribeOn(Schedulers.single()) .test() .awaitDone(5, TimeUnit.SECONDS) .assertFailure(TestException.class); } }
@Test public void testTimeout() { TestSubscriber<String> ts = new TestSubscriber<String>(); Single<String> s1 = Single.<String>unsafeCreate(new SingleSource<String>() { @Override public void subscribe(SingleObserver<? super String> observer) { observer.onSubscribe(Disposables.empty()); try { Thread.sleep(5000); } catch (InterruptedException e) { // ignore as we expect this for the test } observer.onSuccess("success"); } }).subscribeOn(Schedulers.io()); s1.timeout(100, TimeUnit.MILLISECONDS).toFlowable().subscribe(ts); ts.awaitTerminalEvent(); ts.assertError(TimeoutException.class); }
@Test public void testAsync() { TestSubscriber<String> ts = new TestSubscriber<String>(); Single.just("Hello") .subscribeOn(Schedulers.io()) .map(new Function<String, String>() { @Override public String apply(String v) { System.out.println("SubscribeOn Thread: " + Thread.currentThread()); return v; } }) .observeOn(Schedulers.computation()) .map(new Function<String, String>() { @Override public String apply(String v) { System.out.println("ObserveOn Thread: " + Thread.currentThread()); return v; } }) .toFlowable().subscribe(ts); ts.awaitTerminalEvent(); ts.assertValueSequence(Arrays.asList("Hello")); }
@Test public void testTimeoutWithFallback() { TestSubscriber<String> ts = new TestSubscriber<String>(); Single<String> s1 = Single.<String>unsafeCreate(new SingleSource<String>() { @Override public void subscribe(SingleObserver<? super String> observer) { observer.onSubscribe(Disposables.empty()); try { Thread.sleep(5000); } catch (InterruptedException e) { // ignore as we expect this for the test } observer.onSuccess("success"); } }).subscribeOn(Schedulers.io()); s1.timeout(100, TimeUnit.MILLISECONDS, Single.just("hello")).toFlowable().subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); ts.assertValue("hello"); }
@Test public void failSingleSingleBlockingGet() { try { RxJavaPlugins.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 { RxJavaPlugins.reset(); } }