@Override public void run() { ps2.onError(ex); } };
@Test public void subscribeToAfterComplete() { PublishSubject<Integer> ps = PublishSubject.create(); ps.onComplete(); PublishSubject<Integer> ps2 = PublishSubject.create(); ps2.subscribe(ps); assertFalse(ps2.hasObservers()); }
@Override public void run() { ps.onNext(1); ps.onComplete(); } };
@Test public void timedFallbackTake() { PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = ps.timeout(1, TimeUnit.DAYS, Observable.just(2)) .take(1) .test(); assertTrue(ps.hasObservers()); ps.onNext(1); assertFalse(ps.hasObservers()); to.assertResult(1); }
@Test public void switchOnNextDelayError() { PublishSubject<Observable<Integer>> ps = PublishSubject.create(); TestObserver<Integer> to = Observable.switchOnNextDelayError(ps).test(); ps.onNext(Observable.just(1)); ps.onNext(Observable.range(2, 4)); ps.onComplete(); to.assertResult(1, 2, 3, 4, 5); }
@Test public void innerErrorDelayed() { final PublishSubject<Integer> ps = PublishSubject.create(); final CompletableSubject cs = CompletableSubject.create(); TestObserver<Void> to = ps.switchMapCompletableDelayError(Functions.justFunction(cs)).test(); ps.onNext(1); cs.onError(new TestException()); to.assertEmpty(); assertTrue(ps.hasObservers()); ps.onComplete(); to.assertFailure(TestException.class); }
@Test public void delayed() { PublishSubject<Integer> ps = PublishSubject.create(); Single<Integer> cache = ps.single(-99).cache(); TestObserver<Integer> to1 = cache.test(); TestObserver<Integer> to2 = cache.test(); ps.onNext(1); ps.onComplete(); to1.assertResult(1); to2.assertResult(1); }
@Test public void testPublishSubjectValueRelay() { PublishSubject<Integer> async = PublishSubject.create(); async.onNext(1); async.onComplete(); Subject<Integer> serial = async.toSerialized(); assertFalse(serial.hasObservers()); assertTrue(serial.hasComplete()); assertFalse(serial.hasThrowable()); assertNull(serial.getThrowable()); }
@Test public void bufferWithBOSourceThrows() { PublishSubject<Integer> source = PublishSubject.create(); PublishSubject<Integer> boundary = PublishSubject.create(); Observer<Object> o = TestHelper.mockObserver(); source.buffer(boundary).subscribe(o); source.onNext(1); source.onError(new TestException()); verify(o).onError(any(TestException.class)); verify(o, never()).onComplete(); verify(o, never()).onNext(any()); }
@Test public void innerSuccessCompletesAfterMain() { PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = Observable.just(1).flatMapSingle(Functions.justFunction(ps.singleOrError())) .test(); ps.onNext(2); ps.onComplete(); to .assertResult(2); }
@Test public void innerSuccessCompletesAfterMain() { PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = Observable.just(1).flatMapMaybe(Functions.justFunction(ps.singleElement())) .test(); ps.onNext(2); ps.onComplete(); to .assertResult(2); }
@Test public void debounceTimedLastIsNotLost() { PublishSubject<Integer> source = PublishSubject.create(); Observer<Object> o = TestHelper.mockObserver(); source.debounce(100, TimeUnit.MILLISECONDS, scheduler).subscribe(o); source.onNext(1); source.onComplete(); scheduler.advanceTimeBy(1, TimeUnit.SECONDS); verify(o).onNext(1); verify(o).onComplete(); verify(o, never()).onError(any(Throwable.class)); }
@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(); }
@Override public void run() { for (int j = 0; j < 1000; j++) { ps.onNext(j); } } };
@Test public void methodTestNoCancel() { PublishSubject<Integer> ps = PublishSubject.create(); ps.ignoreElements().test(false); assertTrue(ps.hasObservers()); } }
@Test public void mainErrorDelayed() { final PublishSubject<Integer> ps = PublishSubject.create(); final CompletableSubject cs = CompletableSubject.create(); TestObserver<Void> to = ps.switchMapCompletableDelayError(Functions.justFunction(cs)).test(); ps.onNext(1); ps.onError(new TestException()); to.assertEmpty(); assertTrue(cs.hasObservers()); cs.onComplete(); 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 cancel() { final PublishSubject<Integer> ps = PublishSubject.create(); final SingleSubject<Integer> cs = SingleSubject.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 exactOnError() { TestScheduler scheduler = new TestScheduler(); PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = ps.window(1, 1, TimeUnit.SECONDS, scheduler) .flatMap(Functions.<Observable<Integer>>identity()) .test(); ps.onError(new TestException()); to.assertFailure(TestException.class); }