@Override public void connect(Consumer<? super Disposable> connection) { co.connect(connection); }
@Override public void connect(Consumer<? super Disposable> connection) { co.connect(connection); }
@Override public void run() { co.connect(); } };
@Override public void subscribeActual(Observer<? super T> child) { source.subscribe(child); if (clients.incrementAndGet() == numberOfObservers) { source.connect(connection); } } }
@Override public void run() { co.connect(); } };
@Override public void subscribeActual(Observer<? super T> child) { source.subscribe(child); if (clients.incrementAndGet() == numberOfObservers) { source.connect(connection); } } }
/** * Instructs the {@code ConnectableObservable} to begin emitting the items from its underlying * {@link Observable} to its {@link Observer}s. * <p> * To disconnect from a synchronous source, use the {@link #connect(Consumer)} method. * * @return the subscription representing the connection * @see <a href="http://reactivex.io/documentation/operators/connect.html">ReactiveX documentation: Connect</a> */ public final Disposable connect() { ConnectConsumer cc = new ConnectConsumer(); connect(cc); return cc.disposable; }
/** * Instructs the {@code ConnectableObservable} to begin emitting the items from its underlying * {@link Observable} to its {@link Observer}s. * <p> * To disconnect from a synchronous source, use the {@link #connect(Consumer)} method. * * @return the subscription representing the connection * @see <a href="http://reactivex.io/documentation/operators/connect.html">ReactiveX documentation: Connect</a> */ public final Disposable connect() { ConnectConsumer cc = new ConnectConsumer(); connect(cc); return cc.disposable; }
@Test public void empty() { ConnectableObservable<Integer> co = Observable.<Integer>empty().publish(); co.connect(); }
@Test public void connectThrows() { ConnectableObservable<Integer> co = Observable.<Integer>empty().publish(); try { co.connect(new Consumer<Disposable>() { @Override public void accept(Disposable s) throws Exception { throw new TestException(); } }); } catch (TestException ex) { // expected } }
@Test public void testNoDisconnectSomeoneElse() { ConnectableObservable<Object> source = Observable.never().publish(); Disposable s1 = source.connect(); Disposable s2 = source.connect(); s1.dispose(); Disposable s3 = source.connect(); s2.dispose(); assertTrue(checkPublishDisposed(s1)); assertTrue(checkPublishDisposed(s2)); assertFalse(checkPublishDisposed(s3)); }
@Test public void preNextConnect() { for (int i = 0; i < 500; i++) { final ConnectableObservable<Integer> co = Observable.<Integer>empty().publish(); co.connect(); Runnable r1 = new Runnable() { @Override public void run() { co.test(); } }; TestCommonHelper.race(r1, r1); } }
@Test public void take() { ConnectableObservable<Integer> co = Observable.range(1, 2).publish(); TestObserver<Integer> to = co.take(1).test(); co.connect(); to.assertResult(1); }
@Test public void noErrorLoss() { List<Throwable> errors = TestCommonHelper.trackPluginErrors(); try { ConnectableObservable<Object> co = Observable.error(new TestException()).publish(); co.connect(); TestCommonHelper.assertUndeliverable(errors, 0, TestException.class); } finally { RxJavaCommonPlugins.reset(); } }
@Test public void just() { final PublishSubject<Integer> ps = PublishSubject.create(); ConnectableObservable<Integer> co = ps.publish(); TestObserver<Integer> to = new TestObserver<Integer>() { @Override public void onNext(Integer t) { super.onNext(t); ps.onComplete(); } }; co.subscribe(to); co.connect(); ps.onNext(1); to.assertResult(1); }
@Test public void testTakeUntilWithPublishedStream() { Observable<Integer> xs = Observable.range(0, Observable.bufferSize() * 2); TestObserver<Integer> ts = new TestObserver<Integer>(); ConnectableObservable<Integer> xsp = xs.publish(); xsp.takeUntil(xsp.skipWhile(new Predicate<Integer>() { @Override public boolean test(Integer i) { return i <= 3; } })).subscribe(ts); xsp.connect(); System.out.println(ts.values()); }
@Test public void delayedUpstreamOnSubscribe() { final Observer<?>[] sub = { null }; new Observable<Integer>() { @Override protected void subscribeActual(Observer<? super Integer> s) { sub[0] = s; } } .replay() .connect() .dispose(); Disposable bs = Disposables.empty(); sub[0].onSubscribe(bs); assertTrue(bs.isDisposed()); }
@Test public void replayIsUnsubscribed() { ConnectableObservable<Integer> co = Observable.just(1).concatWith(Observable.<Integer>never()) .replay(); assertTrue(((Disposable)co).isDisposed()); Disposable s = co.connect(); assertFalse(((Disposable)co).isDisposed()); s.dispose(); assertTrue(((Disposable)co).isDisposed()); } }
@Test public void testConnectWithNoSubscriber() { TestScheduler scheduler = new TestScheduler(); ConnectableObservable<Long> co = Observable.interval(10, 10, TimeUnit.MILLISECONDS, scheduler).take(3).publish(); co.connect(); // Emit 0 scheduler.advanceTimeBy(15, TimeUnit.MILLISECONDS); TestObserver<Long> to = new TestObserver<Long>(); co.subscribe(to); // Emit 1 and 2 scheduler.advanceTimeBy(50, TimeUnit.MILLISECONDS); to.assertValues(1L, 2L); to.assertNoErrors(); to.assertTerminated(); }