@Test public void untilPublisherMainComplete() { PublishSubject<Integer> main = PublishSubject.create(); PublishSubject<Integer> other = PublishSubject.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 untilPublisherOtherOnNext() { PublishSubject<Integer> main = PublishSubject.create(); PublishSubject<Integer> other = PublishSubject.create(); TestObserver<Integer> to = main.takeUntil(other).test(); assertTrue("Main no observers?", main.hasObservers()); assertTrue("Other no observers?", other.hasObservers()); other.onNext(1); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasObservers()); to.assertResult(); }
@Test public void untilPublisherOtherOnComplete() { PublishSubject<Integer> main = PublishSubject.create(); PublishSubject<Integer> other = PublishSubject.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 untilPublisherDispose() { PublishSubject<Integer> main = PublishSubject.create(); PublishSubject<Integer> other = PublishSubject.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 untilPublisherMainError() { PublishSubject<Integer> main = PublishSubject.create(); PublishSubject<Integer> other = PublishSubject.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 untilPublisherOtherError() { PublishSubject<Integer> main = PublishSubject.create(); PublishSubject<Integer> other = PublishSubject.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 fromObservableDisposeComposesThrough() { PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = ps.singleElement().test(false); assertTrue(ps.hasObservers()); to.cancel(); assertFalse(ps.hasObservers()); }
@Test public void methodTestCancelled() { PublishSubject<Integer> ps = PublishSubject.create(); ps.test(true); assertFalse(ps.hasObservers()); }
@Test public void shouldUnsubscribeFromUnderlyingSubscriptionOnDispose() { final PublishSubject<String> subject = PublishSubject.create(); final TestScheduler scheduler = new TestScheduler(); final TestObserver<Void> observer = subject.ignoreElements() .timeout(100, TimeUnit.MILLISECONDS, scheduler) .test(); assertTrue(subject.hasObservers()); observer.dispose(); assertFalse(subject.hasObservers()); }
@Test public void shouldUnsubscribeFromUnderlyingSubscriptionOnDispose() { final PublishSubject<String> subject = PublishSubject.create(); final TestScheduler scheduler = new TestScheduler(); final TestObserver<String> observer = subject.single("") .timeout(100, TimeUnit.MILLISECONDS, scheduler) .test(); assertTrue(subject.hasObservers()); observer.dispose(); assertFalse(subject.hasObservers()); }
@Test public void methodTestNoCancel() { PublishSubject<Integer> ps = PublishSubject.create(); ps.single(-99).test(false); assertTrue(ps.hasObservers()); }
@Test public void methodTestNoCancel() { PublishSubject<Integer> ps = PublishSubject.create(); ps.ignoreElements().test(false); assertTrue(ps.hasObservers()); } }
@Test public void cancel() { PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = ps.ignoreElements().<Integer>toObservable().test(); assertTrue(ps.hasObservers()); to.cancel(); assertFalse(ps.hasObservers()); TestHelper.checkDisposed(ps.ignoreElements().<Integer>toObservable()); }
@Test public void selectorTake() { PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = ps .timeout(Functions.justFunction(Observable.never())) .take(1) .test(); assertTrue(ps.hasObservers()); ps.onNext(1); assertFalse(ps.hasObservers()); to.assertResult(1); }
@Test public void subscribeToAfterComplete() { PublishSubject<Integer> ps = PublishSubject.create(); ps.onComplete(); PublishSubject<Integer> ps2 = PublishSubject.create(); ps2.subscribe(ps); assertFalse(ps2.hasObservers()); }
@Test public void cancelMain() { CompletableSubject cs = CompletableSubject.create(); PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = cs.andThen(ps) .test(); assertTrue(cs.hasObservers()); assertFalse(ps.hasObservers()); to.cancel(); assertFalse(cs.hasObservers()); assertFalse(ps.hasObservers()); }
@Test public void cancel() { final PublishSubject<Integer> ps = PublishSubject.create(); final MaybeSubject<Integer> cs = MaybeSubject.create(); TestObserver<Integer> to = ps.mergeWith(cs).test(); assertTrue(ps.hasObservers()); assertTrue(cs.hasObservers()); to.cancel(); assertFalse(ps.hasObservers()); assertFalse(cs.hasObservers()); }
@Test public void cancel() { final PublishSubject<Integer> ps = PublishSubject.create(); final CompletableSubject cs = CompletableSubject.create(); TestObserver<Integer> to = ps.mergeWith(cs).test(); assertTrue(ps.hasObservers()); assertTrue(cs.hasObservers()); to.cancel(); assertFalse(ps.hasObservers()); assertFalse(cs.hasObservers()); }
@Test public void cancelMain() { SingleSubject<Integer> ss = SingleSubject.create(); PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = ss.flatMapObservable(Functions.justFunction(ps)) .test(); assertTrue(ss.hasObservers()); assertFalse(ps.hasObservers()); to.cancel(); assertFalse(ss.hasObservers()); assertFalse(ps.hasObservers()); }
@Test public void cancelMain() { 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()); to.cancel(); assertFalse(ms.hasObservers()); assertFalse(ps.hasObservers()); }