@Test public void biConsumerDispose() { PublishSubject<Integer> ps = PublishSubject.create(); Disposable d = ps.single(-99).subscribe(new BiConsumer<Object, Object>() { @Override public void accept(Object t1, Object t2) throws Exception { } }); assertFalse(d.isDisposed()); d.dispose(); assertTrue(d.isDisposed()); assertFalse(ps.hasObservers()); }
@Test public void methodTestNoCancel() { PublishSubject<Integer> ps = PublishSubject.create(); ps.single(-99).test(false); assertTrue(ps.hasObservers()); }
@Test public void consumerDispose() { PublishSubject<Integer> ps = PublishSubject.create(); Disposable d = ps.single(-99).subscribe(Functions.<Integer>emptyConsumer()); assertFalse(d.isDisposed()); d.dispose(); assertTrue(d.isDisposed()); assertFalse(ps.hasObservers()); }
@Test public void onSuccessCancelRace() { for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) { final PublishSubject<Integer> ps = PublishSubject.create(); final Future<?> f = ps.single(-99).toFuture(); ps.onNext(1); Runnable r1 = new Runnable() { @Override public void run() { f.cancel(true); } }; Runnable r2 = new Runnable() { @Override public void run() { ps.onComplete(); } }; TestHelper.race(r1, r2); } }
@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 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()); }
final PublishSubject<Integer> ps = PublishSubject.create(); final Future<?> f = ps.single(-99).toFuture();
@Test public void delayedDisposed() { PublishSubject<Integer> ps = PublishSubject.create(); Single<Integer> cache = ps.single(-99).cache(); TestObserver<Integer> to1 = cache.test(); TestObserver<Integer> to2 = cache.test(); to1.cancel(); ps.onNext(1); ps.onComplete(); to1.assertNoValues().assertNoErrors().assertNotComplete(); to2.assertResult(1); }
@Test public void crossCancelOnError() { PublishSubject<Integer> ps = PublishSubject.create(); Single<Integer> cache = ps.single(-99).cache(); final TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>(); TestSubscriber<Integer> ts2 = new TestSubscriber<Integer>() { @Override public void onError(Throwable t) { super.onError(t); ts1.cancel(); } }; cache.toFlowable().subscribe(ts2); cache.toFlowable().subscribe(ts1); ps.onError(new TestException()); ts1.assertNoValues().assertNoErrors().assertNotComplete(); ts2.assertFailure(TestException.class); }
@Test public void crossCancel() { PublishSubject<Integer> ps = PublishSubject.create(); Single<Integer> cache = ps.single(-99).cache(); final TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>(); TestSubscriber<Integer> ts2 = new TestSubscriber<Integer>() { @Override public void onNext(Integer t) { super.onNext(t); ts1.cancel(); } }; cache.toFlowable().subscribe(ts2); cache.toFlowable().subscribe(ts1); ps.onNext(1); ps.onComplete(); ts1.assertNoValues().assertNoErrors().assertNotComplete(); ts2.assertResult(1); }
@Test public void s2s1Cancel() { io.reactivex.subjects.PublishSubject<Integer> ps = io.reactivex.subjects.PublishSubject.create(); rx.observers.TestSubscriber<Integer> ts = test1(toV1Single(ps.single(-99))); assertTrue("2.x PublishSubject has no observers!", ps.hasObservers()); ts.unsubscribe(); assertFalse("2.x PublishSubject has observers!", ps.hasObservers()); }