@Test public void error() { MaybeSubject<Integer> ms = MaybeSubject.create(); assertFalse(ms.hasValue()); assertNull(ms.getValue()); assertFalse(ms.hasComplete()); assertFalse(ms.hasThrowable()); assertNull(ms.getThrowable()); assertFalse(ms.hasObservers()); assertEquals(0, ms.observerCount()); TestObserver<Integer> to = ms.test(); assertTrue(ms.hasObservers()); assertEquals(1, ms.observerCount()); ms.onError(new IOException()); assertFalse(ms.hasValue()); assertNull(ms.getValue()); assertFalse(ms.hasComplete()); assertTrue(ms.hasThrowable()); assertTrue(ms.getThrowable().toString(), ms.getThrowable() instanceof IOException); assertFalse(ms.hasObservers()); assertEquals(0, ms.observerCount()); ms.test().assertFailure(IOException.class); assertFalse(ms.hasValue());
@Test public void untilMaybeOtherComplete() { MaybeSubject<Integer> main = MaybeSubject.create(); MaybeSubject<Integer> other = MaybeSubject.create(); TestObserver<Integer> to = main.takeUntil(other).test(); assertTrue("Main no observers?", main.hasObservers()); assertTrue("Other no observers?", other.hasObservers()); other.onComplete(); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasObservers()); to.assertResult(); }
@Test public void untilMaybeMainSuccess() { MaybeSubject<Integer> main = MaybeSubject.create(); MaybeSubject<Integer> other = MaybeSubject.create(); TestObserver<Integer> to = main.takeUntil(other).test(); assertTrue("Main no observers?", main.hasObservers()); assertTrue("Other no observers?", other.hasObservers()); main.onSuccess(1); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasObservers()); to.assertResult(1); }
@Test public void autoDispose_withMaybe_normal() { RecordingObserver<Integer> o = new RecordingObserver<>(LOGGER); MaybeSubject<Integer> source = MaybeSubject.create(); CompletableSubject scope = CompletableSubject.create(); source.as(autoDisposable(scope)) .subscribe(o); o.takeSubscribe(); assertThat(source.hasObservers()).isTrue(); assertThat(scope.hasObservers()).isTrue(); // Got the event source.onSuccess(1); assertThat(o.takeSuccess()).isEqualTo(1); // Nothing more, scope disposed too o.assertNoMoreEvents(); assertThat(source.hasObservers()).isFalse(); assertThat(scope.hasObservers()).isFalse(); }
@Test public void scalarSource() { MaybeSubject<Integer> ms = MaybeSubject.create(); TestObserver<Integer> to = Observable.just(1) .switchMapMaybe(Functions.justFunction(ms)) .test(); assertTrue(ms.hasObservers()); to.assertEmpty(); ms.onSuccess(2); to.assertResult(2); } }
@Test public void mainBoundaryErrorInnerEmpty() { PublishSubject<Integer> ps = PublishSubject.create(); MaybeSubject<Integer> ms = MaybeSubject.create(); TestObserver<Integer> to = ps.concatMapMaybeDelayError(Functions.justFunction(ms), false).test(); to.assertEmpty(); ps.onNext(1); assertTrue(ms.hasObservers()); ps.onError(new TestException()); assertTrue(ms.hasObservers()); to.assertEmpty(); ms.onComplete(); to.assertFailure(TestException.class); }
@Test public void cancelOther() { MaybeSubject<Object> other = MaybeSubject.create(); TestSubscriber<Object> ts = Flowable.empty() .concatWith(other) .test(); assertTrue(other.hasObservers()); ts.cancel(); assertFalse(other.hasObservers()); }
@Test public void once() { MaybeSubject<Integer> ms = MaybeSubject.create(); TestObserver<Integer> to = ms.test(); ms.onSuccess(1); ms.onSuccess(2); List<Throwable> errors = TestHelper.trackPluginErrors(); try { ms.onError(new IOException()); TestHelper.assertUndeliverable(errors, 0, IOException.class); } finally { RxJavaPlugins.reset(); } ms.onComplete(); to.assertResult(1); }
@Test public void switchOver() { PublishProcessor<Integer> pp = PublishProcessor.create(); final MaybeSubject<Integer> ms1 = MaybeSubject.create(); final MaybeSubject<Integer> ms2 = MaybeSubject.create(); TestSubscriber<Integer> ts = pp.switchMapMaybe(new Function<Integer, MaybeSource<Integer>>() { @Override public MaybeSource<Integer> apply(Integer v) throws Exception { if (v == 1) { return ms1; } return ms2; } }).test(); ts.assertEmpty(); pp.onNext(1); ts.assertEmpty(); assertTrue(ms1.hasObservers()); pp.onNext(2); assertFalse(ms1.hasObservers()); assertTrue(ms2.hasObservers()); ms2.onError(new TestException()); assertFalse(pp.hasSubscribers()); ts.assertFailure(TestException.class); }
@Test public void checkUnboundedInnerQueue() { MaybeSubject<Integer> ms = MaybeSubject.create(); @SuppressWarnings("unchecked") TestObserver<Integer> to = Observable .fromArray(ms, Maybe.just(2), Maybe.just(3), Maybe.just(4)) .concatMapMaybe(Functions.<Maybe<Integer>>identity(), 2) .test(); to.assertEmpty(); ms.onSuccess(1); to.assertResult(1, 2, 3, 4); }
@Test public void autoDispose_withProvider_completion() { RecordingObserver<Integer> o = new RecordingObserver<>(LOGGER); MaybeSubject<Integer> source = MaybeSubject.create(); CompletableSubject scope = CompletableSubject.create(); ScopeProvider provider = makeProvider(scope); source.as(autoDisposable(provider)) .subscribe(o); o.takeSubscribe(); assertThat(source.hasObservers()).isTrue(); assertThat(scope.hasObservers()).isTrue(); source.onComplete(); o.assertOnComplete(); o.assertNoMoreEvents(); assertThat(source.hasObservers()).isFalse(); assertThat(scope.hasObservers()).isFalse(); }
@Test public void untilMaybeDispose() { MaybeSubject<Integer> main = MaybeSubject.create(); MaybeSubject<Integer> other = MaybeSubject.create(); TestObserver<Integer> to = main.takeUntil(other).test(); assertTrue("Main no observers?", main.hasObservers()); assertTrue("Other no observers?", other.hasObservers()); to.dispose(); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasObservers()); to.assertEmpty(); }
@Test public void untilMaybeMainError() { MaybeSubject<Integer> main = MaybeSubject.create(); MaybeSubject<Integer> other = MaybeSubject.create(); TestObserver<Integer> to = main.takeUntil(other).test(); assertTrue("Main no observers?", main.hasObservers()); assertTrue("Other no observers?", other.hasObservers()); main.onError(new TestException()); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasObservers()); to.assertFailure(TestException.class); }
@Test public void autoDispose_outsideScope_withProviderAndNoOpPlugin_shouldFailSilently() { AutoDisposePlugins.setOutsideScopeHandler(e -> { }); ScopeProvider provider = outsideScopeProvider(); MaybeSubject<Integer> source = MaybeSubject.create(); TestObserver<Integer> o = source.as(autoDisposable(provider)) .test(); assertThat(source.hasObservers()).isFalse(); o.assertNoValues(); o.assertNoErrors(); }
@Test public void autoDispose_outsideScope_withProviderAndPlugin_shouldFailWithWrappedExp() { AutoDisposePlugins.setOutsideScopeHandler(e -> { // Wrap in an IllegalStateException so we can verify this is the exception we see on the // other side throw new IllegalStateException(e); }); ScopeProvider provider = outsideScopeProvider(); TestObserver<Integer> o = MaybeSubject.<Integer>create().as(autoDisposable(provider)) .test(); o.assertNoValues(); o.assertError(throwable -> throwable instanceof IllegalStateException && throwable.getCause() instanceof OutsideScopeException); } }
@Test public void cancelOther() { MaybeSubject<Integer> ms = MaybeSubject.create(); PublishProcessor<Integer> pp = PublishProcessor.create(); TestSubscriber<Integer> ts = ms.flatMapPublisher(Functions.justFunction(pp)) .test(); assertTrue(ms.hasObservers()); assertFalse(pp.hasSubscribers()); ms.onSuccess(1); assertFalse(ms.hasObservers()); assertTrue(pp.hasSubscribers()); ts.cancel(); assertFalse(ms.hasObservers()); assertFalse(pp.hasSubscribers()); }
@Test public void cancelOther() { MaybeSubject<Integer> ms = MaybeSubject.create(); PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = ms.flatMapObservable(Functions.justFunction(ps)) .test(); assertTrue(ms.hasObservers()); assertFalse(ps.hasObservers()); ms.onSuccess(1); assertFalse(ms.hasObservers()); assertTrue(ps.hasObservers()); to.cancel(); assertFalse(ms.hasObservers()); assertFalse(ps.hasObservers()); }
@Override public void run() { ms.onSuccess(3); } };