Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableReplayEagerTruncateTest.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.*;
18 import static org.mockito.Mockito.*;
19
20 import java.lang.management.*;
21 import java.util.*;
22 import java.util.concurrent.*;
23 import java.util.concurrent.atomic.*;
24
25 import org.junit.*;
26 import org.mockito.InOrder;
27
28 import io.reactivex.rxjava3.annotations.NonNull;
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.core.Scheduler.Worker;
33 import io.reactivex.rxjava3.disposables.Disposable;
34 import io.reactivex.rxjava3.exceptions.TestException;
35 import io.reactivex.rxjava3.functions.*;
36 import io.reactivex.rxjava3.internal.functions.Functions;
37 import io.reactivex.rxjava3.internal.fuseable.HasUpstreamObservableSource;
38 import io.reactivex.rxjava3.internal.operators.observable.ObservableReplay.*;
39 import io.reactivex.rxjava3.observables.ConnectableObservable;
40 import io.reactivex.rxjava3.observers.TestObserver;
41 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
42 import io.reactivex.rxjava3.schedulers.*;
43 import io.reactivex.rxjava3.subjects.PublishSubject;
44 import io.reactivex.rxjava3.testsupport.*;
45
46 public class ObservableReplayEagerTruncateTest extends RxJavaTest {
47 @Test
48 public void bufferedReplay() {
49 PublishSubject<Integer> source = PublishSubject.create();
50
51 ConnectableObservable<Integer> co = source.replay(3, true);
52 co.connect();
53
54 {
55 Observer<Object> observer1 = TestHelper.mockObserver();
56 InOrder inOrder = inOrder(observer1);
57
58 co.subscribe(observer1);
59
60 source.onNext(1);
61 source.onNext(2);
62 source.onNext(3);
63
64 inOrder.verify(observer1, times(1)).onNext(1);
65 inOrder.verify(observer1, times(1)).onNext(2);
66 inOrder.verify(observer1, times(1)).onNext(3);
67
68 source.onNext(4);
69 source.onComplete();
70 inOrder.verify(observer1, times(1)).onNext(4);
71 inOrder.verify(observer1, times(1)).onComplete();
72 inOrder.verifyNoMoreInteractions();
73 verify(observer1, never()).onError(any(Throwable.class));
74
75 }
76
77 {
78 Observer<Object> observer1 = TestHelper.mockObserver();
79 InOrder inOrder = inOrder(observer1);
80
81 co.subscribe(observer1);
82
83 inOrder.verify(observer1, times(1)).onNext(2);
84 inOrder.verify(observer1, times(1)).onNext(3);
85 inOrder.verify(observer1, times(1)).onNext(4);
86 inOrder.verify(observer1, times(1)).onComplete();
87 inOrder.verifyNoMoreInteractions();
88 verify(observer1, never()).onError(any(Throwable.class));
89 }
90 }
91
92 @Test
93 public void bufferedWindowReplay() {
94 PublishSubject<Integer> source = PublishSubject.create();
95 TestScheduler scheduler = new TestScheduler();
96 ConnectableObservable<Integer> co = source.replay(3, 100, TimeUnit.MILLISECONDS, scheduler, true);
97 co.connect();
98
99 {
100 Observer<Object> observer1 = TestHelper.mockObserver();
101 InOrder inOrder = inOrder(observer1);
102
103 co.subscribe(observer1);
104
105 source.onNext(1);
106 scheduler.advanceTimeBy(10, TimeUnit.MILLISECONDS);
107 source.onNext(2);
108 scheduler.advanceTimeBy(10, TimeUnit.MILLISECONDS);
109 source.onNext(3);
110 scheduler.advanceTimeBy(10, TimeUnit.MILLISECONDS);
111
112 inOrder.verify(observer1, times(1)).onNext(1);
113 inOrder.verify(observer1, times(1)).onNext(2);
114 inOrder.verify(observer1, times(1)).onNext(3);
115
116 source.onNext(4);
117 source.onNext(5);
118 scheduler.advanceTimeBy(90, TimeUnit.MILLISECONDS);
119
120 inOrder.verify(observer1, times(1)).onNext(4);
121
122 inOrder.verify(observer1, times(1)).onNext(5);
123
124 inOrder.verifyNoMoreInteractions();
125 verify(observer1, never()).onError(any(Throwable.class));
126
127 }
128
129 {
130 Observer<Object> observer1 = TestHelper.mockObserver();
131 InOrder inOrder = inOrder(observer1);
132
133 co.subscribe(observer1);
134
135 inOrder.verify(observer1, times(1)).onNext(4);
136 inOrder.verify(observer1, times(1)).onNext(5);
137 inOrder.verifyNoMoreInteractions();
138 verify(observer1, never()).onError(any(Throwable.class));
139 }
140 }
141
142 @Test
143 public void windowedReplay() {
144 TestScheduler scheduler = new TestScheduler();
145
146 PublishSubject<Integer> source = PublishSubject.create();
147
148 ConnectableObservable<Integer> co = source.replay(100, TimeUnit.MILLISECONDS, scheduler, true);
149 co.connect();
150
151 {
152 Observer<Object> observer1 = TestHelper.mockObserver();
153 InOrder inOrder = inOrder(observer1);
154
155 co.subscribe(observer1);
156
157 source.onNext(1);
158 scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS);
159 source.onNext(2);
160 scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS);
161 source.onNext(3);
162 scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS);
163 source.onComplete();
164 scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS);
165
166 inOrder.verify(observer1, times(1)).onNext(1);
167 inOrder.verify(observer1, times(1)).onNext(2);
168 inOrder.verify(observer1, times(1)).onNext(3);
169
170 inOrder.verify(observer1, times(1)).onComplete();
171 inOrder.verifyNoMoreInteractions();
172 verify(observer1, never()).onError(any(Throwable.class));
173
174 }
175 {
176 Observer<Object> observer1 = TestHelper.mockObserver();
177 InOrder inOrder = inOrder(observer1);
178
179 co.subscribe(observer1);
180 inOrder.verify(observer1, never()).onNext(3);
181
182 inOrder.verify(observer1, times(1)).onComplete();
183 inOrder.verifyNoMoreInteractions();
184 verify(observer1, never()).onError(any(Throwable.class));
185 }
186 }
187
188 @Test
189 public void replaySelector() {
190 final Function<Integer, Integer> dbl = new Function<Integer, Integer>() {
191
192 @Override
193 public Integer apply(Integer t1) {
194 return t1 * 2;
195 }
196
197 };
198
199 Function<Observable<Integer>, Observable<Integer>> selector = new Function<Observable<Integer>, Observable<Integer>>() {
200
201 @Override
202 public Observable<Integer> apply(Observable<Integer> t1) {
203 return t1.map(dbl);
204 }
205
206 };
207
208 PublishSubject<Integer> source = PublishSubject.create();
209
210 Observable<Integer> co = source.replay(selector);
211
212 {
213 Observer<Object> observer1 = TestHelper.mockObserver();
214 InOrder inOrder = inOrder(observer1);
215
216 co.subscribe(observer1);
217
218 source.onNext(1);
219 source.onNext(2);
220 source.onNext(3);
221
222 inOrder.verify(observer1, times(1)).onNext(2);
223 inOrder.verify(observer1, times(1)).onNext(4);
224 inOrder.verify(observer1, times(1)).onNext(6);
225
226 source.onNext(4);
227 source.onComplete();
228 inOrder.verify(observer1, times(1)).onNext(8);
229 inOrder.verify(observer1, times(1)).onComplete();
230 inOrder.verifyNoMoreInteractions();
231 verify(observer1, never()).onError(any(Throwable.class));
232
233 }
234
235 {
236 Observer<Object> observer1 = TestHelper.mockObserver();
237 InOrder inOrder = inOrder(observer1);
238
239 co.subscribe(observer1);
240
241 inOrder.verify(observer1, times(1)).onComplete();
242 inOrder.verifyNoMoreInteractions();
243 verify(observer1, never()).onError(any(Throwable.class));
244
245 }
246
247 }
248
249 @Test
250 public void bufferedReplaySelector() {
251
252 final Function<Integer, Integer> dbl = new Function<Integer, Integer>() {
253
254 @Override
255 public Integer apply(Integer t1) {
256 return t1 * 2;
257 }
258
259 };
260
261 Function<Observable<Integer>, Observable<Integer>> selector = new Function<Observable<Integer>, Observable<Integer>>() {
262
263 @Override
264 public Observable<Integer> apply(Observable<Integer> t1) {
265 return t1.map(dbl);
266 }
267
268 };
269
270 PublishSubject<Integer> source = PublishSubject.create();
271
272 Observable<Integer> co = source.replay(selector, 3);
273
274 {
275 Observer<Object> observer1 = TestHelper.mockObserver();
276 InOrder inOrder = inOrder(observer1);
277
278 co.subscribe(observer1);
279
280 source.onNext(1);
281 source.onNext(2);
282 source.onNext(3);
283
284 inOrder.verify(observer1, times(1)).onNext(2);
285 inOrder.verify(observer1, times(1)).onNext(4);
286 inOrder.verify(observer1, times(1)).onNext(6);
287
288 source.onNext(4);
289 source.onComplete();
290 inOrder.verify(observer1, times(1)).onNext(8);
291 inOrder.verify(observer1, times(1)).onComplete();
292 inOrder.verifyNoMoreInteractions();
293 verify(observer1, never()).onError(any(Throwable.class));
294
295 }
296
297 {
298 Observer<Object> observer1 = TestHelper.mockObserver();
299 InOrder inOrder = inOrder(observer1);
300
301 co.subscribe(observer1);
302
303 inOrder.verify(observer1, times(1)).onComplete();
304 inOrder.verifyNoMoreInteractions();
305 verify(observer1, never()).onError(any(Throwable.class));
306 }
307 }
308
309 @Test
310 public void windowedReplaySelector() {
311
312 final Function<Integer, Integer> dbl = new Function<Integer, Integer>() {
313
314 @Override
315 public Integer apply(Integer t1) {
316 return t1 * 2;
317 }
318
319 };
320
321 Function<Observable<Integer>, Observable<Integer>> selector = new Function<Observable<Integer>, Observable<Integer>>() {
322
323 @Override
324 public Observable<Integer> apply(Observable<Integer> t1) {
325 return t1.map(dbl);
326 }
327
328 };
329
330 TestScheduler scheduler = new TestScheduler();
331
332 PublishSubject<Integer> source = PublishSubject.create();
333
334 Observable<Integer> co = source.replay(selector, 100, TimeUnit.MILLISECONDS, scheduler);
335
336 {
337 Observer<Object> observer1 = TestHelper.mockObserver();
338 InOrder inOrder = inOrder(observer1);
339
340 co.subscribe(observer1);
341
342 source.onNext(1);
343 scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS);
344 source.onNext(2);
345 scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS);
346 source.onNext(3);
347 scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS);
348 source.onComplete();
349 scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS);
350
351 inOrder.verify(observer1, times(1)).onNext(2);
352 inOrder.verify(observer1, times(1)).onNext(4);
353 inOrder.verify(observer1, times(1)).onNext(6);
354
355 inOrder.verify(observer1, times(1)).onComplete();
356 inOrder.verifyNoMoreInteractions();
357 verify(observer1, never()).onError(any(Throwable.class));
358
359 }
360 {
361 Observer<Object> observer1 = TestHelper.mockObserver();
362 InOrder inOrder = inOrder(observer1);
363
364 co.subscribe(observer1);
365
366 inOrder.verify(observer1, times(1)).onComplete();
367 inOrder.verifyNoMoreInteractions();
368 verify(observer1, never()).onError(any(Throwable.class));
369 }
370 }
371
372 @Test
373 public void bufferedReplayError() {
374 PublishSubject<Integer> source = PublishSubject.create();
375
376 ConnectableObservable<Integer> co = source.replay(3, true);
377 co.connect();
378
379 {
380 Observer<Object> observer1 = TestHelper.mockObserver();
381 InOrder inOrder = inOrder(observer1);
382
383 co.subscribe(observer1);
384
385 source.onNext(1);
386 source.onNext(2);
387 source.onNext(3);
388
389 inOrder.verify(observer1, times(1)).onNext(1);
390 inOrder.verify(observer1, times(1)).onNext(2);
391 inOrder.verify(observer1, times(1)).onNext(3);
392
393 source.onNext(4);
394 source.onError(new RuntimeException("Forced failure"));
395
396 inOrder.verify(observer1, times(1)).onNext(4);
397 inOrder.verify(observer1, times(1)).onError(any(RuntimeException.class));
398 inOrder.verifyNoMoreInteractions();
399 verify(observer1, never()).onComplete();
400
401 }
402
403 {
404 Observer<Object> observer1 = TestHelper.mockObserver();
405 InOrder inOrder = inOrder(observer1);
406
407 co.subscribe(observer1);
408
409 inOrder.verify(observer1, times(1)).onNext(2);
410 inOrder.verify(observer1, times(1)).onNext(3);
411 inOrder.verify(observer1, times(1)).onNext(4);
412 inOrder.verify(observer1, times(1)).onError(any(RuntimeException.class));
413 inOrder.verifyNoMoreInteractions();
414 verify(observer1, never()).onComplete();
415 }
416 }
417
418 @Test
419 public void windowedReplayError() {
420 TestScheduler scheduler = new TestScheduler();
421
422 PublishSubject<Integer> source = PublishSubject.create();
423
424 ConnectableObservable<Integer> co = source.replay(100, TimeUnit.MILLISECONDS, scheduler, true);
425 co.connect();
426
427 {
428 Observer<Object> observer1 = TestHelper.mockObserver();
429 InOrder inOrder = inOrder(observer1);
430
431 co.subscribe(observer1);
432
433 source.onNext(1);
434 scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS);
435 source.onNext(2);
436 scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS);
437 source.onNext(3);
438 scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS);
439 source.onError(new RuntimeException("Forced failure"));
440 scheduler.advanceTimeBy(60, TimeUnit.MILLISECONDS);
441
442 inOrder.verify(observer1, times(1)).onNext(1);
443 inOrder.verify(observer1, times(1)).onNext(2);
444 inOrder.verify(observer1, times(1)).onNext(3);
445
446 inOrder.verify(observer1, times(1)).onError(any(RuntimeException.class));
447 inOrder.verifyNoMoreInteractions();
448 verify(observer1, never()).onComplete();
449
450 }
451 {
452 Observer<Object> observer1 = TestHelper.mockObserver();
453 InOrder inOrder = inOrder(observer1);
454
455 co.subscribe(observer1);
456 inOrder.verify(observer1, never()).onNext(3);
457
458 inOrder.verify(observer1, times(1)).onError(any(RuntimeException.class));
459 inOrder.verifyNoMoreInteractions();
460 verify(observer1, never()).onComplete();
461 }
462 }
463
464 @Test
465 public void synchronousDisconnect() {
466 final AtomicInteger effectCounter = new AtomicInteger();
467 Observable<Integer> source = Observable.just(1, 2, 3, 4)
468 .doOnNext(new Consumer<Integer>() {
469 @Override
470 public void accept(Integer v) {
471 effectCounter.incrementAndGet();
472 System.out.println("Sideeffect #" + v);
473 }
474 });
475
476 Observable<Integer> result = source.replay(
477 new Function<Observable<Integer>, Observable<Integer>>() {
478 @Override
479 public Observable<Integer> apply(Observable<Integer> o) {
480 return o.take(2);
481 }
482 });
483
484 for (int i = 1; i < 3; i++) {
485 effectCounter.set(0);
486 System.out.printf("- %d -%n", i);
487 result.subscribe(new Consumer<Integer>() {
488
489 @Override
490 public void accept(Integer t1) {
491 System.out.println(t1);
492 }
493
494 }, new Consumer<Throwable>() {
495
496 @Override
497 public void accept(Throwable t1) {
498 t1.printStackTrace();
499 }
500 },
501 new Action() {
502 @Override
503 public void run() {
504 System.out.println("Done");
505 }
506 });
507 assertEquals(2, effectCounter.get());
508 }
509 }
510
511 /*
512 * test the basic expectation of OperatorMulticast via replay
513 */
514 @SuppressWarnings("unchecked")
515 @Test
516 public void issue2191_UnsubscribeSource() throws Throwable {
517 // setup mocks
518 Consumer<Integer> sourceNext = mock(Consumer.class);
519 Action sourceCompleted = mock(Action.class);
520 Action sourceUnsubscribed = mock(Action.class);
521 Observer<Integer> spiedSubscriberBeforeConnect = TestHelper.mockObserver();
522 Observer<Integer> spiedSubscriberAfterConnect = TestHelper.mockObserver();
523
524 // Observable under test
525 Observable<Integer> source = Observable.just(1, 2);
526
527 ConnectableObservable<Integer> replay = source
528 .doOnNext(sourceNext)
529 .doOnDispose(sourceUnsubscribed)
530 .doOnComplete(sourceCompleted)
531 .replay();
532
533 replay.subscribe(spiedSubscriberBeforeConnect);
534 replay.subscribe(spiedSubscriberBeforeConnect);
535 replay.connect();
536 replay.subscribe(spiedSubscriberAfterConnect);
537 replay.subscribe(spiedSubscriberAfterConnect);
538
539 verify(spiedSubscriberBeforeConnect, times(2)).onSubscribe((Disposable)any());
540 verify(spiedSubscriberAfterConnect, times(2)).onSubscribe((Disposable)any());
541
542 // verify interactions
543 verify(sourceNext, times(1)).accept(1);
544 verify(sourceNext, times(1)).accept(2);
545 verify(sourceCompleted, times(1)).run();
546 verifyObserverMock(spiedSubscriberBeforeConnect, 2, 4);
547 verifyObserverMock(spiedSubscriberAfterConnect, 2, 4);
548
549 // verify(sourceUnsubscribed, times(1)).run();
550
551 verifyNoMoreInteractions(sourceNext);
552 verifyNoMoreInteractions(sourceCompleted);
553 verifyNoMoreInteractions(sourceUnsubscribed);
554 verifyNoMoreInteractions(spiedSubscriberBeforeConnect);
555 verifyNoMoreInteractions(spiedSubscriberAfterConnect);
556
557 }
558
559 /**
560 * Specifically test interaction with a Scheduler with subscribeOn.
561 *
562 * @throws Throwable functional interfaces are declared with throws Exception
563 */
564 @SuppressWarnings("unchecked")
565 @Test
566 public void issue2191_SchedulerUnsubscribe() throws Throwable {
567 // setup mocks
568 Consumer<Integer> sourceNext = mock(Consumer.class);
569 Action sourceCompleted = mock(Action.class);
570 Action sourceUnsubscribed = mock(Action.class);
571 final TestScheduler mockScheduler = new TestScheduler();
572
573 Observer<Integer> mockObserverBeforeConnect = TestHelper.mockObserver();
574 Observer<Integer> mockObserverAfterConnect = TestHelper.mockObserver();
575
576 // Observable under test
577 ConnectableObservable<Integer> replay = Observable.just(1, 2, 3)
578 .doOnNext(sourceNext)
579 .doOnDispose(sourceUnsubscribed)
580 .doOnComplete(sourceCompleted)
581 .subscribeOn(mockScheduler).replay();
582
583 replay.subscribe(mockObserverBeforeConnect);
584 replay.connect();
585 replay.subscribe(mockObserverAfterConnect);
586
587 verify(mockObserverBeforeConnect).onSubscribe((Disposable)any());
588 verify(mockObserverAfterConnect).onSubscribe((Disposable)any());
589
590 mockScheduler.advanceTimeBy(1, TimeUnit.SECONDS);
591
592 // verify interactions
593 verify(sourceNext, times(1)).accept(1);
594 verify(sourceNext, times(1)).accept(2);
595 verify(sourceNext, times(1)).accept(3);
596 verify(sourceCompleted, times(1)).run();
597 verifyObserverMock(mockObserverBeforeConnect, 1, 3);
598 verifyObserverMock(mockObserverAfterConnect, 1, 3);
599
600 // FIXME not supported
601 // verify(spiedWorker, times(1)).isUnsubscribed();
602 // FIXME publish calls cancel too
603 // verify(sourceUnsubscribed, times(1)).run();
604
605 verifyNoMoreInteractions(sourceNext);
606 verifyNoMoreInteractions(sourceCompleted);
607 verifyNoMoreInteractions(sourceUnsubscribed);
608 verifyNoMoreInteractions(mockObserverBeforeConnect);
609 verifyNoMoreInteractions(mockObserverAfterConnect);
610 }
611
612 /**
613 * Specifically test interaction with a Scheduler with subscribeOn.
614 *
615 * @throws Throwable functional interfaces are declared with throws Exception
616 */
617 @SuppressWarnings("unchecked")
618 @Test
619 public void issue2191_SchedulerUnsubscribeOnError() throws Throwable {
620 // setup mocks
621 Consumer<Integer> sourceNext = mock(Consumer.class);
622 Action sourceCompleted = mock(Action.class);
623 Consumer<Throwable> sourceError = mock(Consumer.class);
624 Action sourceUnsubscribed = mock(Action.class);
625 final TestScheduler mockScheduler = new TestScheduler();
626 Observer<Integer> mockObserverBeforeConnect = TestHelper.mockObserver();
627 Observer<Integer> mockObserverAfterConnect = TestHelper.mockObserver();
628
629 // Observable under test
630 Function<Integer, Integer> mockFunc = mock(Function.class);
631 IllegalArgumentException illegalArgumentException = new IllegalArgumentException();
632 when(mockFunc.apply(1)).thenReturn(1);
633 when(mockFunc.apply(2)).thenThrow(illegalArgumentException);
634 ConnectableObservable<Integer> replay = Observable.just(1, 2, 3).map(mockFunc)
635 .doOnNext(sourceNext)
636 .doOnDispose(sourceUnsubscribed)
637 .doOnComplete(sourceCompleted)
638 .doOnError(sourceError)
639 .subscribeOn(mockScheduler).replay();
640
641 replay.subscribe(mockObserverBeforeConnect);
642 replay.connect();
643 replay.subscribe(mockObserverAfterConnect);
644
645 verify(mockObserverBeforeConnect).onSubscribe((Disposable)any());
646 verify(mockObserverAfterConnect).onSubscribe((Disposable)any());
647
648 mockScheduler.advanceTimeBy(1, TimeUnit.SECONDS);
649 // verify interactions
650 verify(sourceNext, times(1)).accept(1);
651 verify(sourceError, times(1)).accept(illegalArgumentException);
652 verifyObserver(mockObserverBeforeConnect, 1, 1, illegalArgumentException);
653 verifyObserver(mockObserverAfterConnect, 1, 1, illegalArgumentException);
654
655 // FIXME no longer supported
656 // verify(spiedWorker, times(1)).isUnsubscribed();
657 // FIXME publish also calls cancel
658 // verify(sourceUnsubscribed, times(1)).run();
659
660 verifyNoMoreInteractions(sourceNext);
661 verifyNoMoreInteractions(sourceCompleted);
662 verifyNoMoreInteractions(sourceError);
663 verifyNoMoreInteractions(sourceUnsubscribed);
664 verifyNoMoreInteractions(mockObserverBeforeConnect);
665 verifyNoMoreInteractions(mockObserverAfterConnect);
666 }
667
668 private static void verifyObserverMock(Observer<Integer> mock, int numSubscriptions, int numItemsExpected) {
669 verify(mock, times(numItemsExpected)).onNext((Integer) notNull());
670 verify(mock, times(numSubscriptions)).onComplete();
671 verifyNoMoreInteractions(mock);
672 }
673
674 private static void verifyObserver(Observer<Integer> mock, int numSubscriptions, int numItemsExpected, Throwable error) {
675 verify(mock, times(numItemsExpected)).onNext((Integer) notNull());
676 verify(mock, times(numSubscriptions)).onError(error);
677 verifyNoMoreInteractions(mock);
678 }
679
680 public static Worker workerSpy(final Disposable mockDisposable) {
681 return spy(new InprocessWorker(mockDisposable));
682 }
683
684 static class InprocessWorker extends Worker {
685 private final Disposable mockDisposable;
686 public boolean unsubscribed;
687
688 InprocessWorker(Disposable mockDisposable) {
689 this.mockDisposable = mockDisposable;
690 }
691
692 @NonNull
693 @Override
694 public Disposable schedule(@NonNull Runnable action) {
695 action.run();
696 return mockDisposable; // this subscription is returned but discarded
697 }
698
699 @NonNull
700 @Override
701 public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
702 action.run();
703 return mockDisposable;
704 }
705
706 @Override
707 public void dispose() {
708 unsubscribed = true;
709 }
710
711 @Override
712 public boolean isDisposed() {
713 return unsubscribed;
714 }
715 }
716
717 @Test
718 public void boundedReplayBuffer() {
719 BoundedReplayBuffer<Integer> buf = new BoundedReplayBuffer<Integer>(false) {
720 private static final long serialVersionUID = -5182053207244406872L;
721
722 @Override
723 void truncate() {
724 }
725 };
726 buf.addLast(new Node(1));
727 buf.addLast(new Node(2));
728 buf.addLast(new Node(3));
729 buf.addLast(new Node(4));
730 buf.addLast(new Node(5));
731
732 List<Integer> values = new ArrayList<>();
733 buf.collect(values);
734
735 Assert.assertEquals(Arrays.asList(1, 2, 3, 4, 5), values);
736
737 buf.removeSome(2);
738 buf.removeFirst();
739 buf.removeSome(2);
740
741 values.clear();
742 buf.collect(values);
743 Assert.assertTrue(values.isEmpty());
744
745 buf.addLast(new Node(5));
746 buf.addLast(new Node(6));
747 buf.collect(values);
748
749 Assert.assertEquals(Arrays.asList(5, 6), values);
750
751 }
752
753 @Test
754 public void timedAndSizedTruncation() {
755 TestScheduler test = new TestScheduler();
756 SizeAndTimeBoundReplayBuffer<Integer> buf = new SizeAndTimeBoundReplayBuffer<>(2, 2000, TimeUnit.MILLISECONDS, test, false);
757 List<Integer> values = new ArrayList<>();
758
759 buf.next(1);
760 test.advanceTimeBy(1, TimeUnit.SECONDS);
761 buf.next(2);
762 test.advanceTimeBy(1, TimeUnit.SECONDS);
763 buf.collect(values);
764 Assert.assertEquals(Arrays.asList(2), values);
765
766 buf.next(3);
767 buf.next(4);
768 values.clear();
769 buf.collect(values);
770 Assert.assertEquals(Arrays.asList(3, 4), values);
771
772 test.advanceTimeBy(2, TimeUnit.SECONDS);
773 buf.next(5);
774
775 values.clear();
776 buf.collect(values);
777 Assert.assertEquals(Arrays.asList(5), values);
778 Assert.assertFalse(buf.hasCompleted());
779
780 test.advanceTimeBy(2, TimeUnit.SECONDS);
781 buf.complete();
782
783 values.clear();
784 buf.collect(values);
785 Assert.assertTrue(values.isEmpty());
786
787 Assert.assertEquals(1, buf.size);
788 Assert.assertTrue(buf.hasCompleted());
789 Assert.assertFalse(buf.hasError());
790 }
791
792 @Test
793 public void timedAndSizedTruncationError() {
794 TestScheduler test = new TestScheduler();
795 SizeAndTimeBoundReplayBuffer<Integer> buf = new SizeAndTimeBoundReplayBuffer<>(2, 2000, TimeUnit.MILLISECONDS, test, false);
796
797 Assert.assertFalse(buf.hasCompleted());
798 Assert.assertFalse(buf.hasError());
799
800 List<Integer> values = new ArrayList<>();
801
802 buf.next(1);
803 test.advanceTimeBy(1, TimeUnit.SECONDS);
804 buf.next(2);
805 test.advanceTimeBy(1, TimeUnit.SECONDS);
806 buf.collect(values);
807 Assert.assertEquals(Arrays.asList(2), values);
808
809 buf.next(3);
810 buf.next(4);
811 values.clear();
812 buf.collect(values);
813 Assert.assertEquals(Arrays.asList(3, 4), values);
814
815 test.advanceTimeBy(2, TimeUnit.SECONDS);
816 buf.next(5);
817
818 values.clear();
819 buf.collect(values);
820 Assert.assertEquals(Arrays.asList(5), values);
821 Assert.assertFalse(buf.hasCompleted());
822 Assert.assertFalse(buf.hasError());
823
824 test.advanceTimeBy(2, TimeUnit.SECONDS);
825 buf.error(new TestException());
826
827 values.clear();
828 buf.collect(values);
829 Assert.assertTrue(values.isEmpty());
830
831 Assert.assertEquals(1, buf.size);
832 Assert.assertFalse(buf.hasCompleted());
833 Assert.assertTrue(buf.hasError());
834 }
835
836 @Test
837 public void sizedTruncation() {
838 SizeBoundReplayBuffer<Integer> buf = new SizeBoundReplayBuffer<>(2, false);
839 List<Integer> values = new ArrayList<>();
840
841 buf.next(1);
842 buf.next(2);
843 buf.collect(values);
844 Assert.assertEquals(Arrays.asList(1, 2), values);
845
846 buf.next(3);
847 buf.next(4);
848 values.clear();
849 buf.collect(values);
850 Assert.assertEquals(Arrays.asList(3, 4), values);
851
852 buf.next(5);
853
854 values.clear();
855 buf.collect(values);
856 Assert.assertEquals(Arrays.asList(4, 5), values);
857 Assert.assertFalse(buf.hasCompleted());
858
859 buf.complete();
860
861 values.clear();
862 buf.collect(values);
863 Assert.assertEquals(Arrays.asList(4, 5), values);
864
865 Assert.assertEquals(3, buf.size);
866 Assert.assertTrue(buf.hasCompleted());
867 Assert.assertFalse(buf.hasError());
868 }
869
870 @Test
871 public void coldReplayNoBackpressure() {
872 Observable<Integer> source = Observable.range(0, 1000).replay().autoConnect();
873
874 TestObserverEx<Integer> to = new TestObserverEx<>();
875
876 source.subscribe(to);
877
878 to.assertNoErrors();
879 to.assertTerminated();
880 List<Integer> onNextEvents = to.values();
881 assertEquals(1000, onNextEvents.size());
882
883 for (int i = 0; i < 1000; i++) {
884 assertEquals((Integer)i, onNextEvents.get(i));
885 }
886 }
887
888 @Test
889 public void cache() throws InterruptedException {
890 final AtomicInteger counter = new AtomicInteger();
891 Observable<String> o = Observable.unsafeCreate(new ObservableSource<String>() {
892
893 @Override
894 public void subscribe(final Observer<? super String> observer) {
895 observer.onSubscribe(Disposable.empty());
896 new Thread(new Runnable() {
897
898 @Override
899 public void run() {
900 counter.incrementAndGet();
901 System.out.println("published Observable being executed");
902 observer.onNext("one");
903 observer.onComplete();
904 }
905 }).start();
906 }
907 }).replay().autoConnect();
908
909 // we then expect the following 2 subscriptions to get that same value
910 final CountDownLatch latch = new CountDownLatch(2);
911
912 // subscribe once
913 o.subscribe(new Consumer<String>() {
914
915 @Override
916 public void accept(String v) {
917 assertEquals("one", v);
918 System.out.println("v: " + v);
919 latch.countDown();
920 }
921 });
922
923 // subscribe again
924 o.subscribe(new Consumer<String>() {
925
926 @Override
927 public void accept(String v) {
928 assertEquals("one", v);
929 System.out.println("v: " + v);
930 latch.countDown();
931 }
932 });
933
934 if (!latch.await(1000, TimeUnit.MILLISECONDS)) {
935 fail("subscriptions did not receive values");
936 }
937 assertEquals(1, counter.get());
938 }
939
940 @Test
941 public void unsubscribeSource() throws Throwable {
942 Action unsubscribe = mock(Action.class);
943 Observable<Integer> o = Observable.just(1).doOnDispose(unsubscribe).replay().autoConnect();
944 o.subscribe();
945 o.subscribe();
946 o.subscribe();
947 verify(unsubscribe, never()).run();
948 }
949
950 @Test
951 public void take() {
952 TestObserverEx<Integer> to = new TestObserverEx<>();
953
954 Observable<Integer> cached = Observable.range(1, 100).replay().autoConnect();
955 cached.take(10).subscribe(to);
956
957 to.assertNoErrors();
958 to.assertTerminated();
959 to.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
960 // FIXME no longer assertable
961 // ts.assertUnsubscribed();
962 }
963
964 @Test
965 public void async() {
966 Observable<Integer> source = Observable.range(1, 10000);
967 for (int i = 0; i < 100; i++) {
968 TestObserverEx<Integer> to1 = new TestObserverEx<>();
969
970 Observable<Integer> cached = source.replay().autoConnect();
971
972 cached.observeOn(Schedulers.computation()).subscribe(to1);
973
974 to1.awaitDone(2, TimeUnit.SECONDS);
975 to1.assertNoErrors();
976 to1.assertTerminated();
977 assertEquals(10000, to1.values().size());
978
979 TestObserverEx<Integer> to2 = new TestObserverEx<>();
980 cached.observeOn(Schedulers.computation()).subscribe(to2);
981
982 to2.awaitDone(2, TimeUnit.SECONDS);
983 to2.assertNoErrors();
984 to2.assertTerminated();
985 assertEquals(10000, to2.values().size());
986 }
987 }
988
989 @Test
990 public void asyncComeAndGo() {
991 Observable<Long> source = Observable.interval(1, 1, TimeUnit.MILLISECONDS)
992 .take(1000)
993 .subscribeOn(Schedulers.io());
994 Observable<Long> cached = source.replay().autoConnect();
995
996 Observable<Long> output = cached.observeOn(Schedulers.computation());
997
998 List<TestObserverEx<Long>> list = new ArrayList<>(100);
999 for (int i = 0; i < 100; i++) {
1000 TestObserverEx<Long> to = new TestObserverEx<>();
1001 list.add(to);
1002 output.skip(i * 10).take(10).subscribe(to);
1003 }
1004
1005 List<Long> expected = new ArrayList<>();
1006 for (int i = 0; i < 10; i++) {
1007 expected.add((long)(i - 10));
1008 }
1009 int j = 0;
1010 for (TestObserverEx<Long> to : list) {
1011 to.awaitDone(3, TimeUnit.SECONDS);
1012 to.assertNoErrors();
1013 to.assertTerminated();
1014
1015 for (int i = j * 10; i < j * 10 + 10; i++) {
1016 expected.set(i - j * 10, (long)i);
1017 }
1018
1019 to.assertValueSequence(expected);
1020
1021 j++;
1022 }
1023 }
1024
1025 @Test
1026 public void noMissingBackpressureException() {
1027 final int m = 4 * 1000 * 1000;
1028 Observable<Integer> firehose = Observable.unsafeCreate(new ObservableSource<Integer>() {
1029 @Override
1030 public void subscribe(Observer<? super Integer> t) {
1031 t.onSubscribe(Disposable.empty());
1032 for (int i = 0; i < m; i++) {
1033 t.onNext(i);
1034 }
1035 t.onComplete();
1036 }
1037 });
1038
1039 TestObserverEx<Integer> to = new TestObserverEx<>();
1040 firehose.replay().autoConnect().observeOn(Schedulers.computation()).takeLast(100).subscribe(to);
1041
1042 to.awaitDone(3, TimeUnit.SECONDS);
1043 to.assertNoErrors();
1044 to.assertTerminated();
1045
1046 assertEquals(100, to.values().size());
1047 }
1048
1049 @Test
1050 public void valuesAndThenError() {
1051 Observable<Integer> source = Observable.range(1, 10)
1052 .concatWith(Observable.<Integer>error(new TestException()))
1053 .replay().autoConnect();
1054
1055 TestObserverEx<Integer> to = new TestObserverEx<>();
1056 source.subscribe(to);
1057
1058 to.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
1059 to.assertNotComplete();
1060 Assert.assertEquals(1, to.errors().size());
1061
1062 TestObserverEx<Integer> to2 = new TestObserverEx<>();
1063 source.subscribe(to2);
1064
1065 to2.assertValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
1066 to2.assertNotComplete();
1067 Assert.assertEquals(1, to2.errors().size());
1068 }
1069
1070 @Test
1071 public void replayTime() {
1072 Observable.just(1).replay(1, TimeUnit.MINUTES, Schedulers.computation(), true)
1073 .autoConnect()
1074 .test()
1075 .awaitDone(5, TimeUnit.SECONDS)
1076 .assertResult(1);
1077 }
1078
1079 @Test
1080 public void replaySizeAndTime() {
1081 Observable.just(1).replay(1, 1, TimeUnit.MILLISECONDS, Schedulers.computation(), true)
1082 .autoConnect()
1083 .test()
1084 .awaitDone(5, TimeUnit.SECONDS)
1085 .assertResult(1);
1086 }
1087
1088 @Test
1089 public void replaySelectorTime() {
1090 Observable.just(1).replay(Functions.<Observable<Integer>>identity(), 1, TimeUnit.MINUTES)
1091 .test()
1092 .awaitDone(5, TimeUnit.SECONDS)
1093 .assertResult(1);
1094 }
1095
1096 @Test
1097 public void replayMaxInt() {
1098 Observable.range(1, 2)
1099 .replay(Integer.MAX_VALUE, true)
1100 .autoConnect()
1101 .test()
1102 .assertResult(1, 2);
1103 }
1104
1105 @Test
1106 public void source() {
1107 Observable<Integer> source = Observable.range(1, 3);
1108
1109 assertSame(source, (((HasUpstreamObservableSource<?>)source.replay())).source());
1110 }
1111
1112 @Test
1113 public void connectRace() {
1114 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
1115 final ConnectableObservable<Integer> co = Observable.range(1, 3).replay();
1116
1117 Runnable r = new Runnable() {
1118 @Override
1119 public void run() {
1120 co.connect();
1121 }
1122 };
1123
1124 TestHelper.race(r, r);
1125 }
1126 }
1127
1128 @Test
1129 public void subscribeRace() {
1130 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
1131 final ConnectableObservable<Integer> co = Observable.range(1, 3).replay();
1132
1133 final TestObserver<Integer> to1 = new TestObserver<>();
1134 final TestObserver<Integer> to2 = new TestObserver<>();
1135
1136 Runnable r1 = new Runnable() {
1137 @Override
1138 public void run() {
1139 co.subscribe(to1);
1140 }
1141 };
1142
1143 Runnable r2 = new Runnable() {
1144 @Override
1145 public void run() {
1146 co.subscribe(to2);
1147 }
1148 };
1149
1150 TestHelper.race(r1, r2);
1151 }
1152 }
1153
1154 @Test
1155 public void addRemoveRace() {
1156 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
1157 final ConnectableObservable<Integer> co = Observable.range(1, 3).replay();
1158
1159 final TestObserver<Integer> to1 = new TestObserver<>();
1160 final TestObserver<Integer> to2 = new TestObserver<>();
1161
1162 co.subscribe(to1);
1163
1164 Runnable r1 = new Runnable() {
1165 @Override
1166 public void run() {
1167 to1.dispose();
1168 }
1169 };
1170
1171 Runnable r2 = new Runnable() {
1172 @Override
1173 public void run() {
1174 co.subscribe(to2);
1175 }
1176 };
1177
1178 TestHelper.race(r1, r2);
1179 }
1180 }
1181
1182 @Test
1183 public void cancelOnArrival() {
1184 Observable.range(1, 2)
1185 .replay(Integer.MAX_VALUE, true)
1186 .autoConnect()
1187 .test(true)
1188 .assertEmpty();
1189 }
1190
1191 @Test
1192 public void cancelOnArrival2() {
1193 ConnectableObservable<Integer> co = PublishSubject.<Integer>create()
1194 .replay(Integer.MAX_VALUE, true);
1195
1196 co.test();
1197
1198 co
1199 .autoConnect()
1200 .test(true)
1201 .assertEmpty();
1202 }
1203
1204 @Test
1205 public void connectConsumerThrows() {
1206 ConnectableObservable<Integer> co = Observable.range(1, 2)
1207 .replay();
1208
1209 try {
1210 co.connect(new Consumer<Disposable>() {
1211 @Override
1212 public void accept(Disposable t) throws Exception {
1213 throw new TestException();
1214 }
1215 });
1216 fail("Should have thrown");
1217 } catch (TestException ex) {
1218 // expected
1219 }
1220
1221 co.test().assertEmpty().dispose();
1222
1223 co.connect();
1224
1225 co.test().assertResult(1, 2);
1226 }
1227
1228 @Test
1229 public void badSource() {
1230 List<Throwable> errors = TestHelper.trackPluginErrors();
1231 try {
1232 new Observable<Integer>() {
1233 @Override
1234 protected void subscribeActual(Observer<? super Integer> observer) {
1235 observer.onSubscribe(Disposable.empty());
1236 observer.onError(new TestException("First"));
1237 observer.onNext(1);
1238 observer.onError(new TestException("Second"));
1239 observer.onComplete();
1240 }
1241 }.replay()
1242 .autoConnect()
1243 .to(TestHelper.<Integer>testConsumer())
1244 .assertFailureAndMessage(TestException.class, "First");
1245
1246 TestHelper.assertUndeliverable(errors, 0, TestException.class, "Second");
1247 } finally {
1248 RxJavaPlugins.reset();
1249 }
1250 }
1251
1252 @Test
1253 public void subscribeOnNextRace() {
1254 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
1255 final PublishSubject<Integer> ps = PublishSubject.create();
1256
1257 final ConnectableObservable<Integer> co = ps.replay();
1258
1259 final TestObserver<Integer> to1 = new TestObserver<>();
1260
1261 Runnable r1 = new Runnable() {
1262 @Override
1263 public void run() {
1264 co.subscribe(to1);
1265 }
1266 };
1267
1268 Runnable r2 = new Runnable() {
1269 @Override
1270 public void run() {
1271 for (int j = 0; j < 1000; j++) {
1272 ps.onNext(j);
1273 }
1274 }
1275 };
1276
1277 TestHelper.race(r1, r2);
1278 }
1279 }
1280
1281 @Test
1282 public void unsubscribeOnNextRace() {
1283 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
1284 final PublishSubject<Integer> ps = PublishSubject.create();
1285
1286 final ConnectableObservable<Integer> co = ps.replay();
1287
1288 final TestObserver<Integer> to1 = new TestObserver<>();
1289
1290 co.subscribe(to1);
1291
1292 Runnable r1 = new Runnable() {
1293 @Override
1294 public void run() {
1295 to1.dispose();
1296 }
1297 };
1298
1299 Runnable r2 = new Runnable() {
1300 @Override
1301 public void run() {
1302 for (int j = 0; j < 1000; j++) {
1303 ps.onNext(j);
1304 }
1305 }
1306 };
1307
1308 TestHelper.race(r1, r2);
1309 }
1310 }
1311
1312 @Test
1313 public void unsubscribeReplayRace() {
1314 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
1315 final ConnectableObservable<Integer> co = Observable.range(1, 1000).replay();
1316
1317 final TestObserver<Integer> to1 = new TestObserver<>();
1318
1319 co.connect();
1320
1321 Runnable r1 = new Runnable() {
1322 @Override
1323 public void run() {
1324 co.subscribe(to1);
1325 }
1326 };
1327
1328 Runnable r2 = new Runnable() {
1329 @Override
1330 public void run() {
1331 to1.dispose();
1332 }
1333 };
1334
1335 TestHelper.race(r1, r2);
1336 }
1337 }
1338
1339 @Test
1340 public void reentrantOnNext() {
1341 final PublishSubject<Integer> ps = PublishSubject.create();
1342
1343 TestObserver<Integer> to = new TestObserver<Integer>() {
1344 @Override
1345 public void onNext(Integer t) {
1346 if (t == 1) {
1347 ps.onNext(2);
1348 ps.onComplete();
1349 }
1350 super.onNext(t);
1351 }
1352 };
1353
1354 ps.replay().autoConnect().subscribe(to);
1355
1356 ps.onNext(1);
1357
1358 to.assertResult(1, 2);
1359 }
1360
1361 @Test
1362 public void reentrantOnNextBound() {
1363 final PublishSubject<Integer> ps = PublishSubject.create();
1364
1365 TestObserver<Integer> to = new TestObserver<Integer>() {
1366 @Override
1367 public void onNext(Integer t) {
1368 if (t == 1) {
1369 ps.onNext(2);
1370 ps.onComplete();
1371 }
1372 super.onNext(t);
1373 }
1374 };
1375
1376 ps.replay(10, true).autoConnect().subscribe(to);
1377
1378 ps.onNext(1);
1379
1380 to.assertResult(1, 2);
1381 }
1382
1383 @Test
1384 public void reentrantOnNextCancel() {
1385 final PublishSubject<Integer> ps = PublishSubject.create();
1386
1387 TestObserver<Integer> to = new TestObserver<Integer>() {
1388 @Override
1389 public void onNext(Integer t) {
1390 if (t == 1) {
1391 ps.onNext(2);
1392 dispose();
1393 }
1394 super.onNext(t);
1395 }
1396 };
1397
1398 ps.replay().autoConnect().subscribe(to);
1399
1400 ps.onNext(1);
1401
1402 to.assertValues(1);
1403 }
1404
1405 @Test
1406 public void reentrantOnNextCancelBounded() {
1407 final PublishSubject<Integer> ps = PublishSubject.create();
1408
1409 TestObserver<Integer> to = new TestObserver<Integer>() {
1410 @Override
1411 public void onNext(Integer t) {
1412 if (t == 1) {
1413 ps.onNext(2);
1414 dispose();
1415 }
1416 super.onNext(t);
1417 }
1418 };
1419
1420 ps.replay(10, true).autoConnect().subscribe(to);
1421
1422 ps.onNext(1);
1423
1424 to.assertValues(1);
1425 }
1426
1427 @Test
1428 public void delayedUpstreamOnSubscribe() {
1429 final Observer<?>[] sub = { null };
1430
1431 new Observable<Integer>() {
1432 @Override
1433 protected void subscribeActual(Observer<? super Integer> observer) {
1434 sub[0] = observer;
1435 }
1436 }
1437 .replay()
1438 .connect()
1439 .dispose();
1440
1441 Disposable bs = Disposable.empty();
1442
1443 sub[0].onSubscribe(bs);
1444
1445 assertTrue(bs.isDisposed());
1446 }
1447
1448 @Test
1449 public void timedNoOutdatedData() {
1450 TestScheduler scheduler = new TestScheduler();
1451
1452 Observable<Integer> source = Observable.just(1)
1453 .replay(2, TimeUnit.SECONDS, scheduler, true)
1454 .autoConnect();
1455
1456 source.test().assertResult(1);
1457
1458 source.test().assertResult(1);
1459
1460 scheduler.advanceTimeBy(3, TimeUnit.SECONDS);
1461
1462 source.test().assertResult();
1463 }
1464
1465 @Test
1466 public void replaySelectorReturnsNull() {
1467 Observable.just(1)
1468 .replay(new Function<Observable<Integer>, Observable<Object>>() {
1469 @Override
1470 public Observable<Object> apply(Observable<Integer> v) throws Exception {
1471 return null;
1472 }
1473 })
1474 .to(TestHelper.<Object>testConsumer())
1475 .assertFailureAndMessage(NullPointerException.class, "The selector returned a null ObservableSource");
1476 }
1477
1478 @Test
1479 public void replaySelectorConnectableReturnsNull() {
1480 ObservableReplay.multicastSelector(Functions.justSupplier((ConnectableObservable<Integer>)null), Functions.justFunction(Observable.just(1)))
1481 .to(TestHelper.<Integer>testConsumer())
1482 .assertFailureAndMessage(NullPointerException.class, "The connectableFactory returned a null ConnectableObservable");
1483 }
1484
1485 @Test
1486 public void noHeadRetentionCompleteSize() {
1487 PublishSubject<Integer> source = PublishSubject.create();
1488
1489 ObservableReplay<Integer> co = (ObservableReplay<Integer>)source
1490 .replay(1, true);
1491
1492 co.connect();
1493
1494 BoundedReplayBuffer<Integer> buf = (BoundedReplayBuffer<Integer>)(co.current.get().buffer);
1495
1496 source.onNext(1);
1497 source.onNext(2);
1498 source.onComplete();
1499
1500 assertNull(buf.get().value);
1501
1502 Object o = buf.get();
1503
1504 buf.trimHead();
1505
1506 assertSame(o, buf.get());
1507 }
1508
1509 @Test
1510 public void noHeadRetentionErrorSize() {
1511 PublishSubject<Integer> source = PublishSubject.create();
1512
1513 ObservableReplay<Integer> co = (ObservableReplay<Integer>)source
1514 .replay(1, true);
1515
1516 co.connect();
1517
1518 BoundedReplayBuffer<Integer> buf = (BoundedReplayBuffer<Integer>)(co.current.get().buffer);
1519
1520 source.onNext(1);
1521 source.onNext(2);
1522 source.onError(new TestException());
1523
1524 assertNull(buf.get().value);
1525
1526 Object o = buf.get();
1527
1528 buf.trimHead();
1529
1530 assertSame(o, buf.get());
1531 }
1532
1533 @Test
1534 public void noHeadRetentionSize() {
1535 PublishSubject<Integer> source = PublishSubject.create();
1536
1537 ObservableReplay<Integer> co = (ObservableReplay<Integer>)source
1538 .replay(1, true);
1539
1540 co.connect();
1541
1542 BoundedReplayBuffer<Integer> buf = (BoundedReplayBuffer<Integer>)(co.current.get().buffer);
1543
1544 source.onNext(1);
1545 source.onNext(2);
1546
1547 assertNull(buf.get().value);
1548
1549 buf.trimHead();
1550
1551 assertNull(buf.get().value);
1552
1553 Object o = buf.get();
1554
1555 buf.trimHead();
1556
1557 assertSame(o, buf.get());
1558 }
1559
1560 @Test
1561 public void noHeadRetentionCompleteTime() {
1562 PublishSubject<Integer> source = PublishSubject.create();
1563
1564 ObservableReplay<Integer> co = (ObservableReplay<Integer>)source
1565 .replay(1, TimeUnit.MINUTES, Schedulers.computation(), true);
1566
1567 co.connect();
1568
1569 BoundedReplayBuffer<Integer> buf = (BoundedReplayBuffer<Integer>)(co.current.get().buffer);
1570
1571 source.onNext(1);
1572 source.onNext(2);
1573 source.onComplete();
1574
1575 assertNull(buf.get().value);
1576
1577 Object o = buf.get();
1578
1579 buf.trimHead();
1580
1581 assertSame(o, buf.get());
1582 }
1583
1584 @Test
1585 public void noHeadRetentionErrorTime() {
1586 PublishSubject<Integer> source = PublishSubject.create();
1587
1588 ObservableReplay<Integer> co = (ObservableReplay<Integer>)source
1589 .replay(1, TimeUnit.MINUTES, Schedulers.computation(), true);
1590
1591 co.connect();
1592
1593 BoundedReplayBuffer<Integer> buf = (BoundedReplayBuffer<Integer>)(co.current.get().buffer);
1594
1595 source.onNext(1);
1596 source.onNext(2);
1597 source.onError(new TestException());
1598
1599 assertNull(buf.get().value);
1600
1601 Object o = buf.get();
1602
1603 buf.trimHead();
1604
1605 assertSame(o, buf.get());
1606 }
1607
1608 @Test
1609 public void noHeadRetentionTime() {
1610 TestScheduler sch = new TestScheduler();
1611
1612 PublishSubject<Integer> source = PublishSubject.create();
1613
1614 ObservableReplay<Integer> co = (ObservableReplay<Integer>)source
1615 .replay(1, TimeUnit.MILLISECONDS, sch, true);
1616
1617 co.connect();
1618
1619 BoundedReplayBuffer<Integer> buf = (BoundedReplayBuffer<Integer>)(co.current.get().buffer);
1620
1621 source.onNext(1);
1622
1623 sch.advanceTimeBy(2, TimeUnit.MILLISECONDS);
1624
1625 source.onNext(2);
1626
1627 assertNull(buf.get().value);
1628
1629 buf.trimHead();
1630
1631 assertNull(buf.get().value);
1632
1633 Object o = buf.get();
1634
1635 buf.trimHead();
1636
1637 assertSame(o, buf.get());
1638 }
1639
1640 @Test
1641 public void noBoundedRetentionViaThreadLocal() throws Exception {
1642 Observable<byte[]> source = Observable.range(1, 200)
1643 .map(new Function<Integer, byte[]>() {
1644 @Override
1645 public byte[] apply(Integer v) throws Exception {
1646 return new byte[1024 * 1024];
1647 }
1648 })
1649 .replay(new Function<Observable<byte[]>, Observable<byte[]>>() {
1650 @Override
1651 public Observable<byte[]> apply(final Observable<byte[]> o) throws Exception {
1652 return o.take(1)
1653 .concatMap(new Function<byte[], Observable<byte[]>>() {
1654 @Override
1655 public Observable<byte[]> apply(byte[] v) throws Exception {
1656 return o;
1657 }
1658 });
1659 }
1660 }, 1)
1661 .takeLast(1)
1662 ;
1663
1664 System.out.println("Bounded Replay Leak check: Wait before GC");
1665 Thread.sleep(1000);
1666
1667 System.out.println("Bounded Replay Leak check: GC");
1668 System.gc();
1669
1670 Thread.sleep(500);
1671
1672 final MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
1673 MemoryUsage memHeap = memoryMXBean.getHeapMemoryUsage();
1674 long initial = memHeap.getUsed();
1675
1676 System.out.printf("Bounded Replay Leak check: Starting: %.3f MB%n", initial / 1024.0 / 1024.0);
1677
1678 final AtomicLong after = new AtomicLong();
1679
1680 source.subscribe(new Consumer<byte[]>() {
1681 @Override
1682 public void accept(byte[] v) throws Exception {
1683 System.out.println("Bounded Replay Leak check: Wait before GC 2");
1684 Thread.sleep(1000);
1685
1686 System.out.println("Bounded Replay Leak check: GC 2");
1687 System.gc();
1688
1689 Thread.sleep(500);
1690
1691 after.set(memoryMXBean.getHeapMemoryUsage().getUsed());
1692 }
1693 });
1694
1695 System.out.printf("Bounded Replay Leak check: After: %.3f MB%n", after.get() / 1024.0 / 1024.0);
1696
1697 if (initial + 100 * 1024 * 1024 < after.get()) {
1698 Assert.fail("Bounded Replay Leak check: Memory leak detected: " + (initial / 1024.0 / 1024.0)
1699 + " -> " + after.get() / 1024.0 / 1024.0);
1700 }
1701 }
1702
1703 @Test
1704 public void sizeBoundEagerTruncate() throws Exception {
1705
1706 PublishSubject<int[]> ps = PublishSubject.create();
1707
1708 ConnectableObservable<int[]> co = ps.replay(1, true);
1709
1710 TestObserver<int[]> to = co.test();
1711
1712 co.connect();
1713
1714 Thread.sleep(200);
1715 System.gc();
1716 Thread.sleep(200);
1717
1718 final MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
1719 long initial = memoryMXBean.getHeapMemoryUsage().getUsed();
1720
1721 System.out.printf("Bounded Replay Leak check: Starting: %.3f MB%n", initial / 1024.0 / 1024.0);
1722
1723 ps.onNext(new int[100 * 1024 * 1024]);
1724
1725 to.assertValueCount(1);
1726 to.values().clear();
1727
1728 ps.onNext(new int[0]);
1729
1730 Thread.sleep(200);
1731 System.gc();
1732 Thread.sleep(200);
1733
1734 long after = memoryMXBean.getHeapMemoryUsage().getUsed();
1735
1736 to.dispose();
1737
1738 System.out.printf("Bounded Replay Leak check: After: %.3f MB%n", after / 1024.0 / 1024.0);
1739
1740 if (initial + 100 * 1024 * 1024 < after) {
1741 Assert.fail("Bounded Replay Leak check: Memory leak detected: " + (initial / 1024.0 / 1024.0)
1742 + " -> " + after / 1024.0 / 1024.0);
1743 }
1744 }
1745
1746 @Test
1747 public void timeBoundEagerTruncate() throws Exception {
1748
1749 PublishSubject<int[]> ps = PublishSubject.create();
1750
1751 TestScheduler scheduler = new TestScheduler();
1752
1753 ConnectableObservable<int[]> co = ps.replay(1, TimeUnit.SECONDS, scheduler, true);
1754
1755 TestObserver<int[]> to = co.test();
1756
1757 co.connect();
1758
1759 Thread.sleep(200);
1760 System.gc();
1761 Thread.sleep(200);
1762
1763 final MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
1764 long initial = memoryMXBean.getHeapMemoryUsage().getUsed();
1765
1766 System.out.printf("Bounded Replay Leak check: Starting: %.3f MB%n", initial / 1024.0 / 1024.0);
1767
1768 ps.onNext(new int[100 * 1024 * 1024]);
1769
1770 to.assertValueCount(1);
1771 to.values().clear();
1772
1773 scheduler.advanceTimeBy(2, TimeUnit.SECONDS);
1774
1775 ps.onNext(new int[0]);
1776
1777 Thread.sleep(200);
1778 System.gc();
1779 Thread.sleep(200);
1780
1781 long after = memoryMXBean.getHeapMemoryUsage().getUsed();
1782
1783 to.dispose();
1784
1785 System.out.printf("Bounded Replay Leak check: After: %.3f MB%n", after / 1024.0 / 1024.0);
1786
1787 if (initial + 100 * 1024 * 1024 < after) {
1788 Assert.fail("Bounded Replay Leak check: Memory leak detected: " + (initial / 1024.0 / 1024.0)
1789 + " -> " + after / 1024.0 / 1024.0);
1790 }
1791 }
1792
1793 @Test
1794 public void timeAndSizeBoundEagerTruncate() throws Exception {
1795
1796 PublishSubject<int[]> ps = PublishSubject.create();
1797
1798 TestScheduler scheduler = new TestScheduler();
1799
1800 ConnectableObservable<int[]> co = ps.replay(1, 5, TimeUnit.SECONDS, scheduler, true);
1801
1802 TestObserver<int[]> to = co.test();
1803
1804 co.connect();
1805
1806 Thread.sleep(200);
1807 System.gc();
1808 Thread.sleep(200);
1809
1810 final MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
1811 long initial = memoryMXBean.getHeapMemoryUsage().getUsed();
1812
1813 System.out.printf("Bounded Replay Leak check: Starting: %.3f MB%n", initial / 1024.0 / 1024.0);
1814
1815 ps.onNext(new int[100 * 1024 * 1024]);
1816
1817 to.assertValueCount(1);
1818 to.values().clear();
1819
1820 scheduler.advanceTimeBy(2, TimeUnit.SECONDS);
1821
1822 ps.onNext(new int[0]);
1823
1824 Thread.sleep(200);
1825 System.gc();
1826 Thread.sleep(200);
1827
1828 long after = memoryMXBean.getHeapMemoryUsage().getUsed();
1829
1830 to.dispose();
1831
1832 System.out.printf("Bounded Replay Leak check: After: %.3f MB%n", after / 1024.0 / 1024.0);
1833
1834 if (initial + 100 * 1024 * 1024 < after) {
1835 Assert.fail("Bounded Replay Leak check: Memory leak detected: " + (initial / 1024.0 / 1024.0)
1836 + " -> " + after / 1024.0 / 1024.0);
1837 }
1838 }
1839
1840 @Test
1841 public void sizeBoundSelectorEagerTruncate() throws Exception {
1842
1843 PublishSubject<int[]> ps = PublishSubject.create();
1844
1845 Observable<int[]> co = ps.replay(Functions.<Observable<int[]>>identity(), 1, true);
1846
1847 TestObserver<int[]> to = co.test();
1848
1849 Thread.sleep(200);
1850 System.gc();
1851 Thread.sleep(200);
1852
1853 final MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
1854 long initial = memoryMXBean.getHeapMemoryUsage().getUsed();
1855
1856 System.out.printf("Bounded Replay Leak check: Starting: %.3f MB%n", initial / 1024.0 / 1024.0);
1857
1858 ps.onNext(new int[100 * 1024 * 1024]);
1859
1860 to.assertValueCount(1);
1861 to.values().clear();
1862
1863 ps.onNext(new int[0]);
1864
1865 Thread.sleep(200);
1866 System.gc();
1867 Thread.sleep(200);
1868
1869 long after = memoryMXBean.getHeapMemoryUsage().getUsed();
1870
1871 to.dispose();
1872
1873 System.out.printf("Bounded Replay Leak check: After: %.3f MB%n", after / 1024.0 / 1024.0);
1874
1875 if (initial + 100 * 1024 * 1024 < after) {
1876 Assert.fail("Bounded Replay Leak check: Memory leak detected: " + (initial / 1024.0 / 1024.0)
1877 + " -> " + after / 1024.0 / 1024.0);
1878 }
1879 }
1880
1881 @Test
1882 public void timeBoundSelectorEagerTruncate() throws Exception {
1883
1884 PublishSubject<int[]> ps = PublishSubject.create();
1885
1886 TestScheduler scheduler = new TestScheduler();
1887
1888 Observable<int[]> co = ps.replay(Functions.<Observable<int[]>>identity(), 1, TimeUnit.SECONDS, scheduler, true);
1889
1890 TestObserver<int[]> to = co.test();
1891
1892 Thread.sleep(200);
1893 System.gc();
1894 Thread.sleep(200);
1895
1896 final MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
1897 long initial = memoryMXBean.getHeapMemoryUsage().getUsed();
1898
1899 System.out.printf("Bounded Replay Leak check: Starting: %.3f MB%n", initial / 1024.0 / 1024.0);
1900
1901 ps.onNext(new int[100 * 1024 * 1024]);
1902
1903 to.assertValueCount(1);
1904 to.values().clear();
1905
1906 scheduler.advanceTimeBy(2, TimeUnit.SECONDS);
1907
1908 ps.onNext(new int[0]);
1909
1910 Thread.sleep(200);
1911 System.gc();
1912 Thread.sleep(200);
1913
1914 long after = memoryMXBean.getHeapMemoryUsage().getUsed();
1915
1916 to.dispose();
1917
1918 System.out.printf("Bounded Replay Leak check: After: %.3f MB%n", after / 1024.0 / 1024.0);
1919
1920 if (initial + 100 * 1024 * 1024 < after) {
1921 Assert.fail("Bounded Replay Leak check: Memory leak detected: " + (initial / 1024.0 / 1024.0)
1922 + " -> " + after / 1024.0 / 1024.0);
1923 }
1924 }
1925
1926 @Test
1927 public void timeAndSizeSelectorBoundEagerTruncate() throws Exception {
1928
1929 PublishSubject<int[]> ps = PublishSubject.create();
1930
1931 TestScheduler scheduler = new TestScheduler();
1932
1933 Observable<int[]> co = ps.replay(Functions.<Observable<int[]>>identity(), 1, 5, TimeUnit.SECONDS, scheduler, true);
1934
1935 TestObserver<int[]> to = co.test();
1936
1937 Thread.sleep(200);
1938 System.gc();
1939 Thread.sleep(200);
1940
1941 final MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
1942 long initial = memoryMXBean.getHeapMemoryUsage().getUsed();
1943
1944 System.out.printf("Bounded Replay Leak check: Starting: %.3f MB%n", initial / 1024.0 / 1024.0);
1945
1946 ps.onNext(new int[100 * 1024 * 1024]);
1947
1948 to.assertValueCount(1);
1949 to.values().clear();
1950
1951 scheduler.advanceTimeBy(2, TimeUnit.SECONDS);
1952
1953 ps.onNext(new int[0]);
1954
1955 Thread.sleep(200);
1956 System.gc();
1957 Thread.sleep(200);
1958
1959 long after = memoryMXBean.getHeapMemoryUsage().getUsed();
1960
1961 to.dispose();
1962
1963 System.out.printf("Bounded Replay Leak check: After: %.3f MB%n", after / 1024.0 / 1024.0);
1964
1965 if (initial + 100 * 1024 * 1024 < after) {
1966 Assert.fail("Bounded Replay Leak check: Memory leak detected: " + (initial / 1024.0 / 1024.0)
1967 + " -> " + after / 1024.0 / 1024.0);
1968 }
1969 }
1970
1971 @Test
1972 public void timeAndSizeNoTerminalTruncationOnTimechange() {
1973 Observable.just(1).replay(1, 1, TimeUnit.SECONDS, new TimesteppingScheduler(), true)
1974 .autoConnect()
1975 .test()
1976 .assertComplete()
1977 .assertNoErrors();
1978 }
1979
1980 @Test
1981 public void disposeNoNeedForResetSizeBound() {
1982 PublishSubject<Integer> ps = PublishSubject.create();
1983
1984 ConnectableObservable<Integer> co = ps.replay(10, true);
1985
1986 TestObserver<Integer> to = co.test();
1987
1988 Disposable d = co.connect();
1989
1990 ps.onNext(1);
1991
1992 d.dispose();
1993
1994 to = co.test();
1995
1996 to.assertEmpty();
1997
1998 co.connect();
1999
2000 to.assertEmpty();
2001
2002 ps.onNext(2);
2003
2004 to.assertValuesOnly(2);
2005 }
2006
2007 @Test
2008 public void disposeNoNeedForResetTimeBound() {
2009 PublishSubject<Integer> ps = PublishSubject.create();
2010
2011 ConnectableObservable<Integer> co = ps.replay(10, TimeUnit.MINUTES, Schedulers.single(), true);
2012
2013 TestObserver<Integer> to = co.test();
2014
2015 Disposable d = co.connect();
2016
2017 ps.onNext(1);
2018
2019 d.dispose();
2020
2021 to = co.test();
2022
2023 to.assertEmpty();
2024
2025 co.connect();
2026
2027 to.assertEmpty();
2028
2029 ps.onNext(2);
2030
2031 to.assertValuesOnly(2);
2032 }
2033
2034 @Test
2035 public void disposeNoNeedForResetTimeAndSIzeBound() {
2036 PublishSubject<Integer> ps = PublishSubject.create();
2037
2038 ConnectableObservable<Integer> co = ps.replay(10, 10, TimeUnit.MINUTES, Schedulers.single(), true);
2039
2040 TestObserver<Integer> to = co.test();
2041
2042 Disposable d = co.connect();
2043
2044 ps.onNext(1);
2045
2046 d.dispose();
2047
2048 to = co.test();
2049
2050 to.assertEmpty();
2051
2052 co.connect();
2053
2054 to.assertEmpty();
2055
2056 ps.onNext(2);
2057
2058 to.assertValuesOnly(2);
2059 }
2060 }