Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableRefCountTest.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 import static org.mockito.ArgumentMatchers.any;
18 import static org.mockito.Mockito.*;
19
20 import java.io.IOException;
21 import java.lang.management.ManagementFactory;
22 import java.util.*;
23 import java.util.concurrent.*;
24 import java.util.concurrent.atomic.*;
25
26 import org.junit.Test;
27 import org.mockito.InOrder;
28
29 import io.reactivex.rxjava3.core.*;
30 import io.reactivex.rxjava3.core.Observable;
31 import io.reactivex.rxjava3.core.Observer;
32 import io.reactivex.rxjava3.disposables.*;
33 import io.reactivex.rxjava3.exceptions.*;
34 import io.reactivex.rxjava3.functions.*;
35 import io.reactivex.rxjava3.internal.functions.Functions;
36 import io.reactivex.rxjava3.internal.operators.observable.ObservableRefCount.RefConnection;
37 import io.reactivex.rxjava3.internal.util.ExceptionHelper;
38 import io.reactivex.rxjava3.observables.ConnectableObservable;
39 import io.reactivex.rxjava3.observers.TestObserver;
40 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
41 import io.reactivex.rxjava3.schedulers.*;
42 import io.reactivex.rxjava3.subjects.*;
43 import io.reactivex.rxjava3.testsupport.*;
44
45 public class ObservableRefCountTest extends RxJavaTest {
46
47 @Test
48 public void refCountAsync() throws InterruptedException {
49 // Flaky
50 for (int i = 0; i < 10; i++) {
51 try {
52 refCountAsyncActual();
53 return;
54 } catch (AssertionError ex) {
55 if (i == 9) {
56 throw ex;
57 }
58 Thread.sleep((int)(200 * (Math.random() * 10 + 1)));
59 }
60 }
61 }
62
63 /**
64 * Tries to coordinate async counting but it is flaky due to the low 10s of milliseconds.
65 */
66 void refCountAsyncActual() {
67 final AtomicInteger subscribeCount = new AtomicInteger();
68 final AtomicInteger nextCount = new AtomicInteger();
69 Observable<Long> r = Observable.interval(0, 25, TimeUnit.MILLISECONDS)
70 .doOnSubscribe(new Consumer<Disposable>() {
71 @Override
72 public void accept(Disposable d) {
73 subscribeCount.incrementAndGet();
74 }
75 })
76 .doOnNext(new Consumer<Long>() {
77 @Override
78 public void accept(Long l) {
79 nextCount.incrementAndGet();
80 }
81 })
82 .publish().refCount();
83
84 final AtomicInteger receivedCount = new AtomicInteger();
85 Disposable d1 = r.subscribe(new Consumer<Long>() {
86 @Override
87 public void accept(Long l) {
88 receivedCount.incrementAndGet();
89 }
90 });
91
92 Disposable d2 = r.subscribe();
93
94 // give time to emit
95 try {
96 Thread.sleep(260);
97 } catch (InterruptedException e) {
98 }
99
100 // now unsubscribe
101 d2.dispose(); // unsubscribe s2 first as we're counting in 1 and there can be a race between unsubscribe and one Observer getting a value but not the other
102 d1.dispose();
103
104 System.out.println("onNext: " + nextCount.get());
105
106 // should emit once for both subscribers
107 assertEquals(nextCount.get(), receivedCount.get());
108 // only 1 subscribe
109 assertEquals(1, subscribeCount.get());
110 }
111
112 @Test
113 public void refCountSynchronous() {
114 final AtomicInteger subscribeCount = new AtomicInteger();
115 final AtomicInteger nextCount = new AtomicInteger();
116 Observable<Integer> r = Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9)
117 .doOnSubscribe(new Consumer<Disposable>() {
118 @Override
119 public void accept(Disposable d) {
120 subscribeCount.incrementAndGet();
121 }
122 })
123 .doOnNext(new Consumer<Integer>() {
124 @Override
125 public void accept(Integer l) {
126 nextCount.incrementAndGet();
127 }
128 })
129 .publish().refCount();
130
131 final AtomicInteger receivedCount = new AtomicInteger();
132 Disposable d1 = r.subscribe(new Consumer<Integer>() {
133 @Override
134 public void accept(Integer l) {
135 receivedCount.incrementAndGet();
136 }
137 });
138
139 Disposable d2 = r.subscribe();
140
141 // give time to emit
142 try {
143 Thread.sleep(50);
144 } catch (InterruptedException e) {
145 }
146
147 // now unsubscribe
148 d2.dispose(); // unsubscribe s2 first as we're counting in 1 and there can be a race between unsubscribe and one Observer getting a value but not the other
149 d1.dispose();
150
151 System.out.println("onNext Count: " + nextCount.get());
152
153 // it will emit twice because it is synchronous
154 assertEquals(nextCount.get(), receivedCount.get() * 2);
155 // it will subscribe twice because it is synchronous
156 assertEquals(2, subscribeCount.get());
157 }
158
159 @Test
160 public void refCountSynchronousTake() {
161 final AtomicInteger nextCount = new AtomicInteger();
162 Observable<Integer> r = Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9)
163 .doOnNext(new Consumer<Integer>() {
164 @Override
165 public void accept(Integer l) {
166 System.out.println("onNext --------> " + l);
167 nextCount.incrementAndGet();
168 }
169 })
170 .take(4)
171 .publish().refCount();
172
173 final AtomicInteger receivedCount = new AtomicInteger();
174 r.subscribe(new Consumer<Integer>() {
175 @Override
176 public void accept(Integer l) {
177 receivedCount.incrementAndGet();
178 }
179 });
180
181 System.out.println("onNext: " + nextCount.get());
182
183 assertEquals(4, receivedCount.get());
184 assertEquals(4, receivedCount.get());
185 }
186
187 @Test
188 public void repeat() {
189 final AtomicInteger subscribeCount = new AtomicInteger();
190 final AtomicInteger unsubscribeCount = new AtomicInteger();
191 Observable<Long> r = Observable.interval(0, 1, TimeUnit.MILLISECONDS)
192 .doOnSubscribe(new Consumer<Disposable>() {
193 @Override
194 public void accept(Disposable d) {
195 System.out.println("******************************* Subscribe received");
196 // when we are subscribed
197 subscribeCount.incrementAndGet();
198 }
199 })
200 .doOnDispose(new Action() {
201 @Override
202 public void run() {
203 System.out.println("******************************* Unsubscribe received");
204 // when we are unsubscribed
205 unsubscribeCount.incrementAndGet();
206 }
207 })
208 .publish().refCount();
209
210 for (int i = 0; i < 10; i++) {
211 TestObserver<Long> to1 = new TestObserver<>();
212 TestObserver<Long> to2 = new TestObserver<>();
213 r.subscribe(to1);
214 r.subscribe(to2);
215 try {
216 Thread.sleep(50);
217 } catch (InterruptedException e) {
218 }
219 to1.dispose();
220 to2.dispose();
221 to1.assertNoErrors();
222 to2.assertNoErrors();
223 assertTrue(to1.values().size() > 0);
224 assertTrue(to2.values().size() > 0);
225 }
226
227 assertEquals(10, subscribeCount.get());
228 assertEquals(10, unsubscribeCount.get());
229 }
230
231 @Test
232 public void connectUnsubscribe() throws InterruptedException {
233 final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
234 final CountDownLatch subscribeLatch = new CountDownLatch(1);
235
236 Observable<Long> o = synchronousInterval()
237 .doOnSubscribe(new Consumer<Disposable>() {
238 @Override
239 public void accept(Disposable d) {
240 System.out.println("******************************* Subscribe received");
241 // when we are subscribed
242 subscribeLatch.countDown();
243 }
244 })
245 .doOnDispose(new Action() {
246 @Override
247 public void run() {
248 System.out.println("******************************* Unsubscribe received");
249 // when we are unsubscribed
250 unsubscribeLatch.countDown();
251 }
252 });
253
254 TestObserverEx<Long> observer = new TestObserverEx<>();
255 o.publish().refCount().subscribeOn(Schedulers.newThread()).subscribe(observer);
256 System.out.println("send unsubscribe");
257 // wait until connected
258 subscribeLatch.await();
259 // now unsubscribe
260 observer.dispose();
261 System.out.println("DONE sending unsubscribe ... now waiting");
262 if (!unsubscribeLatch.await(3000, TimeUnit.MILLISECONDS)) {
263 System.out.println("Errors: " + observer.errors());
264 if (observer.errors().size() > 0) {
265 observer.errors().get(0).printStackTrace();
266 }
267 fail("timed out waiting for unsubscribe");
268 }
269 observer.assertNoErrors();
270 }
271
272 @Test
273 public void connectUnsubscribeRaceConditionLoop() throws InterruptedException {
274 for (int i = 0; i < 100; i++) {
275 connectUnsubscribeRaceCondition();
276 }
277 }
278
279 @Test
280 public void connectUnsubscribeRaceCondition() throws InterruptedException {
281 final AtomicInteger subUnsubCount = new AtomicInteger();
282 Observable<Long> o = synchronousInterval()
283 .doOnDispose(new Action() {
284 @Override
285 public void run() {
286 System.out.println("******************************* Unsubscribe received");
287 // when we are unsubscribed
288 subUnsubCount.decrementAndGet();
289 }
290 })
291 .doOnSubscribe(new Consumer<Disposable>() {
292 @Override
293 public void accept(Disposable d) {
294 System.out.println("******************************* SUBSCRIBE received");
295 subUnsubCount.incrementAndGet();
296 }
297 });
298
299 TestObserverEx<Long> observer = new TestObserverEx<>();
300
301 o.publish().refCount().subscribeOn(Schedulers.computation()).subscribe(observer);
302 System.out.println("send unsubscribe");
303 // now immediately unsubscribe while subscribeOn is racing to subscribe
304 observer.dispose();
305
306 // this generally will mean it won't even subscribe as it is already unsubscribed by the time connect() gets scheduled
307 // give time to the counter to update
308 Thread.sleep(10);
309
310 // make sure we wait a bit in case the counter is still nonzero
311 int counter = 200;
312 while (subUnsubCount.get() != 0 && counter-- != 0) {
313 Thread.sleep(10);
314 }
315 // either we subscribed and then unsubscribed, or we didn't ever even subscribe
316 assertEquals(0, subUnsubCount.get());
317
318 System.out.println("DONE sending unsubscribe ... now waiting");
319 System.out.println("Errors: " + observer.errors());
320 if (observer.errors().size() > 0) {
321 observer.errors().get(0).printStackTrace();
322 }
323 observer.assertNoErrors();
324 }
325
326 private Observable<Long> synchronousInterval() {
327 return Observable.unsafeCreate(new ObservableSource<Long>() {
328 @Override
329 public void subscribe(Observer<? super Long> observer) {
330 final AtomicBoolean cancel = new AtomicBoolean();
331 observer.onSubscribe(Disposable.fromRunnable(new Runnable() {
332 @Override
333 public void run() {
334 cancel.set(true);
335 }
336 }));
337 for (;;) {
338 if (cancel.get()) {
339 break;
340 }
341 try {
342 Thread.sleep(100);
343 } catch (InterruptedException e) {
344 }
345 observer.onNext(1L);
346 }
347 }
348 });
349 }
350
351 @Test
352 public void onlyFirstShouldSubscribeAndLastUnsubscribe() {
353 final AtomicInteger subscriptionCount = new AtomicInteger();
354 final AtomicInteger unsubscriptionCount = new AtomicInteger();
355 Observable<Integer> o = Observable.unsafeCreate(new ObservableSource<Integer>() {
356 @Override
357 public void subscribe(Observer<? super Integer> observer) {
358 subscriptionCount.incrementAndGet();
359 observer.onSubscribe(Disposable.fromRunnable(new Runnable() {
360 @Override
361 public void run() {
362 unsubscriptionCount.incrementAndGet();
363 }
364 }));
365 }
366 });
367 Observable<Integer> refCounted = o.publish().refCount();
368
369 Disposable first = refCounted.subscribe();
370 assertEquals(1, subscriptionCount.get());
371
372 Disposable second = refCounted.subscribe();
373 assertEquals(1, subscriptionCount.get());
374
375 first.dispose();
376 assertEquals(0, unsubscriptionCount.get());
377
378 second.dispose();
379 assertEquals(1, unsubscriptionCount.get());
380 }
381
382 @Test
383 public void refCount() {
384 TestScheduler s = new TestScheduler();
385 Observable<Long> interval = Observable.interval(100, TimeUnit.MILLISECONDS, s).publish().refCount();
386
387 // subscribe list1
388 final List<Long> list1 = new ArrayList<>();
389 Disposable d1 = interval.subscribe(new Consumer<Long>() {
390 @Override
391 public void accept(Long t1) {
392 list1.add(t1);
393 }
394 });
395
396 s.advanceTimeBy(200, TimeUnit.MILLISECONDS);
397
398 assertEquals(2, list1.size());
399 assertEquals(0L, list1.get(0).longValue());
400 assertEquals(1L, list1.get(1).longValue());
401
402 // subscribe list2
403 final List<Long> list2 = new ArrayList<>();
404 Disposable d2 = interval.subscribe(new Consumer<Long>() {
405 @Override
406 public void accept(Long t1) {
407 list2.add(t1);
408 }
409 });
410
411 s.advanceTimeBy(300, TimeUnit.MILLISECONDS);
412
413 // list 1 should have 5 items
414 assertEquals(5, list1.size());
415 assertEquals(2L, list1.get(2).longValue());
416 assertEquals(3L, list1.get(3).longValue());
417 assertEquals(4L, list1.get(4).longValue());
418
419 // list 2 should only have 3 items
420 assertEquals(3, list2.size());
421 assertEquals(2L, list2.get(0).longValue());
422 assertEquals(3L, list2.get(1).longValue());
423 assertEquals(4L, list2.get(2).longValue());
424
425 // unsubscribe list1
426 d1.dispose();
427
428 // advance further
429 s.advanceTimeBy(300, TimeUnit.MILLISECONDS);
430
431 // list 1 should still have 5 items
432 assertEquals(5, list1.size());
433
434 // list 2 should have 6 items
435 assertEquals(6, list2.size());
436 assertEquals(5L, list2.get(3).longValue());
437 assertEquals(6L, list2.get(4).longValue());
438 assertEquals(7L, list2.get(5).longValue());
439
440 // unsubscribe list2
441 d2.dispose();
442
443 // advance further
444 s.advanceTimeBy(1000, TimeUnit.MILLISECONDS);
445
446 // subscribing a new one should start over because the source should have been unsubscribed
447 // subscribe list3
448 final List<Long> list3 = new ArrayList<>();
449 interval.subscribe(new Consumer<Long>() {
450 @Override
451 public void accept(Long t1) {
452 list3.add(t1);
453 }
454 });
455
456 s.advanceTimeBy(200, TimeUnit.MILLISECONDS);
457
458 assertEquals(2, list3.size());
459 assertEquals(0L, list3.get(0).longValue());
460 assertEquals(1L, list3.get(1).longValue());
461
462 }
463
464 @Test
465 public void alreadyUnsubscribedClient() {
466 Observer<Integer> done = DisposingObserver.INSTANCE;
467
468 Observer<Integer> o = TestHelper.mockObserver();
469
470 Observable<Integer> result = Observable.just(1).publish().refCount();
471
472 result.subscribe(done);
473
474 result.subscribe(o);
475
476 verify(o).onNext(1);
477 verify(o).onComplete();
478 verify(o, never()).onError(any(Throwable.class));
479 }
480
481 @Test
482 public void alreadyUnsubscribedInterleavesWithClient() {
483 ReplaySubject<Integer> source = ReplaySubject.create();
484
485 Observer<Integer> done = DisposingObserver.INSTANCE;
486
487 Observer<Integer> o = TestHelper.mockObserver();
488 InOrder inOrder = inOrder(o);
489
490 Observable<Integer> result = source.publish().refCount();
491
492 result.subscribe(o);
493
494 source.onNext(1);
495
496 result.subscribe(done);
497
498 source.onNext(2);
499 source.onComplete();
500
501 inOrder.verify(o).onNext(1);
502 inOrder.verify(o).onNext(2);
503 inOrder.verify(o).onComplete();
504 verify(o, never()).onError(any(Throwable.class));
505 }
506
507 @Test
508 public void connectDisconnectConnectAndSubjectState() {
509 Observable<Integer> o1 = Observable.just(10);
510 Observable<Integer> o2 = Observable.just(20);
511 Observable<Integer> combined = Observable.combineLatest(o1, o2, new BiFunction<Integer, Integer, Integer>() {
512 @Override
513 public Integer apply(Integer t1, Integer t2) {
514 return t1 + t2;
515 }
516 })
517 .publish().refCount();
518
519 TestObserverEx<Integer> to1 = new TestObserverEx<>();
520 TestObserverEx<Integer> to2 = new TestObserverEx<>();
521
522 combined.subscribe(to1);
523 combined.subscribe(to2);
524
525 to1.assertTerminated();
526 to1.assertNoErrors();
527 to1.assertValue(30);
528
529 to2.assertTerminated();
530 to2.assertNoErrors();
531 to2.assertValue(30);
532 }
533
534 @Test
535 public void upstreamErrorAllowsRetry() throws InterruptedException {
536 final AtomicInteger intervalSubscribed = new AtomicInteger();
537 Observable<String> interval =
538 Observable.interval(200, TimeUnit.MILLISECONDS)
539 .doOnSubscribe(new Consumer<Disposable>() {
540 @Override
541 public void accept(Disposable d) {
542 System.out.println("Subscribing to interval " + intervalSubscribed.incrementAndGet());
543 }
544 }
545 )
546 .flatMap(new Function<Long, Observable<String>>() {
547 @Override
548 public Observable<String> apply(Long t1) {
549 return Observable.defer(new Supplier<Observable<String>>() {
550 @Override
551 public Observable<String> get() {
552 return Observable.<String>error(new Exception("Some exception"));
553 }
554 });
555 }
556 })
557 .onErrorResumeNext(new Function<Throwable, Observable<String>>() {
558 @Override
559 public Observable<String> apply(Throwable t1) {
560 return Observable.<String>error(t1);
561 }
562 })
563 .publish()
564 .refCount();
565
566 interval
567 .doOnError(new Consumer<Throwable>() {
568 @Override
569 public void accept(Throwable t1) {
570 System.out.println("Observer 1 onError: " + t1);
571 }
572 })
573 .retry(5)
574 .subscribe(new Consumer<String>() {
575 @Override
576 public void accept(String t1) {
577 System.out.println("Observer 1: " + t1);
578 }
579 });
580 Thread.sleep(100);
581 interval
582 .doOnError(new Consumer<Throwable>() {
583 @Override
584 public void accept(Throwable t1) {
585 System.out.println("Observer 2 onError: " + t1);
586 }
587 })
588 .retry(5)
589 .subscribe(new Consumer<String>() {
590 @Override
591 public void accept(String t1) {
592 System.out.println("Observer 2: " + t1);
593 }
594 });
595
596 Thread.sleep(1300);
597
598 System.out.println(intervalSubscribed.get());
599 assertEquals(6, intervalSubscribed.get());
600 }
601
602 private enum DisposingObserver implements Observer<Integer> {
603 INSTANCE;
604
605 @Override
606 public void onSubscribe(Disposable d) {
607 d.dispose();
608 }
609
610 @Override
611 public void onNext(Integer t) {
612 }
613
614 @Override
615 public void onError(Throwable t) {
616 }
617
618 @Override
619 public void onComplete() {
620 }
621 }
622
623 @Test
624 public void disposed() {
625 TestHelper.checkDisposed(Observable.just(1).publish().refCount());
626 }
627
628 @Test
629 public void noOpConnect() {
630 final int[] calls = { 0 };
631 Observable<Integer> o = new ConnectableObservable<Integer>() {
632 @Override
633 public void connect(Consumer<? super Disposable> connection) {
634 calls[0]++;
635 }
636
637 @Override
638 public void reset() {
639 // nothing to do in this test
640 }
641
642 @Override
643 protected void subscribeActual(Observer<? super Integer> observer) {
644 observer.onSubscribe(Disposable.disposed());
645 }
646 }.refCount();
647
648 o.test();
649 o.test();
650
651 assertEquals(1, calls[0]);
652 }
653 Observable<Object> source;
654
655 @Test
656 public void replayNoLeak() throws Exception {
657 System.gc();
658 Thread.sleep(100);
659
660 long start = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
661
662 source = Observable.fromCallable(new Callable<Object>() {
663 @Override
664 public Object call() throws Exception {
665 return new byte[100 * 1000 * 1000];
666 }
667 })
668 .replay(1)
669 .refCount();
670
671 source.subscribe();
672
673 long after = TestHelper.awaitGC(GC_SLEEP_TIME, 20, start + 20 * 1000 * 1000);
674
675 source = null;
676 assertTrue(String.format("%,3d -> %,3d%n", start, after), start + 20 * 1000 * 1000 > after);
677 }
678
679 @Test
680 public void replayNoLeak2() throws Exception {
681 System.gc();
682 Thread.sleep(100);
683
684 long start = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
685
686 source = Observable.fromCallable(new Callable<Object>() {
687 @Override
688 public Object call() throws Exception {
689 return new byte[100 * 1000 * 1000];
690 }
691 }).concatWith(Observable.never())
692 .replay(1)
693 .refCount();
694
695 Disposable d1 = source.subscribe();
696 Disposable d2 = source.subscribe();
697
698 d1.dispose();
699 d2.dispose();
700
701 d1 = null;
702 d2 = null;
703
704 long after = TestHelper.awaitGC(GC_SLEEP_TIME, 20, start + 20 * 1000 * 1000);
705
706 source = null;
707 assertTrue(String.format("%,3d -> %,3d%n", start, after), start + 20 * 1000 * 1000 > after);
708 }
709
710 static final class ExceptionData extends Exception {
711 private static final long serialVersionUID = -6763898015338136119L;
712
713 public final Object data;
714
715 ExceptionData(Object data) {
716 this.data = data;
717 }
718 }
719
720 static final int GC_SLEEP_TIME = 250;
721
722 @Test
723 public void publishNoLeak() throws Exception {
724 System.gc();
725 Thread.sleep(GC_SLEEP_TIME);
726
727 source = Observable.fromCallable(new Callable<Object>() {
728 @Override
729 public Object call() throws Exception {
730 throw new ExceptionData(new byte[100 * 1000 * 1000]);
731 }
732 })
733 .publish()
734 .refCount();
735
736 long start = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
737
738 source.subscribe(Functions.emptyConsumer(), Functions.emptyConsumer());
739
740 long after = TestHelper.awaitGC(GC_SLEEP_TIME, 20, start + 20 * 1000 * 1000);
741
742 source = null;
743 assertTrue(String.format("%,3d -> %,3d%n", start, after), start + 20 * 1000 * 1000 > after);
744 }
745
746 @Test
747 public void publishNoLeak2() throws Exception {
748 System.gc();
749 Thread.sleep(GC_SLEEP_TIME);
750
751 long start = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
752
753 source = Observable.fromCallable(new Callable<Object>() {
754 @Override
755 public Object call() throws Exception {
756 return new byte[100 * 1000 * 1000];
757 }
758 }).concatWith(Observable.never())
759 .publish()
760 .refCount();
761
762 Disposable d1 = source.test();
763 Disposable d2 = source.test();
764
765 d1.dispose();
766 d2.dispose();
767
768 d1 = null;
769 d2 = null;
770
771 long after = TestHelper.awaitGC(GC_SLEEP_TIME, 20, start + 20 * 1000 * 1000);
772
773 source = null;
774 assertTrue(String.format("%,3d -> %,3d%n", start, after), start + 20 * 1000 * 1000 > after);
775 }
776
777 @Test
778 public void replayIsUnsubscribed() {
779 ConnectableObservable<Integer> co = Observable.just(1).concatWith(Observable.<Integer>never())
780 .replay();
781
782 if (co instanceof Disposable) {
783 assertTrue(((Disposable)co).isDisposed());
784
785 Disposable connection = co.connect();
786
787 assertFalse(((Disposable)co).isDisposed());
788
789 connection.dispose();
790
791 assertTrue(((Disposable)co).isDisposed());
792 }
793 }
794
795 static final class BadObservableSubscribe extends ConnectableObservable<Object> {
796
797 @Override
798 public void connect(Consumer<? super Disposable> connection) {
799 try {
800 connection.accept(Disposable.empty());
801 } catch (Throwable ex) {
802 throw ExceptionHelper.wrapOrThrow(ex);
803 }
804 }
805
806 @Override
807 public void reset() {
808 // nothing to do in this test
809 }
810
811 @Override
812 protected void subscribeActual(Observer<? super Object> observer) {
813 throw new TestException("subscribeActual");
814 }
815 }
816
817 static final class BadObservableDispose extends ConnectableObservable<Object> {
818
819 @Override
820 public void reset() {
821 throw new TestException("dispose");
822 }
823
824 @Override
825 public void connect(Consumer<? super Disposable> connection) {
826 try {
827 connection.accept(Disposable.empty());
828 } catch (Throwable ex) {
829 throw ExceptionHelper.wrapOrThrow(ex);
830 }
831 }
832
833 @Override
834 protected void subscribeActual(Observer<? super Object> observer) {
835 observer.onSubscribe(Disposable.empty());
836 }
837 }
838
839 static final class BadObservableConnect extends ConnectableObservable<Object> {
840
841 @Override
842 public void connect(Consumer<? super Disposable> connection) {
843 throw new TestException("connect");
844 }
845
846 @Override
847 public void reset() {
848 // nothing to do in this test
849 }
850
851 @Override
852 protected void subscribeActual(Observer<? super Object> observer) {
853 observer.onSubscribe(Disposable.empty());
854 }
855 }
856
857 @Test
858 @SuppressUndeliverable
859 public void badSourceSubscribe() {
860 BadObservableSubscribe bo = new BadObservableSubscribe();
861
862 try {
863 bo.refCount()
864 .test();
865 fail("Should have thrown");
866 } catch (NullPointerException ex) {
867 assertTrue(ex.getCause() instanceof TestException);
868 }
869 }
870
871 @Test
872 public void badSourceDispose() {
873 BadObservableDispose bo = new BadObservableDispose();
874
875 try {
876 bo.refCount()
877 .test()
878 .dispose();
879 fail("Should have thrown");
880 } catch (TestException expected) {
881 }
882 }
883
884 @Test
885 @SuppressUndeliverable
886 public void badSourceConnect() {
887 BadObservableConnect bo = new BadObservableConnect();
888
889 try {
890 bo.refCount()
891 .test();
892 fail("Should have thrown");
893 } catch (NullPointerException ex) {
894 assertTrue(ex.getCause() instanceof TestException);
895 }
896 }
897
898 static final class BadObservableSubscribe2 extends ConnectableObservable<Object> {
899
900 int count;
901
902 @Override
903 public void connect(Consumer<? super Disposable> connection) {
904 try {
905 connection.accept(Disposable.empty());
906 } catch (Throwable ex) {
907 throw ExceptionHelper.wrapOrThrow(ex);
908 }
909 }
910
911 @Override
912 public void reset() {
913 // nothing to do in this test
914 }
915
916 @Override
917 protected void subscribeActual(Observer<? super Object> observer) {
918 if (++count == 1) {
919 observer.onSubscribe(Disposable.empty());
920 } else {
921 throw new TestException("subscribeActual");
922 }
923 }
924 }
925
926 @Test
927 @SuppressUndeliverable
928 public void badSourceSubscribe2() {
929 BadObservableSubscribe2 bo = new BadObservableSubscribe2();
930
931 Observable<Object> o = bo.refCount();
932 o.test();
933 try {
934 o.test();
935 fail("Should have thrown");
936 } catch (NullPointerException ex) {
937 assertTrue(ex.getCause() instanceof TestException);
938 }
939 }
940
941 static final class BadObservableConnect2 extends ConnectableObservable<Object> {
942
943 @Override
944 public void connect(Consumer<? super Disposable> connection) {
945 try {
946 connection.accept(Disposable.empty());
947 } catch (Throwable ex) {
948 throw ExceptionHelper.wrapOrThrow(ex);
949 }
950 }
951
952 @Override
953 public void reset() {
954 throw new TestException("dispose");
955 }
956
957 @Override
958 protected void subscribeActual(Observer<? super Object> observer) {
959 observer.onSubscribe(Disposable.empty());
960 observer.onComplete();
961 }
962 }
963
964 @Test
965 @SuppressUndeliverable
966 public void badSourceCompleteDisconnect() {
967 BadObservableConnect2 bo = new BadObservableConnect2();
968
969 try {
970 bo.refCount()
971 .test();
972 fail("Should have thrown");
973 } catch (NullPointerException ex) {
974 assertTrue(ex.getCause() instanceof TestException);
975 }
976 }
977
978 @Test
979 public void blockingSourceAsnycCancel() throws Exception {
980 BehaviorSubject<Integer> bs = BehaviorSubject.createDefault(1);
981
982 Observable<Integer> o = bs
983 .replay(1)
984 .refCount();
985
986 o.subscribe();
987
988 final AtomicBoolean interrupted = new AtomicBoolean();
989
990 o.switchMap(new Function<Integer, ObservableSource<? extends Object>>() {
991 @Override
992 public ObservableSource<? extends Object> apply(Integer v) throws Exception {
993 return Observable.create(new ObservableOnSubscribe<Object>() {
994 @Override
995 public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
996 while (!emitter.isDisposed()) {
997 Thread.sleep(100);
998 }
999 interrupted.set(true);
1000 }
1001 });
1002 }
1003 })
1004 .take(500, TimeUnit.MILLISECONDS)
1005 .test()
1006 .awaitDone(5, TimeUnit.SECONDS)
1007 .assertResult();
1008
1009 assertTrue(interrupted.get());
1010 }
1011
1012 @Test
1013 public void byCount() {
1014 final int[] subscriptions = { 0 };
1015
1016 Observable<Integer> source = Observable.range(1, 5)
1017 .doOnSubscribe(new Consumer<Disposable>() {
1018 @Override
1019 public void accept(Disposable d) throws Exception {
1020 subscriptions[0]++;
1021 }
1022 })
1023 .publish()
1024 .refCount(2);
1025
1026 for (int i = 0; i < 3; i++) {
1027 TestObserver<Integer> to1 = source.test();
1028
1029 to1.withTag("to1 " + i);
1030 to1.assertEmpty();
1031
1032 TestObserver<Integer> to2 = source.test();
1033
1034 to2.withTag("to2 " + i);
1035
1036 to1.assertResult(1, 2, 3, 4, 5);
1037 to2.assertResult(1, 2, 3, 4, 5);
1038 }
1039
1040 assertEquals(3, subscriptions[0]);
1041 }
1042
1043 @Test
1044 public void resubscribeBeforeTimeout() throws Exception {
1045 final int[] subscriptions = { 0 };
1046
1047 PublishSubject<Integer> ps = PublishSubject.create();
1048
1049 Observable<Integer> source = ps
1050 .doOnSubscribe(new Consumer<Disposable>() {
1051 @Override
1052 public void accept(Disposable d) throws Exception {
1053 subscriptions[0]++;
1054 }
1055 })
1056 .publish()
1057 .refCount(500, TimeUnit.MILLISECONDS);
1058
1059 TestObserver<Integer> to1 = source.test();
1060
1061 assertEquals(1, subscriptions[0]);
1062
1063 to1.dispose();
1064
1065 Thread.sleep(100);
1066
1067 to1 = source.test();
1068
1069 assertEquals(1, subscriptions[0]);
1070
1071 Thread.sleep(500);
1072
1073 assertEquals(1, subscriptions[0]);
1074
1075 ps.onNext(1);
1076 ps.onNext(2);
1077 ps.onNext(3);
1078 ps.onNext(4);
1079 ps.onNext(5);
1080 ps.onComplete();
1081
1082 to1
1083 .assertResult(1, 2, 3, 4, 5);
1084 }
1085
1086 @Test
1087 public void letitTimeout() throws Exception {
1088 final int[] subscriptions = { 0 };
1089
1090 PublishSubject<Integer> ps = PublishSubject.create();
1091
1092 Observable<Integer> source = ps
1093 .doOnSubscribe(new Consumer<Disposable>() {
1094 @Override
1095 public void accept(Disposable d) throws Exception {
1096 subscriptions[0]++;
1097 }
1098 })
1099 .publish()
1100 .refCount(1, 100, TimeUnit.MILLISECONDS);
1101
1102 TestObserver<Integer> to1 = source.test();
1103
1104 assertEquals(1, subscriptions[0]);
1105
1106 to1.dispose();
1107
1108 assertTrue(ps.hasObservers());
1109
1110 Thread.sleep(200);
1111
1112 assertFalse(ps.hasObservers());
1113 }
1114
1115 @Test
1116 public void error() {
1117 Observable.<Integer>error(new IOException())
1118 .publish()
1119 .refCount(500, TimeUnit.MILLISECONDS)
1120 .test()
1121 .assertFailure(IOException.class);
1122 }
1123
1124 @Test
1125 public void comeAndGo() {
1126 PublishSubject<Integer> ps = PublishSubject.create();
1127
1128 Observable<Integer> source = ps
1129 .publish()
1130 .refCount(1);
1131
1132 TestObserver<Integer> to1 = source.test();
1133
1134 assertTrue(ps.hasObservers());
1135
1136 for (int i = 0; i < 3; i++) {
1137 TestObserver<Integer> to2 = source.test();
1138 to1.dispose();
1139 to1 = to2;
1140 }
1141
1142 to1.dispose();
1143
1144 assertFalse(ps.hasObservers());
1145 }
1146
1147 @Test
1148 public void unsubscribeSubscribeRace() {
1149 for (int i = 0; i < 1000; i++) {
1150
1151 final Observable<Integer> source = Observable.range(1, 5)
1152 .replay()
1153 .refCount(1)
1154 ;
1155
1156 final TestObserver<Integer> to1 = source.test();
1157
1158 final TestObserver<Integer> to2 = new TestObserver<>();
1159
1160 Runnable r1 = new Runnable() {
1161 @Override
1162 public void run() {
1163 to1.dispose();
1164 }
1165 };
1166
1167 Runnable r2 = new Runnable() {
1168 @Override
1169 public void run() {
1170 source.subscribe(to2);
1171 }
1172 };
1173
1174 TestHelper.race(r1, r2, Schedulers.single());
1175
1176 to2
1177 .withTag("Round: " + i)
1178 .assertResult(1, 2, 3, 4, 5);
1179 }
1180 }
1181
1182 static final class BadObservableDoubleOnX extends ConnectableObservable<Object>
1183 implements Disposable {
1184
1185 @Override
1186 public void connect(Consumer<? super Disposable> connection) {
1187 try {
1188 connection.accept(Disposable.empty());
1189 } catch (Throwable ex) {
1190 throw ExceptionHelper.wrapOrThrow(ex);
1191 }
1192 }
1193
1194 @Override
1195 public void reset() {
1196 // nothing to do in this test
1197 }
1198
1199 @Override
1200 protected void subscribeActual(Observer<? super Object> observer) {
1201 observer.onSubscribe(Disposable.empty());
1202 observer.onSubscribe(Disposable.empty());
1203 observer.onComplete();
1204 observer.onComplete();
1205 observer.onError(new TestException());
1206 }
1207
1208 @Override
1209 public void dispose() {
1210 }
1211
1212 @Override
1213 public boolean isDisposed() {
1214 return false;
1215 }
1216 }
1217
1218 @Test
1219 public void doubleOnX() {
1220 List<Throwable> errors = TestHelper.trackPluginErrors();
1221 try {
1222 new BadObservableDoubleOnX()
1223 .refCount()
1224 .test()
1225 .assertResult();
1226
1227 TestHelper.assertError(errors, 0, ProtocolViolationException.class);
1228 TestHelper.assertUndeliverable(errors, 1, TestException.class);
1229 } finally {
1230 RxJavaPlugins.reset();
1231 }
1232 }
1233
1234 @Test
1235 public void doubleOnXCount() {
1236 List<Throwable> errors = TestHelper.trackPluginErrors();
1237 try {
1238 new BadObservableDoubleOnX()
1239 .refCount(1)
1240 .test()
1241 .assertResult();
1242
1243 TestHelper.assertError(errors, 0, ProtocolViolationException.class);
1244 TestHelper.assertUndeliverable(errors, 1, TestException.class);
1245 } finally {
1246 RxJavaPlugins.reset();
1247 }
1248 }
1249
1250 @Test
1251 public void doubleOnXTime() {
1252 List<Throwable> errors = TestHelper.trackPluginErrors();
1253 try {
1254 new BadObservableDoubleOnX()
1255 .refCount(5, TimeUnit.SECONDS, Schedulers.single())
1256 .test()
1257 .assertResult();
1258
1259 TestHelper.assertError(errors, 0, ProtocolViolationException.class);
1260 TestHelper.assertUndeliverable(errors, 1, TestException.class);
1261 } finally {
1262 RxJavaPlugins.reset();
1263 }
1264 }
1265
1266 @Test
1267 public void cancelTerminateStateExclusion() {
1268 ObservableRefCount<Object> o = (ObservableRefCount<Object>)PublishSubject.create()
1269 .publish()
1270 .refCount();
1271
1272 o.cancel(new RefConnection(o));
1273
1274 RefConnection rc = new RefConnection(o);
1275 o.connection = null;
1276 rc.subscriberCount = 0;
1277 o.timeout(rc);
1278
1279 rc.subscriberCount = 1;
1280 o.timeout(rc);
1281
1282 o.connection = rc;
1283 o.timeout(rc);
1284
1285 rc.subscriberCount = 0;
1286 o.timeout(rc);
1287
1288 // -------------------
1289
1290 rc.subscriberCount = 2;
1291 rc.connected = false;
1292 o.connection = rc;
1293 o.cancel(rc);
1294
1295 rc.subscriberCount = 1;
1296 rc.connected = false;
1297 o.connection = rc;
1298 o.cancel(rc);
1299
1300 rc.subscriberCount = 2;
1301 rc.connected = true;
1302 o.connection = rc;
1303 o.cancel(rc);
1304
1305 rc.subscriberCount = 1;
1306 rc.connected = true;
1307 o.connection = rc;
1308 rc.lazySet(null);
1309 o.cancel(rc);
1310
1311 o.connection = rc;
1312 o.cancel(new RefConnection(o));
1313 }
1314
1315 @Test
1316 public void replayRefCountShallBeThreadSafe() {
1317 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
1318 Observable<Integer> observable = Observable.just(1).replay(1).refCount();
1319
1320 TestObserver<Integer> observer1 = observable
1321 .subscribeOn(Schedulers.io())
1322 .test();
1323
1324 TestObserver<Integer> observer2 = observable
1325 .subscribeOn(Schedulers.io())
1326 .test();
1327
1328 observer1
1329 .withTag("" + i)
1330 .awaitDone(5, TimeUnit.SECONDS)
1331 .assertResult(1);
1332
1333 observer2
1334 .withTag("" + i)
1335 .awaitDone(5, TimeUnit.SECONDS)
1336 .assertResult(1);
1337 }
1338 }
1339
1340 static final class TestConnectableObservable<T> extends ConnectableObservable<T> {
1341
1342 volatile boolean reset;
1343
1344 @Override
1345 public void reset() {
1346 reset = true;
1347 }
1348
1349 @Override
1350 public void connect(Consumer<? super Disposable> connection) {
1351 // not relevant
1352 }
1353
1354 @Override
1355 protected void subscribeActual(Observer<? super T> observer) {
1356 // not relevant
1357 }
1358 }
1359
1360 @Test
1361 public void timeoutResetsSource() {
1362 TestConnectableObservable<Object> tco = new TestConnectableObservable<>();
1363 ObservableRefCount<Object> o = (ObservableRefCount<Object>)tco.refCount();
1364
1365 RefConnection rc = new RefConnection(o);
1366 rc.set(Disposable.empty());
1367 o.connection = rc;
1368
1369 o.timeout(rc);
1370
1371 assertTrue(tco.reset);
1372 }
1373
1374 @Test
1375 public void disconnectBeforeConnect() {
1376 BehaviorSubject<Integer> subject = BehaviorSubject.create();
1377
1378 Observable<Integer> observable = subject
1379 .replay(1)
1380 .refCount();
1381
1382 observable.takeUntil(Observable.just(1)).test();
1383
1384 subject.onNext(2);
1385
1386 observable.take(1).test().assertResult(2);
1387 }
1388
1389 @Test
1390 public void publishRefCountShallBeThreadSafe() {
1391 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
1392 Observable<Integer> observable = Observable.just(1).publish().refCount();
1393
1394 TestObserver<Integer> observer1 = observable
1395 .subscribeOn(Schedulers.io())
1396 .test();
1397
1398 TestObserver<Integer> observer2 = observable
1399 .subscribeOn(Schedulers.io())
1400 .test();
1401
1402 observer1
1403 .withTag("observer1 " + i)
1404 .awaitDone(5, TimeUnit.SECONDS)
1405 .assertNoErrors()
1406 .assertComplete();
1407
1408 observer2
1409 .withTag("observer2 " + i)
1410 .awaitDone(5, TimeUnit.SECONDS)
1411 .assertNoErrors()
1412 .assertComplete();
1413 }
1414 }
1415
1416 @Test
1417 public void upstreamTerminationTriggersAnotherCancel() throws Exception {
1418 ReplaySubject<Integer> rs = ReplaySubject.create();
1419 rs.onNext(1);
1420 rs.onComplete();
1421
1422 Observable<Integer> shared = rs.share();
1423
1424 shared
1425 .buffer(shared.debounce(5, TimeUnit.SECONDS))
1426 .test()
1427 .assertValueCount(2);
1428
1429 shared
1430 .buffer(shared.debounce(5, TimeUnit.SECONDS))
1431 .test()
1432 .assertValueCount(2);
1433 }
1434 }