Debian Codegraph @

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