@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 onSubscribeDispose() { MaybeSubject<Integer> ms = MaybeSubject.create(); Disposable d = Disposables.empty(); ms.onSubscribe(d); assertFalse(d.isDisposed()); ms.onComplete(); d = Disposables.empty(); ms.onSubscribe(d); assertTrue(d.isDisposed()); }
@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 untilPublisherMainComplete() { MaybeSubject<Integer> main = MaybeSubject.create(); PublishProcessor<Integer> other = PublishProcessor.create(); TestObserver<Integer> to = main.takeUntil(other).test(); assertTrue("Main no observers?", main.hasObservers()); assertTrue("Other no observers?", other.hasSubscribers()); main.onComplete(); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasSubscribers()); to.assertResult(); }
@Test public void untilMaybeMainComplete() { 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.onComplete(); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasObservers()); to.assertResult(); }
@Test public void autoDispose_withLifecycleProvider_completion() { RecordingObserver<Integer> o = new RecordingObserver<>(LOGGER); MaybeSubject<Integer> source = MaybeSubject.create(); BehaviorSubject<Integer> lifecycle = BehaviorSubject.createDefault(0); LifecycleScopeProvider<Integer> provider = makeLifecycleProvider(lifecycle); source.as(autoDisposable(provider)) .subscribe(o); o.takeSubscribe(); assertThat(source.hasObservers()).isTrue(); assertThat(lifecycle.hasObservers()).isTrue(); lifecycle.onNext(1); assertThat(source.hasObservers()).isTrue(); assertThat(lifecycle.hasObservers()).isTrue(); source.onComplete(); o.assertOnComplete(); o.assertNoMoreEvents(); assertThat(source.hasObservers()).isFalse(); assertThat(lifecycle.hasObservers()).isFalse(); }
@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 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 mainBoundaryErrorInnerEmpty() { PublishProcessor<Integer> pp = PublishProcessor.create(); MaybeSubject<Integer> ms = MaybeSubject.create(); TestSubscriber<Integer> ts = pp.concatMapMaybeDelayError(Functions.justFunction(ms), false).test(); ts.assertEmpty(); pp.onNext(1); assertTrue(ms.hasObservers()); pp.onError(new TestException()); assertTrue(ms.hasObservers()); ts.assertEmpty(); ms.onComplete(); ts.assertFailure(TestException.class); }
@Test public void mainErrorInnerCompleteDelayError() { PublishSubject<Integer> ps = PublishSubject.create(); final MaybeSubject<Integer> ms = MaybeSubject.create(); TestObserver<Integer> to = ps.switchMapMaybeDelayError(new Function<Integer, MaybeSource<Integer>>() { @Override public MaybeSource<Integer> apply(Integer v) throws Exception { return ms; } }).test(); to.assertEmpty(); ps.onNext(1); to.assertEmpty(); assertTrue(ms.hasObservers()); ps.onError(new TestException()); assertTrue(ms.hasObservers()); to.assertEmpty(); ms.onComplete(); to.assertFailure(TestException.class); }
@Test public void mainErrorInnerCompleteDelayError() { PublishProcessor<Integer> pp = PublishProcessor.create(); final MaybeSubject<Integer> ms = MaybeSubject.create(); TestSubscriber<Integer> ts = pp.switchMapMaybeDelayError(new Function<Integer, MaybeSource<Integer>>() { @Override public MaybeSource<Integer> apply(Integer v) throws Exception { return ms; } }).test(); ts.assertEmpty(); pp.onNext(1); ts.assertEmpty(); assertTrue(ms.hasObservers()); pp.onError(new TestException()); assertTrue(ms.hasObservers()); ts.assertEmpty(); ms.onComplete(); ts.assertFailure(TestException.class); }
assertEquals(1, ms.observerCount()); ms.onComplete();
/** * Returns a Maybe that emits the resulting value of the CompletionStage or * its error, treating null as empty source. * @param <T> the value type * @param cs the source CompletionStage instance * @return the new Maybe instance */ public static <T> Maybe<T> fromFuture(CompletionStage<T> cs) { MaybeSubject<T> ms = MaybeSubject.create(); cs.whenComplete((v, e) -> { if (e != null) { ms.onError(e); } else if (v != null) { ms.onSuccess(v); } else { ms.onComplete(); } }); return ms; }
@Test public void onCompleteNormal() { MaybeConsumers.subscribeAutoDispose(processor, composite, this, this, this); assertTrue(composite.size() > 0); assertTrue(events.toString(), events.isEmpty()); processor.onComplete(); assertEquals(0, composite.size()); assertEquals(Arrays.<Object>asList("OnComplete"), events); }
@Test public void onCompleteCrash() { List<Throwable> errors = TestHelper.trackPluginErrors(); try { MaybeConsumers.subscribeAutoDispose(processor, composite, this, this, new Action() { @Override public void run() throws Exception { throw new IOException(); } }); processor.onComplete(); assertTrue(events.toString(), events.isEmpty()); TestHelper.assertUndeliverable(errors, 0, IOException.class); } finally { RxJavaPlugins.reset(); } }