@Override public void run() { ms.onSuccess(1); } };
@Override public void run() { cs.onSuccess(1); } };
@Override public void run() { cs.onSuccess(1); } };
@Override public void run() { ms.onSuccess(1); } };
@Override public void run() { ms.onSuccess(3); } };
@Override public void run() { ms.onSuccess(3); } };
@Override public void run() { cs.onSuccess(1); } };
@Override public void onNext(Integer t) { super.onNext(t); if (t == 1) { cs.onSuccess(2); } } });
@Override public void onNext(Integer t) { super.onNext(t); if (t == 1) { cs.onSuccess(2); } } });
@Override public void onNext(Integer t) { super.onNext(t); if (t == 1) { cs.onSuccess(2); } } });
@Override public void onNext(Integer t) { super.onNext(t); if (t == 1) { cs.onSuccess(2); } } });
@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 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 untilPublisherMainSuccess() { 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.onSuccess(1); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasSubscribers()); to.assertResult(1); }
@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 untilMaybeOtherSuccess() { 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.onSuccess(1); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasObservers()); to.assertResult(); }
@Test public void mainBoundaryErrorInnerSuccess() { 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.onSuccess(1); to.assertFailure(TestException.class, 1); }
@Test public void mainBoundaryErrorInnerSuccess() { 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.onSuccess(1); ts.assertFailure(TestException.class, 1); }
@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()); }