@Override public void run() { ps.subscribe(); } };
@Override public void run() { ps.subscribe(to); } };
@Override public void run() { ps.subscribe(); } };
private void doSomeWork() { PublishSubject<Integer> source = PublishSubject.create(); source.subscribe(getFirstObserver()); // it will get 1, 2, 3, 4 and onComplete source.onNext(1); source.onNext(2); source.onNext(3); /* * it will emit 4 and onComplete for second observer also. */ source.subscribe(getSecondObserver()); source.onNext(4); source.onComplete(); }
@Test public void crossCancelOnComplete() { final TestObserver<Integer> to1 = new TestObserver<Integer>(); TestObserver<Integer> to2 = new TestObserver<Integer>() { @Override public void onComplete() { super.onComplete(); to1.cancel(); } }; PublishSubject<Integer> ps = PublishSubject.create(); ps.subscribe(to2); ps.subscribe(to1); ps.onComplete(); to2.assertComplete(); to1.assertNotComplete(); }
@Test public void crossCancel() { final TestObserver<Integer> to1 = new TestObserver<Integer>(); TestObserver<Integer> to2 = new TestObserver<Integer>() { @Override public void onNext(Integer t) { super.onNext(t); to1.cancel(); } }; PublishSubject<Integer> ps = PublishSubject.create(); ps.subscribe(to2); ps.subscribe(to1); ps.onNext(1); to2.assertValue(1); to1.assertNoValues(); }
@Test public void onSubscribeThrowsCancelsUpstream() { PublishSubject<Integer> ps = PublishSubject.create(); final List<Throwable> errors = new ArrayList<Throwable>(); ps.subscribe(new Consumer<Integer>() { @Override public void accept(Integer v) throws Exception { } }, new Consumer<Throwable>() { @Override public void accept(Throwable e) throws Exception { errors.add(e); } }, new Action() { @Override public void run() throws Exception { } }, new Consumer<Disposable>() { @Override public void accept(Disposable d) throws Exception { throw new TestException(); } }); assertFalse("Has observers?!", ps.hasObservers()); assertFalse("No errors?!", errors.isEmpty()); assertTrue(errors.toString(), errors.get(0) instanceof TestException); }
@Test public void crossCancelOnError() { final TestObserver<Integer> to1 = new TestObserver<Integer>(); TestObserver<Integer> to2 = new TestObserver<Integer>() { @Override public void onError(Throwable t) { super.onError(t); to1.cancel(); } }; PublishSubject<Integer> ps = PublishSubject.create(); ps.subscribe(to2); ps.subscribe(to1); ps.onError(new TestException()); to2.assertError(TestException.class); to1.assertNoErrors(); }
@Test public void testCompletedStopsEmittingData() { PublishSubject<Object> channel = PublishSubject.create(); Observer<Object> observerA = TestHelper.mockObserver(); Observer<Object> observerB = TestHelper.mockObserver(); Observer<Object> observerC = TestHelper.mockObserver(); TestObserver<Object> to = new TestObserver<Object>(observerA); channel.subscribe(to); channel.subscribe(observerB); InOrder inOrderA = inOrder(observerA); InOrder inOrderB = inOrder(observerB); InOrder inOrderC = inOrder(observerC); channel.onNext(42); inOrderA.verify(observerA).onNext(42); inOrderB.verify(observerB).onNext(42); to.dispose(); inOrderA.verifyNoMoreInteractions(); channel.onNext(4711); inOrderB.verify(observerB).onNext(4711); channel.onComplete(); inOrderB.verify(observerB).onComplete(); channel.subscribe(observerC); inOrderC.verify(observerC).onComplete(); channel.onNext(13); inOrderB.verifyNoMoreInteractions(); inOrderC.verifyNoMoreInteractions(); }
@Test public void onNextThrowsCancelsUpstream() { PublishSubject<Integer> ps = PublishSubject.create(); final List<Throwable> errors = new ArrayList<Throwable>(); ps.subscribe(new Consumer<Integer>() { @Override public void accept(Integer v) throws Exception { throw new TestException(); } }, new Consumer<Throwable>() { @Override public void accept(Throwable e) throws Exception { errors.add(e); } }); assertTrue("No observers?!", ps.hasObservers()); assertTrue("Has errors already?!", errors.isEmpty()); ps.onNext(1); assertFalse("Has observers?!", ps.hasObservers()); assertFalse("No errors?!", errors.isEmpty()); assertTrue(errors.toString(), errors.get(0) instanceof TestException); }
/** * Should be able to unsubscribe all Subscribers, have it stop emitting, then subscribe new ones and it start emitting again. */ @Test public void testReSubscribe() { final PublishSubject<Integer> ps = PublishSubject.create(); Observer<Integer> o1 = TestHelper.mockObserver(); TestObserver<Integer> to = new TestObserver<Integer>(o1); ps.subscribe(to); // emit ps.onNext(1); // validate we got it InOrder inOrder1 = inOrder(o1); inOrder1.verify(o1, times(1)).onNext(1); inOrder1.verifyNoMoreInteractions(); // unsubscribe to.dispose(); // emit again but nothing will be there to receive it ps.onNext(2); Observer<Integer> o2 = TestHelper.mockObserver(); TestObserver<Integer> to2 = new TestObserver<Integer>(o2); ps.subscribe(to2); // emit ps.onNext(3); // validate we got it InOrder inOrder2 = inOrder(o2); inOrder2.verify(o2, times(1)).onNext(3); inOrder2.verifyNoMoreInteractions(); to2.dispose(); }
@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 testError() { PublishSubject<String> subject = PublishSubject.create(); Observer<String> observer = TestHelper.mockObserver(); subject.subscribe(observer); subject.onNext("one"); subject.onNext("two"); subject.onNext("three"); subject.onError(testException); Observer<String> anotherSubscriber = TestHelper.mockObserver(); subject.subscribe(anotherSubscriber); subject.onNext("four"); subject.onError(new Throwable()); subject.onComplete(); assertErrorSubscriber(observer); // todo bug? assertNeverSubscriber(anotherSubscriber); }
@Test public void testCompleted() { PublishSubject<String> subject = PublishSubject.create(); Observer<String> observer = TestHelper.mockObserver(); subject.subscribe(observer); subject.onNext("one"); subject.onNext("two"); subject.onNext("three"); subject.onComplete(); Observer<String> anotherSubscriber = TestHelper.mockObserver(); subject.subscribe(anotherSubscriber); subject.onNext("four"); subject.onComplete(); subject.onError(new Throwable()); assertCompletedSubscriber(observer); // todo bug? assertNeverSubscriber(anotherSubscriber); }
@Test public void testSubscribeMidSequence() { PublishSubject<String> subject = PublishSubject.create(); Observer<String> observer = TestHelper.mockObserver(); subject.subscribe(observer); subject.onNext("one"); subject.onNext("two"); assertObservedUntilTwo(observer); Observer<String> anotherSubscriber = TestHelper.mockObserver(); subject.subscribe(anotherSubscriber); subject.onNext("three"); subject.onComplete(); assertCompletedSubscriber(observer); assertCompletedStartingWithThreeSubscriber(anotherSubscriber); }
@Test public void testUnsubscribeFirstSubscriber() { PublishSubject<String> subject = PublishSubject.create(); Observer<String> observer = TestHelper.mockObserver(); TestObserver<String> to = new TestObserver<String>(observer); subject.subscribe(to); subject.onNext("one"); subject.onNext("two"); to.dispose(); assertObservedUntilTwo(observer); Observer<String> anotherSubscriber = TestHelper.mockObserver(); subject.subscribe(anotherSubscriber); subject.onNext("three"); subject.onComplete(); assertObservedUntilTwo(observer); assertCompletedStartingWithThreeSubscriber(anotherSubscriber); }
@Test public void subscribedTo() { PublishSubject<Integer> ps = PublishSubject.create(); PublishSubject<Integer> ps2 = PublishSubject.create(); ps.subscribe(ps2); TestObserver<Integer> to = ps2.test(); ps.onNext(1); ps.onNext(2); ps.onComplete(); to.assertResult(1, 2); } }
@Test public void onSubscribeCancelsImmediately() { PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = ps.test(); ps.subscribe(new Observer<Integer>() { @Override public void onSubscribe(Disposable d) { d.dispose(); d.dispose(); } @Override public void onNext(Integer t) { } @Override public void onError(Throwable t) { } @Override public void onComplete() { } }); to.cancel(); assertFalse(ps.hasObservers()); }