@Override public void run() { cached.test(); } };
@Test public void simpleInequal() { Observable.sequenceEqual(Observable.just(1), Observable.just(2)) .test() .assertResult(false); }
@Test public void elementAtOrErrorOneElement() { Observable.just(1) .elementAtOrError(0) .test() .assertNoErrors() .assertValue(1); }
@Test public void singleOrErrorOneElement() { Observable.just(1) .singleOrError() .test() .assertNoErrors() .assertValue(1); }
@Test public void lastOrErrorOneElement() { Observable.just(1) .lastOrError() .test() .assertNoErrors() .assertValue(1); }
@Test public void createNullSuccess() { Single.create(new SingleOnSubscribe<Object>() { @Override public void subscribe(SingleEmitter<Object> s) throws Exception { s.onSuccess(null); s.onSuccess(null); } }) .test() .assertFailure(NullPointerException.class); }
@Test public void emitterHasToString() { Single.create(new SingleOnSubscribe<Object>() { @Override public void subscribe(SingleEmitter<Object> emitter) throws Exception { assertTrue(emitter.toString().contains(SingleCreate.Emitter.class.getSimpleName())); } }).test().assertEmpty(); } }
@Test public void doOnTerminateSuccessCrash() { Single.just(1).doOnTerminate(new Action() { @Override public void run() throws Exception { throw new TestException(); } }) .test() .assertFailure(TestException.class); }
@Test public void normal() { Maybe.just(1) .isEmpty() .test() .assertResult(false); }
@Test public void doOnSuccessCrash() { Single.just(1) .doOnSuccess(new Consumer<Integer>() { @Override public void accept(Integer v) throws Exception { throw new TestException(); } }) .test() .assertFailure(TestException.class); }
@Test public void lastOrErrorError() { Flowable.error(new RuntimeException("error")) .lastOrError() .test() .assertNoValues() .assertErrorMessage("error") .assertError(RuntimeException.class); }
@Test @SuppressWarnings("unchecked") public void success() { Maybe.just(1) .materialize() .test() .assertResult(Notification.createOnNext(1)); }
@Test public void singleOrErrorNoElement() { Observable.empty() .singleOrError() .test() .assertNoValues() .assertError(NoSuchElementException.class); }
@Test public void lastOrErrorNoElement() { Observable.empty() .lastOrError() .test() .assertNoValues() .assertError(NoSuchElementException.class); }
@Test public void error() { Maybe.error(new TestException()) .isEmpty() .test() .assertFailure(TestException.class); }
@Test public void singleOrErrorMultipleElements() { Flowable.just(1, 2, 3) .singleOrError() .test() .assertNoValues() .assertError(IllegalArgumentException.class); }
@Test public void delaySubscriptionSingle() throws Exception { Single.just(1).delaySubscription(Single.timer(100, TimeUnit.MILLISECONDS)) .test() .awaitDone(5, TimeUnit.SECONDS) .assertResult(1); }
@Test public void withPublisherError() { Single.just(1) .delaySubscription(Flowable.error(new TestException())) .test() .assertFailure(TestException.class); }
@Test public void resourceDisposedIfMapperCrashes() { Disposable d = Disposables.empty(); Single.using(Functions.justCallable(d), mapperThrows, disposer) .test() .assertFailure(TestException.class); assertTrue(d.isDisposed()); }
@Test public void delayOnSuccess() { final TestScheduler scheduler = new TestScheduler(); final TestObserver<Integer> observer = Single.just(1) .delay(5, TimeUnit.SECONDS, scheduler) .test(); scheduler.advanceTimeTo(2, TimeUnit.SECONDS); observer.assertNoValues(); scheduler.advanceTimeTo(5, TimeUnit.SECONDS); observer.assertValue(1); }