@Test public void dispose() { TestHelper.checkDisposed(PublishSubject.create().takeUntil(Observable.never())); }
@Test public void dispose() { TestHelper.checkDisposed(PublishSubject.create().takeUntil(Functions.alwaysFalse())); }
@Test public void testDownstreamUnsubscribes() { PublishSubject<Integer> source = PublishSubject.create(); PublishSubject<Integer> until = PublishSubject.create(); TestObserver<Integer> to = new TestObserver<Integer>(); source.takeUntil(until).take(1).subscribe(to); assertTrue(source.hasObservers()); assertTrue(until.hasObservers()); source.onNext(1); to.assertValue(1); to.assertNoErrors(); to.assertTerminated(); assertFalse("Source still has observers", source.hasObservers()); assertFalse("Until still has observers", until.hasObservers()); // 2.0.2 - not anymore // assertTrue("Not cancelled!", ts.isCancelled()); }
@Test public void testMainCompletes() { PublishSubject<Integer> source = PublishSubject.create(); PublishSubject<Integer> until = PublishSubject.create(); TestObserver<Integer> to = new TestObserver<Integer>(); source.takeUntil(until).subscribe(to); assertTrue(source.hasObservers()); assertTrue(until.hasObservers()); source.onNext(1); source.onComplete(); to.assertValue(1); to.assertNoErrors(); to.assertTerminated(); assertFalse("Source still has observers", source.hasObservers()); assertFalse("Until still has observers", until.hasObservers()); // 2.0.2 - not anymore // assertTrue("Not cancelled!", ts.isCancelled()); }
@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 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 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 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 testUntilFires() { PublishSubject<Integer> source = PublishSubject.create(); PublishSubject<Integer> until = PublishSubject.create(); TestObserver<Integer> to = new TestObserver<Integer>(); source.takeUntil(until).subscribe(to); assertTrue(source.hasObservers()); assertTrue(until.hasObservers()); source.onNext(1); to.assertValue(1); until.onNext(1); to.assertValue(1); to.assertNoErrors(); to.assertTerminated(); assertFalse("Source still has observers", source.hasObservers()); assertFalse("Until still has observers", until.hasObservers()); // 2.0.2 - not anymore // assertTrue("Not cancelled!", ts.isCancelled()); }
@Test public void untilPublisherMainSuccess() { 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.onNext(1); main.onNext(2); main.onComplete(); assertFalse("Main has observers?", main.hasObservers()); assertFalse("Other has observers?", other.hasObservers()); to.assertResult(1, 2); }