Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservablePublishTest.java

raw
1 /*
2 * Copyright (c) 2016-present, RxJava Contributors.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
5 * compliance with the License. You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software distributed under the License is
10 * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
11 * the License for the specific language governing permissions and limitations under the License.
12 */
13
14 package io.reactivex.rxjava3.internal.operators.observable;
15
16 import static org.junit.Assert.*;
17
18 import java.util.*;
19 import java.util.concurrent.*;
20 import java.util.concurrent.atomic.*;
21
22 import org.junit.Test;
23
24 import io.reactivex.rxjava3.core.*;
25 import io.reactivex.rxjava3.core.Observable;
26 import io.reactivex.rxjava3.core.Observer;
27 import io.reactivex.rxjava3.disposables.*;
28 import io.reactivex.rxjava3.exceptions.TestException;
29 import io.reactivex.rxjava3.functions.*;
30 import io.reactivex.rxjava3.internal.functions.Functions;
31 import io.reactivex.rxjava3.internal.fuseable.HasUpstreamObservableSource;
32 import io.reactivex.rxjava3.observables.ConnectableObservable;
33 import io.reactivex.rxjava3.observers.TestObserver;
34 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
35 import io.reactivex.rxjava3.schedulers.*;
36 import io.reactivex.rxjava3.subjects.PublishSubject;
37 import io.reactivex.rxjava3.testsupport.*;
38
39 public class ObservablePublishTest extends RxJavaTest {
40
41 @Test
42 public void publish() throws InterruptedException {
43 final AtomicInteger counter = new AtomicInteger();
44 ConnectableObservable<String> o = Observable.unsafeCreate(new ObservableSource<String>() {
45
46 @Override
47 public void subscribe(final Observer<? super String> observer) {
48 observer.onSubscribe(Disposable.empty());
49 new Thread(new Runnable() {
50
51 @Override
52 public void run() {
53 counter.incrementAndGet();
54 observer.onNext("one");
55 observer.onComplete();
56 }
57 }).start();
58 }
59 }).publish();
60
61 final CountDownLatch latch = new CountDownLatch(2);
62
63 // subscribe once
64 o.subscribe(new Consumer<String>() {
65
66 @Override
67 public void accept(String v) {
68 assertEquals("one", v);
69 latch.countDown();
70 }
71 });
72
73 // subscribe again
74 o.subscribe(new Consumer<String>() {
75
76 @Override
77 public void accept(String v) {
78 assertEquals("one", v);
79 latch.countDown();
80 }
81 });
82
83 Disposable connection = o.connect();
84 try {
85 if (!latch.await(1000, TimeUnit.MILLISECONDS)) {
86 fail("subscriptions did not receive values");
87 }
88 assertEquals(1, counter.get());
89 } finally {
90 connection.dispose();
91 }
92 }
93
94 @Test
95 public void backpressureFastSlow() {
96 ConnectableObservable<Integer> is = Observable.range(1, Flowable.bufferSize() * 2).publish();
97 Observable<Integer> fast = is.observeOn(Schedulers.computation())
98 .doOnComplete(new Action() {
99 @Override
100 public void run() {
101 System.out.println("^^^^^^^^^^^^^ completed FAST");
102 }
103 });
104
105 Observable<Integer> slow = is.observeOn(Schedulers.computation()).map(new Function<Integer, Integer>() {
106 int c;
107
108 @Override
109 public Integer apply(Integer i) {
110 if (c == 0) {
111 try {
112 Thread.sleep(500);
113 } catch (InterruptedException e) {
114 }
115 }
116 c++;
117 return i;
118 }
119
120 }).doOnComplete(new Action() {
121
122 @Override
123 public void run() {
124 System.out.println("^^^^^^^^^^^^^ completed SLOW");
125 }
126
127 });
128
129 TestObserver<Integer> to = new TestObserver<>();
130 Observable.merge(fast, slow).subscribe(to);
131 is.connect();
132 to.awaitDone(5, TimeUnit.SECONDS);
133 to.assertNoErrors();
134 assertEquals(Flowable.bufferSize() * 4, to.values().size());
135 }
136
137 // use case from https://github.com/ReactiveX/RxJava/issues/1732
138 @Test
139 public void takeUntilWithPublishedStreamUsingSelector() {
140 final AtomicInteger emitted = new AtomicInteger();
141 Observable<Integer> xs = Observable.range(0, Flowable.bufferSize() * 2).doOnNext(new Consumer<Integer>() {
142
143 @Override
144 public void accept(Integer t1) {
145 emitted.incrementAndGet();
146 }
147
148 });
149 TestObserver<Integer> to = new TestObserver<>();
150 xs.publish(new Function<Observable<Integer>, Observable<Integer>>() {
151
152 @Override
153 public Observable<Integer> apply(Observable<Integer> xs) {
154 return xs.takeUntil(xs.skipWhile(new Predicate<Integer>() {
155
156 @Override
157 public boolean test(Integer i) {
158 return i <= 3;
159 }
160
161 }));
162 }
163
164 }).subscribe(to);
165 to.awaitDone(5, TimeUnit.SECONDS);
166 to.assertNoErrors();
167 to.assertValues(0, 1, 2, 3);
168 assertEquals(5, emitted.get());
169 System.out.println(to.values());
170 }
171
172 // use case from https://github.com/ReactiveX/RxJava/issues/1732
173 @Test
174 public void takeUntilWithPublishedStream() {
175 Observable<Integer> xs = Observable.range(0, Flowable.bufferSize() * 2);
176 TestObserver<Integer> to = new TestObserver<>();
177 ConnectableObservable<Integer> xsp = xs.publish();
178 xsp.takeUntil(xsp.skipWhile(new Predicate<Integer>() {
179
180 @Override
181 public boolean test(Integer i) {
182 return i <= 3;
183 }
184
185 })).subscribe(to);
186 xsp.connect();
187 System.out.println(to.values());
188 }
189
190 @Test
191 public void backpressureTwoConsumers() {
192 final AtomicInteger sourceEmission = new AtomicInteger();
193 final AtomicBoolean sourceUnsubscribed = new AtomicBoolean();
194 final Observable<Integer> source = Observable.range(1, 100)
195 .doOnNext(new Consumer<Integer>() {
196 @Override
197 public void accept(Integer t1) {
198 sourceEmission.incrementAndGet();
199 }
200 })
201 .doOnDispose(new Action() {
202 @Override
203 public void run() {
204 sourceUnsubscribed.set(true);
205 }
206 }).share();
207 ;
208
209 final AtomicBoolean child1Unsubscribed = new AtomicBoolean();
210 final AtomicBoolean child2Unsubscribed = new AtomicBoolean();
211
212 final TestObserver<Integer> to2 = new TestObserver<>();
213
214 final TestObserver<Integer> to1 = new TestObserver<Integer>() {
215 @Override
216 public void onNext(Integer t) {
217 if (values().size() == 2) {
218 source.doOnDispose(new Action() {
219 @Override
220 public void run() {
221 child2Unsubscribed.set(true);
222 }
223 }).take(5).subscribe(to2);
224 }
225 super.onNext(t);
226 }
227 };
228
229 source.doOnDispose(new Action() {
230 @Override
231 public void run() {
232 child1Unsubscribed.set(true);
233 }
234 }).take(5)
235 .subscribe(to1);
236
237 to1.awaitDone(5, TimeUnit.SECONDS);
238 to2.awaitDone(5, TimeUnit.SECONDS);
239
240 to1.assertNoErrors();
241 to2.assertNoErrors();
242
243 assertTrue(sourceUnsubscribed.get());
244 assertTrue(child1Unsubscribed.get());
245 assertTrue(child2Unsubscribed.get());
246
247 to1.assertValues(1, 2, 3, 4, 5);
248 to2.assertValues(4, 5, 6, 7, 8);
249
250 assertEquals(8, sourceEmission.get());
251 }
252
253 @Test
254 public void connectWithNoSubscriber() {
255 TestScheduler scheduler = new TestScheduler();
256 ConnectableObservable<Long> co = Observable.interval(10, 10, TimeUnit.MILLISECONDS, scheduler).take(3).publish();
257 co.connect();
258 // Emit 0
259 scheduler.advanceTimeBy(15, TimeUnit.MILLISECONDS);
260 TestObserverEx<Long> to = new TestObserverEx<>();
261 co.subscribe(to);
262 // Emit 1 and 2
263 scheduler.advanceTimeBy(50, TimeUnit.MILLISECONDS);
264 to.assertValues(1L, 2L);
265 to.assertNoErrors();
266 to.assertTerminated();
267 }
268
269 @Test
270 public void subscribeAfterDisconnectThenConnect() {
271 ConnectableObservable<Integer> source = Observable.just(1).publish();
272
273 TestObserverEx<Integer> to1 = new TestObserverEx<>();
274
275 source.subscribe(to1);
276
277 Disposable connection = source.connect();
278
279 to1.assertValue(1);
280 to1.assertNoErrors();
281 to1.assertTerminated();
282
283 source.reset();
284
285 TestObserverEx<Integer> to2 = new TestObserverEx<>();
286
287 source.subscribe(to2);
288
289 Disposable connection2 = source.connect();
290
291 to2.assertValue(1);
292 to2.assertNoErrors();
293 to2.assertTerminated();
294
295 System.out.println(connection);
296 System.out.println(connection2);
297 }
298
299 @Test
300 public void noSubscriberRetentionOnCompleted() {
301 ObservablePublish<Integer> source = (ObservablePublish<Integer>)Observable.just(1).publish();
302
303 TestObserverEx<Integer> to1 = new TestObserverEx<>();
304
305 source.subscribe(to1);
306
307 to1.assertNoValues();
308 to1.assertNoErrors();
309 to1.assertNotComplete();
310
311 source.connect();
312
313 to1.assertValue(1);
314 to1.assertNoErrors();
315 to1.assertTerminated();
316
317 assertEquals(0, source.current.get().get().length);
318 }
319
320 @Test
321 public void nonNullConnection() {
322 ConnectableObservable<Object> source = Observable.never().publish();
323
324 assertNotNull(source.connect());
325 assertNotNull(source.connect());
326 }
327
328 @Test
329 public void noDisconnectSomeoneElse() {
330 ConnectableObservable<Object> source = Observable.never().publish();
331
332 Disposable connection1 = source.connect();
333 Disposable connection2 = source.connect();
334
335 connection1.dispose();
336
337 Disposable connection3 = source.connect();
338
339 connection2.dispose();
340
341 assertTrue(checkPublishDisposed(connection1));
342 assertTrue(checkPublishDisposed(connection2));
343 assertFalse(checkPublishDisposed(connection3));
344 }
345
346 @SuppressWarnings("unchecked")
347 static boolean checkPublishDisposed(Disposable d) {
348 return ((ObservablePublish.PublishConnection<Object>)d).isDisposed();
349 }
350
351 @Test
352 public void connectIsIdempotent() {
353 final AtomicInteger calls = new AtomicInteger();
354 Observable<Integer> source = Observable.unsafeCreate(new ObservableSource<Integer>() {
355 @Override
356 public void subscribe(Observer<? super Integer> t) {
357 t.onSubscribe(Disposable.empty());
358 calls.getAndIncrement();
359 }
360 });
361
362 ConnectableObservable<Integer> conn = source.publish();
363
364 assertEquals(0, calls.get());
365
366 conn.connect();
367 conn.connect();
368
369 assertEquals(1, calls.get());
370
371 conn.connect().dispose();
372
373 conn.connect();
374 conn.connect();
375
376 assertEquals(2, calls.get());
377 }
378
379 @Test
380 public void observeOn() {
381 ConnectableObservable<Integer> co = Observable.range(0, 1000).publish();
382 Observable<Integer> obs = co.observeOn(Schedulers.computation());
383 for (int i = 0; i < 1000; i++) {
384 for (int j = 1; j < 6; j++) {
385 List<TestObserverEx<Integer>> tos = new ArrayList<>();
386 for (int k = 1; k < j; k++) {
387 TestObserverEx<Integer> to = new TestObserverEx<>();
388 tos.add(to);
389 obs.subscribe(to);
390 }
391
392 Disposable connection = co.connect();
393
394 for (TestObserverEx<Integer> to : tos) {
395 to.awaitDone(2, TimeUnit.SECONDS);
396 to.assertTerminated();
397 to.assertNoErrors();
398 assertEquals(1000, to.values().size());
399 }
400 connection.dispose();
401 }
402 }
403 }
404
405 @Test
406 public void preNextConnect() {
407 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
408
409 final ConnectableObservable<Integer> co = Observable.<Integer>empty().publish();
410
411 co.connect();
412
413 Runnable r1 = new Runnable() {
414 @Override
415 public void run() {
416 co.test();
417 }
418 };
419
420 TestHelper.race(r1, r1);
421 }
422 }
423
424 @Test
425 public void connectRace() {
426 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
427
428 final ConnectableObservable<Integer> co = Observable.<Integer>empty().publish();
429
430 Runnable r1 = new Runnable() {
431 @Override
432 public void run() {
433 co.connect();
434 }
435 };
436
437 TestHelper.race(r1, r1);
438 }
439 }
440
441 @Test
442 public void selectorCrash() {
443 Observable.just(1).publish(new Function<Observable<Integer>, ObservableSource<Object>>() {
444 @Override
445 public ObservableSource<Object> apply(Observable<Integer> v) throws Exception {
446 throw new TestException();
447 }
448 })
449 .test()
450 .assertFailure(TestException.class);
451 }
452
453 @Test
454 public void source() {
455 Observable<Integer> o = Observable.never();
456
457 assertSame(o, (((HasUpstreamObservableSource<?>)o.publish()).source()));
458 }
459
460 @Test
461 public void connectThrows() {
462 ConnectableObservable<Integer> co = Observable.<Integer>empty().publish();
463 try {
464 co.connect(new Consumer<Disposable>() {
465 @Override
466 public void accept(Disposable d) throws Exception {
467 throw new TestException();
468 }
469 });
470 } catch (TestException ex) {
471 // expected
472 }
473 }
474
475 @Test
476 public void addRemoveRace() {
477 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
478
479 final ConnectableObservable<Integer> co = Observable.<Integer>empty().publish();
480
481 final TestObserver<Integer> to = co.test();
482
483 final TestObserver<Integer> to2 = new TestObserver<>();
484
485 Runnable r1 = new Runnable() {
486 @Override
487 public void run() {
488 co.subscribe(to2);
489 }
490 };
491
492 Runnable r2 = new Runnable() {
493 @Override
494 public void run() {
495 to.dispose();
496 }
497 };
498
499 TestHelper.race(r1, r2);
500 }
501 }
502
503 @Test
504 public void disposeOnArrival() {
505 ConnectableObservable<Integer> co = Observable.<Integer>empty().publish();
506
507 co.test(true).assertEmpty();
508 }
509
510 @Test
511 public void dispose() {
512 TestHelper.checkDisposed(Observable.never().publish());
513
514 TestHelper.checkDisposed(Observable.never().publish(Functions.<Observable<Object>>identity()));
515 }
516
517 @Test
518 public void empty() {
519 ConnectableObservable<Integer> co = Observable.<Integer>empty().publish();
520
521 co.connect();
522 }
523
524 @Test
525 public void take() {
526 ConnectableObservable<Integer> co = Observable.range(1, 2).publish();
527
528 TestObserver<Integer> to = co.take(1).test();
529
530 co.connect();
531
532 to.assertResult(1);
533 }
534
535 @Test
536 public void just() {
537 final PublishSubject<Integer> ps = PublishSubject.create();
538
539 ConnectableObservable<Integer> co = ps.publish();
540
541 TestObserver<Integer> to = new TestObserver<Integer>() {
542 @Override
543 public void onNext(Integer t) {
544 super.onNext(t);
545 ps.onComplete();
546 }
547 };
548
549 co.subscribe(to);
550 co.connect();
551
552 ps.onNext(1);
553
554 to.assertResult(1);
555 }
556
557 @Test
558 public void nextCancelRace() {
559 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
560
561 final PublishSubject<Integer> ps = PublishSubject.create();
562
563 final ConnectableObservable<Integer> co = ps.publish();
564
565 final TestObserver<Integer> to = co.test();
566
567 Runnable r1 = new Runnable() {
568 @Override
569 public void run() {
570 ps.onNext(1);
571 }
572 };
573
574 Runnable r2 = new Runnable() {
575 @Override
576 public void run() {
577 to.dispose();
578 }
579 };
580
581 TestHelper.race(r1, r2);
582 }
583 }
584
585 @Test
586 public void badSource() {
587 List<Throwable> errors = TestHelper.trackPluginErrors();
588 try {
589 new Observable<Integer>() {
590 @Override
591 protected void subscribeActual(Observer<? super Integer> observer) {
592 observer.onSubscribe(Disposable.empty());
593 observer.onNext(1);
594 observer.onComplete();
595 observer.onNext(2);
596 observer.onError(new TestException());
597 observer.onComplete();
598 }
599 }
600 .publish()
601 .autoConnect()
602 .test()
603 .assertResult(1);
604
605 TestHelper.assertUndeliverable(errors, 0, TestException.class);
606 } finally {
607 RxJavaPlugins.reset();
608 }
609 }
610
611 @Test
612 public void noErrorLoss() {
613 ConnectableObservable<Object> co = Observable.error(new TestException()).publish();
614
615 co.connect();
616
617 // 3.x: terminal events remain observable until reset
618 co.test()
619 .assertFailure(TestException.class);
620 }
621
622 @Test
623 public void subscribeDisconnectRace() {
624 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
625
626 final PublishSubject<Integer> ps = PublishSubject.create();
627
628 final ConnectableObservable<Integer> co = ps.publish();
629
630 final Disposable d = co.connect();
631 final TestObserver<Integer> to = new TestObserver<>();
632
633 Runnable r1 = new Runnable() {
634 @Override
635 public void run() {
636 d.dispose();
637 }
638 };
639
640 Runnable r2 = new Runnable() {
641 @Override
642 public void run() {
643 co.subscribe(to);
644 }
645 };
646
647 TestHelper.race(r1, r2);
648 }
649 }
650
651 @Test
652 public void selectorDisconnectsIndependentSource() {
653 PublishSubject<Integer> ps = PublishSubject.create();
654
655 ps.publish(new Function<Observable<Integer>, ObservableSource<Integer>>() {
656 @Override
657 public ObservableSource<Integer> apply(Observable<Integer> v) throws Exception {
658 return Observable.range(1, 2);
659 }
660 })
661 .test()
662 .assertResult(1, 2);
663
664 assertFalse(ps.hasObservers());
665 }
666
667 @Test
668 public void selectorLatecommer() {
669 Observable.range(1, 5)
670 .publish(new Function<Observable<Integer>, ObservableSource<Integer>>() {
671 @Override
672 public ObservableSource<Integer> apply(Observable<Integer> v) throws Exception {
673 return v.concatWith(v);
674 }
675 })
676 .test()
677 .assertResult(1, 2, 3, 4, 5);
678 }
679
680 @Test
681 public void mainError() {
682 Observable.error(new TestException())
683 .publish(Functions.<Observable<Object>>identity())
684 .test()
685 .assertFailure(TestException.class);
686 }
687
688 @Test
689 public void selectorInnerError() {
690 PublishSubject<Integer> ps = PublishSubject.create();
691
692 ps.publish(new Function<Observable<Integer>, ObservableSource<Integer>>() {
693 @Override
694 public ObservableSource<Integer> apply(Observable<Integer> v) throws Exception {
695 return Observable.error(new TestException());
696 }
697 })
698 .test()
699 .assertFailure(TestException.class);
700
701 assertFalse(ps.hasObservers());
702 }
703
704 @Test
705 public void delayedUpstreamOnSubscribe() {
706 final Observer<?>[] sub = { null };
707
708 new Observable<Integer>() {
709 @Override
710 protected void subscribeActual(Observer<? super Integer> observer) {
711 sub[0] = observer;
712 }
713 }
714 .publish()
715 .connect()
716 .dispose();
717
718 Disposable bs = Disposable.empty();
719
720 sub[0].onSubscribe(bs);
721
722 assertTrue(bs.isDisposed());
723 }
724
725 @Test
726 public void doubleOnSubscribe() {
727 TestHelper.checkDoubleOnSubscribeObservable(new Function<Observable<Object>, ObservableSource<Object>>() {
728 @Override
729 public ObservableSource<Object> apply(final Observable<Object> o)
730 throws Exception {
731 return Observable.<Integer>never().publish(new Function<Observable<Integer>, ObservableSource<Object>>() {
732 @Override
733 public ObservableSource<Object> apply(Observable<Integer> v)
734 throws Exception {
735 return o;
736 }
737 });
738 }
739 }
740 );
741 }
742
743 @Test
744 public void disposedUpfront() {
745 ConnectableObservable<Integer> co = Observable.just(1)
746 .concatWith(Observable.<Integer>never())
747 .publish();
748
749 TestObserver<Integer> to1 = co.test();
750
751 TestObserver<Integer> to2 = co.test(true);
752
753 co.connect();
754
755 to1.assertValuesOnly(1);
756
757 to2.assertEmpty();
758
759 ((ObservablePublish<Integer>)co).current.get().remove(null);
760 }
761
762 @Test
763 public void altConnectCrash() {
764 try {
765 new ObservablePublish<>(Observable.<Integer>empty())
766 .connect(new Consumer<Disposable>() {
767 @Override
768 public void accept(Disposable t) throws Exception {
769 throw new TestException();
770 }
771 });
772 fail("Should have thrown");
773 } catch (TestException expected) {
774 // expected
775 }
776 }
777
778 @Test
779 public void altConnectRace() {
780 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
781 final ConnectableObservable<Integer> co =
782 new ObservablePublish<>(Observable.<Integer>never());
783
784 Runnable r = new Runnable() {
785 @Override
786 public void run() {
787 co.connect();
788 }
789 };
790
791 TestHelper.race(r, r);
792 }
793 }
794
795 @Test
796 public void onCompleteAvailableUntilReset() {
797 ConnectableObservable<Integer> co = Observable.just(1).publish();
798
799 TestObserver<Integer> to = co.test();
800 to.assertEmpty();
801
802 co.connect();
803
804 to.assertResult(1);
805
806 co.test().assertResult();
807
808 co.reset();
809
810 to = co.test();
811 to.assertEmpty();
812
813 co.connect();
814
815 to.assertResult(1);
816 }
817
818 @Test
819 public void onErrorAvailableUntilReset() {
820 ConnectableObservable<Integer> co = Observable.just(1)
821 .concatWith(Observable.<Integer>error(new TestException()))
822 .publish();
823
824 TestObserver<Integer> to = co.test();
825 to.assertEmpty();
826
827 co.connect();
828
829 to.assertFailure(TestException.class, 1);
830
831 co.test().assertFailure(TestException.class);
832
833 co.reset();
834
835 to = co.test();
836 to.assertEmpty();
837
838 co.connect();
839
840 to.assertFailure(TestException.class, 1);
841 }
842
843 @Test
844 public void disposeResets() {
845 PublishSubject<Integer> ps = PublishSubject.create();
846
847 ConnectableObservable<Integer> co = ps.publish();
848
849 assertFalse(ps.hasObservers());
850
851 Disposable d = co.connect();
852
853 assertTrue(ps.hasObservers());
854
855 d.dispose();
856
857 assertFalse(ps.hasObservers());
858
859 TestObserver<Integer> to = co.test();
860
861 co.connect();
862
863 assertTrue(ps.hasObservers());
864
865 ps.onNext(1);
866
867 to.assertValuesOnly(1);
868 }
869
870 @Test
871 public void disposeNoNeedForReset() {
872 PublishSubject<Integer> ps = PublishSubject.create();
873
874 ConnectableObservable<Integer> co = ps.publish();
875
876 TestObserver<Integer> to = co.test();
877
878 Disposable d = co.connect();
879
880 ps.onNext(1);
881
882 d.dispose();
883
884 to = co.test();
885
886 to.assertEmpty();
887
888 co.connect();
889
890 to.assertEmpty();
891
892 ps.onNext(2);
893
894 to.assertValuesOnly(2);
895 }
896 }