@Override public void run() { ms.onError(ex2); } };
@Override public void run() { ms.onError(ex); } };
@Override public void run() { ms.onError(ex2); } };
@Override public void run() { ms.onError(ex); } };
@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 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 untilMaybeOtherError() { 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.onError(new TestException()); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasObservers()); to.assertFailure(TestException.class); }
@Test public void untilPublisherMainError() { 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.onError(new TestException()); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasSubscribers()); to.assertFailure(TestException.class); }
@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 switchOver() { PublishSubject<Integer> ps = PublishSubject.create(); final MaybeSubject<Integer> ms1 = MaybeSubject.create(); final MaybeSubject<Integer> ms2 = MaybeSubject.create(); TestObserver<Integer> to = ps.switchMapMaybe(new Function<Integer, MaybeSource<Integer>>() { @Override public MaybeSource<Integer> apply(Integer v) throws Exception { if (v == 1) { return ms1; } return ms2; } }).test(); to.assertEmpty(); ps.onNext(1); to.assertEmpty(); assertTrue(ms1.hasObservers()); ps.onNext(2); assertFalse(ms1.hasObservers()); assertTrue(ms2.hasObservers()); ms2.onError(new TestException()); assertFalse(ps.hasObservers()); to.assertFailure(TestException.class); }
@Test public void switchOverDelayError() { PublishSubject<Integer> ps = PublishSubject.create(); final MaybeSubject<Integer> ms1 = MaybeSubject.create(); final MaybeSubject<Integer> ms2 = MaybeSubject.create(); TestObserver<Integer> to = ps.switchMapMaybeDelayError(new Function<Integer, MaybeSource<Integer>>() { @Override public MaybeSource<Integer> apply(Integer v) throws Exception { if (v == 1) { return ms1; } return ms2; } }).test(); to.assertEmpty(); ps.onNext(1); to.assertEmpty(); assertTrue(ms1.hasObservers()); ps.onNext(2); assertFalse(ms1.hasObservers()); assertTrue(ms2.hasObservers()); ms2.onError(new TestException()); to.assertEmpty(); assertTrue(ps.hasObservers()); ps.onComplete(); to.assertFailure(TestException.class); }
@Test public void switchOverDelayError() { PublishProcessor<Integer> pp = PublishProcessor.create(); final MaybeSubject<Integer> ms1 = MaybeSubject.create(); final MaybeSubject<Integer> ms2 = MaybeSubject.create(); TestSubscriber<Integer> ts = pp.switchMapMaybeDelayError(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()); ts.assertEmpty(); assertTrue(pp.hasSubscribers()); pp.onComplete(); ts.assertFailure(TestException.class); }
assertEquals(1, ms.observerCount()); ms.onError(new IOException());
/** * 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 onErrorError() { Disposable d = MaybeConsumers.subscribeAutoDispose(processor, composite, this, this); assertTrue(d.getClass().toString(), ((LambdaConsumerIntrospection)d).hasCustomOnError()); assertTrue(composite.size() > 0); assertTrue(events.toString(), events.isEmpty()); processor.onError(new IOException()); assertTrue(events.toString(), events.get(0) instanceof IOException); assertEquals(0, composite.size()); }
@Test public void onCompleteError() { MaybeConsumers.subscribeAutoDispose(processor, composite, this, this, this); assertTrue(composite.size() > 0); assertTrue(events.toString(), events.isEmpty()); processor.onError(new IOException()); assertTrue(events.toString(), events.get(0) instanceof IOException); assertEquals(0, composite.size()); }
@Test public void onErrorCrash() { List<Throwable> errors = TestHelper.trackPluginErrors(); try { MaybeConsumers.subscribeAutoDispose(processor, composite, this, new Consumer<Throwable>() { @Override public void accept(Throwable t) throws Exception { throw new IOException(t); } }, this); processor.onError(new IllegalArgumentException()); assertTrue(events.toString(), events.isEmpty()); TestHelper.assertError(errors, 0, CompositeException.class); List<Throwable> inners = TestHelper.compositeList(errors.get(0)); TestHelper.assertError(inners, 0, IllegalArgumentException.class); TestHelper.assertError(inners, 1, IOException.class); } finally { RxJavaPlugins.reset(); } }