/** * Returns an Observable that automatically connects to this ConnectableObservable * when the first Subscriber subscribes. * * @return an Observable that automatically connects to this ConnectableObservable * when the first Subscriber subscribes */ @NonNull public Observable<T> autoConnect() { return autoConnect(1); } /**
/** * Returns an Observable that automatically connects to this ConnectableObservable * when the first Subscriber subscribes. * * @return an Observable that automatically connects to this ConnectableObservable * when the first Subscriber subscribes */ @NonNull public Observable<T> autoConnect() { return autoConnect(1); } /**
/** * Returns an Observable that automatically connects to this ConnectableObservable * when the specified number of Subscribers subscribe to it. * * @param numberOfSubscribers the number of subscribers to await before calling connect * on the ConnectableObservable. A non-positive value indicates * an immediate connection. * @return an Observable that automatically connects to this ConnectableObservable * when the specified number of Subscribers subscribe to it */ @NonNull public Observable<T> autoConnect(int numberOfSubscribers) { return autoConnect(numberOfSubscribers, Functions.emptyConsumer()); }
/** * Returns an Observable that automatically connects to this ConnectableObservable * when the specified number of Subscribers subscribe to it. * * @param numberOfSubscribers the number of subscribers to await before calling connect * on the ConnectableObservable. A non-positive value indicates * an immediate connection. * @return an Observable that automatically connects to this ConnectableObservable * when the specified number of Subscribers subscribe to it */ @NonNull public Observable<T> autoConnect(int numberOfSubscribers) { return autoConnect(numberOfSubscribers, Functions.emptyConsumer()); }
@Test public void replayMaxInt() { Observable.range(1, 2) .replay(Integer.MAX_VALUE) .autoConnect() .test() .assertResult(1, 2); }
@Test public void cancelOnArrival() { Observable.range(1, 2) .replay(Integer.MAX_VALUE) .autoConnect() .test(true) .assertEmpty(); }
@Test public void autoConnectImmediately() { PublishSubject<Integer> ps = PublishSubject.create(); ps.publish().autoConnect(0); assertTrue(ps.hasObservers()); } }
@Test public void testColdReplayNoBackpressure() { Observable<Integer> source = Observable.range(0, 1000).replay().autoConnect(); TestObserver<Integer> ts = new TestObserver<Integer>(); source.subscribe(ts); ts.assertNoErrors(); ts.assertTerminated(); List<Integer> onNextEvents = ts.values(); assertEquals(1000, onNextEvents.size()); for (int i = 0; i < 1000; i++) { assertEquals((Integer)i, onNextEvents.get(i)); } }
@Test public void cancelOnArrival2() { ConnectableObservable<Integer> co = PublishSubject.<Integer>create() .replay(Integer.MAX_VALUE); co.test(); co .autoConnect() .test(true) .assertEmpty(); }
@Test public void replayTime() { Observable.just(1).replay(1, TimeUnit.MINUTES) .autoConnect() .test() .awaitDone(5, TimeUnit.SECONDS) .assertResult(1); }
@Test public void replaySizeAndTime() { Observable.just(1).replay(1, 1, TimeUnit.MILLISECONDS) .autoConnect() .test() .awaitDone(5, TimeUnit.SECONDS) .assertResult(1); }
@Test public void replaySizeScheduler() { Observable.just(1).replay(1, Schedulers.computation()) .autoConnect() .test() .awaitDone(5, TimeUnit.SECONDS) .assertResult(1); }
@Test public void reentrantOnNextCancelBounded() { final PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = new TestObserver<Integer>() { @Override public void onNext(Integer t) { if (t == 1) { ps.onNext(2); cancel(); } super.onNext(t); } }; ps.replay(10).autoConnect().subscribe(to); ps.onNext(1); to.assertValues(1); }
@Test public void replayScheduler() { Observable.just(1).replay(Schedulers.computation()) .autoConnect() .test() .awaitDone(5, TimeUnit.SECONDS) .assertResult(1); }
@Test public void reentrantOnNext() { final PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = new TestObserver<Integer>() { @Override public void onNext(Integer t) { if (t == 1) { ps.onNext(2); ps.onComplete(); } super.onNext(t); } }; ps.replay().autoConnect().subscribe(to); ps.onNext(1); to.assertResult(1, 2); }
@Test public void reentrantOnNextCancel() { final PublishSubject<Integer> ps = PublishSubject.create(); TestObserver<Integer> to = new TestObserver<Integer>() { @Override public void onNext(Integer t) { if (t == 1) { ps.onNext(2); cancel(); } super.onNext(t); } }; ps.replay().autoConnect().subscribe(to); ps.onNext(1); to.assertValues(1); }
@Test public void testTake() { TestObserver<Integer> ts = new TestObserver<Integer>(); Observable<Integer> cached = Observable.range(1, 100).replay().autoConnect(); cached.take(10).subscribe(ts); ts.assertNoErrors(); ts.assertTerminated(); ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); // FIXME no longer assertable // ts.assertUnsubscribed(); }
@Test public void timedNoOutdatedData() { TestScheduler scheduler = new TestScheduler(); Observable<Integer> source = Observable.just(1) .replay(2, TimeUnit.SECONDS, scheduler) .autoConnect(); source.test().assertResult(1); source.test().assertResult(1); scheduler.advanceTimeBy(3, TimeUnit.SECONDS); source.test().assertResult(); }
@Test public void testValuesAndThenError() { Observable<Integer> source = Observable.range(1, 10) .concatWith(Observable.<Integer>error(new TestException())) .replay().autoConnect(); TestObserver<Integer> ts = new TestObserver<Integer>(); source.subscribe(ts); ts.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); ts.assertNotComplete(); Assert.assertEquals(1, ts.errors().size()); TestObserver<Integer> ts2 = new TestObserver<Integer>(); source.subscribe(ts2); ts2.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); ts2.assertNotComplete(); Assert.assertEquals(1, ts2.errors().size()); }
@Test public void testAsync() { Observable<Integer> source = Observable.range(1, 10000); for (int i = 0; i < 100; i++) { TestObserver<Integer> ts1 = new TestObserver<Integer>(); Observable<Integer> cached = source.replay().autoConnect(); cached.observeOn(Schedulers.computation()).subscribe(ts1); ts1.awaitTerminalEvent(2, TimeUnit.SECONDS); ts1.assertNoErrors(); ts1.assertTerminated(); assertEquals(10000, ts1.values().size()); TestObserver<Integer> ts2 = new TestObserver<Integer>(); cached.observeOn(Schedulers.computation()).subscribe(ts2); ts2.awaitTerminalEvent(2, TimeUnit.SECONDS); ts2.assertNoErrors(); ts2.assertTerminated(); assertEquals(10000, ts2.values().size()); } } @Test