Debian Codegraph @

src/test/java/io/reactivex/rxjava3/subjects/ReplaySubjectTest.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.subjects;
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.Arrays;
22 import java.util.concurrent.*;
23 import java.util.concurrent.atomic.*;
24
25 import org.junit.*;
26 import org.mockito.*;
27
28 import io.reactivex.rxjava3.core.*;
29 import io.reactivex.rxjava3.disposables.*;
30 import io.reactivex.rxjava3.exceptions.TestException;
31 import io.reactivex.rxjava3.functions.*;
32 import io.reactivex.rxjava3.observers.*;
33 import io.reactivex.rxjava3.schedulers.*;
34 import io.reactivex.rxjava3.subjects.ReplaySubject.*;
35 import io.reactivex.rxjava3.testsupport.*;
36
37 public class ReplaySubjectTest extends SubjectTest<Integer> {
38
39 private final Throwable testException = new Throwable();
40
41 @Override
42 protected Subject<Integer> create() {
43 return ReplaySubject.create();
44 }
45
46 @Test
47 @SuppressUndeliverable
48 public void completed() {
49 ReplaySubject<String> subject = ReplaySubject.create();
50
51 Observer<String> o1 = TestHelper.mockObserver();
52 subject.subscribe(o1);
53
54 subject.onNext("one");
55 subject.onNext("two");
56 subject.onNext("three");
57 subject.onComplete();
58
59 subject.onNext("four");
60 subject.onComplete();
61 subject.onError(new Throwable());
62
63 assertCompletedSubscriber(o1);
64
65 // assert that subscribing a 2nd time gets the same data
66 Observer<String> o2 = TestHelper.mockObserver();
67 subject.subscribe(o2);
68 assertCompletedSubscriber(o2);
69 }
70
71 @Test
72 @SuppressUndeliverable
73 public void completedStopsEmittingData() {
74 ReplaySubject<Integer> channel = ReplaySubject.create();
75 Observer<Object> observerA = TestHelper.mockObserver();
76 Observer<Object> observerB = TestHelper.mockObserver();
77 Observer<Object> observerC = TestHelper.mockObserver();
78 Observer<Object> observerD = TestHelper.mockObserver();
79 TestObserver<Object> to = new TestObserver<>(observerA);
80
81 channel.subscribe(to);
82 channel.subscribe(observerB);
83
84 InOrder inOrderA = inOrder(observerA);
85 InOrder inOrderB = inOrder(observerB);
86 InOrder inOrderC = inOrder(observerC);
87 InOrder inOrderD = inOrder(observerD);
88
89 channel.onNext(42);
90
91 // both A and B should have received 42 from before subscription
92 inOrderA.verify(observerA).onNext(42);
93 inOrderB.verify(observerB).onNext(42);
94
95 to.dispose();
96
97 // a should receive no more
98 inOrderA.verifyNoMoreInteractions();
99
100 channel.onNext(4711);
101
102 // only be should receive 4711 at this point
103 inOrderB.verify(observerB).onNext(4711);
104
105 channel.onComplete();
106
107 // B is subscribed so should receive onComplete
108 inOrderB.verify(observerB).onComplete();
109
110 channel.subscribe(observerC);
111
112 // when C subscribes it should receive 42, 4711, onComplete
113 inOrderC.verify(observerC).onNext(42);
114 inOrderC.verify(observerC).onNext(4711);
115 inOrderC.verify(observerC).onComplete();
116
117 // if further events are propagated they should be ignored
118 channel.onNext(13);
119 channel.onNext(14);
120 channel.onNext(15);
121 channel.onError(new RuntimeException());
122
123 // a new subscription should only receive what was emitted prior to terminal state onComplete
124 channel.subscribe(observerD);
125
126 inOrderD.verify(observerD).onNext(42);
127 inOrderD.verify(observerD).onNext(4711);
128 inOrderD.verify(observerD).onComplete();
129
130 verify(observerA).onSubscribe((Disposable)notNull());
131 verify(observerB).onSubscribe((Disposable)notNull());
132 verify(observerC).onSubscribe((Disposable)notNull());
133 verify(observerD).onSubscribe((Disposable)notNull());
134 Mockito.verifyNoMoreInteractions(observerA);
135 Mockito.verifyNoMoreInteractions(observerB);
136 Mockito.verifyNoMoreInteractions(observerC);
137 Mockito.verifyNoMoreInteractions(observerD);
138
139 }
140
141 @Test
142 @SuppressUndeliverable
143 public void completedAfterError() {
144 ReplaySubject<String> subject = ReplaySubject.create();
145
146 Observer<String> observer = TestHelper.mockObserver();
147
148 subject.onNext("one");
149 subject.onError(testException);
150 subject.onNext("two");
151 subject.onComplete();
152 subject.onError(new RuntimeException());
153
154 subject.subscribe(observer);
155 verify(observer).onSubscribe((Disposable)notNull());
156 verify(observer, times(1)).onNext("one");
157 verify(observer, times(1)).onError(testException);
158 verifyNoMoreInteractions(observer);
159 }
160
161 private void assertCompletedSubscriber(Observer<String> observer) {
162 InOrder inOrder = inOrder(observer);
163
164 inOrder.verify(observer, times(1)).onNext("one");
165 inOrder.verify(observer, times(1)).onNext("two");
166 inOrder.verify(observer, times(1)).onNext("three");
167 inOrder.verify(observer, Mockito.never()).onError(any(Throwable.class));
168 inOrder.verify(observer, times(1)).onComplete();
169 inOrder.verifyNoMoreInteractions();
170 }
171
172 @Test
173 @SuppressUndeliverable
174 public void error() {
175 ReplaySubject<String> subject = ReplaySubject.create();
176
177 Observer<String> observer = TestHelper.mockObserver();
178 subject.subscribe(observer);
179
180 subject.onNext("one");
181 subject.onNext("two");
182 subject.onNext("three");
183 subject.onError(testException);
184
185 subject.onNext("four");
186 subject.onError(new Throwable());
187 subject.onComplete();
188
189 assertErrorSubscriber(observer);
190
191 observer = TestHelper.mockObserver();
192 subject.subscribe(observer);
193 assertErrorSubscriber(observer);
194 }
195
196 private void assertErrorSubscriber(Observer<String> observer) {
197 verify(observer, times(1)).onNext("one");
198 verify(observer, times(1)).onNext("two");
199 verify(observer, times(1)).onNext("three");
200 verify(observer, times(1)).onError(testException);
201 verify(observer, Mockito.never()).onComplete();
202 }
203
204 @Test
205 public void subscribeMidSequence() {
206 ReplaySubject<String> subject = ReplaySubject.create();
207
208 Observer<String> observer = TestHelper.mockObserver();
209 subject.subscribe(observer);
210
211 subject.onNext("one");
212 subject.onNext("two");
213
214 assertObservedUntilTwo(observer);
215
216 Observer<String> anotherSubscriber = TestHelper.mockObserver();
217 subject.subscribe(anotherSubscriber);
218 assertObservedUntilTwo(anotherSubscriber);
219
220 subject.onNext("three");
221 subject.onComplete();
222
223 assertCompletedSubscriber(observer);
224 assertCompletedSubscriber(anotherSubscriber);
225 }
226
227 @Test
228 public void unsubscribeFirstSubscriber() {
229 ReplaySubject<String> subject = ReplaySubject.create();
230
231 Observer<String> observer = TestHelper.mockObserver();
232 TestObserver<String> to = new TestObserver<>(observer);
233 subject.subscribe(to);
234
235 subject.onNext("one");
236 subject.onNext("two");
237
238 to.dispose();
239 assertObservedUntilTwo(observer);
240
241 Observer<String> anotherSubscriber = TestHelper.mockObserver();
242 subject.subscribe(anotherSubscriber);
243 assertObservedUntilTwo(anotherSubscriber);
244
245 subject.onNext("three");
246 subject.onComplete();
247
248 assertObservedUntilTwo(observer);
249 assertCompletedSubscriber(anotherSubscriber);
250 }
251
252 private void assertObservedUntilTwo(Observer<String> observer) {
253 verify(observer, times(1)).onNext("one");
254 verify(observer, times(1)).onNext("two");
255 verify(observer, Mockito.never()).onNext("three");
256 verify(observer, Mockito.never()).onError(any(Throwable.class));
257 verify(observer, Mockito.never()).onComplete();
258 }
259
260 @Test
261 public void newSubscriberDoesntBlockExisting() throws InterruptedException {
262
263 final AtomicReference<String> lastValueForSubscriber1 = new AtomicReference<>();
264 Observer<String> observer1 = new DefaultObserver<String>() {
265
266 @Override
267 public void onComplete() {
268
269 }
270
271 @Override
272 public void onError(Throwable e) {
273
274 }
275
276 @Override
277 public void onNext(String v) {
278 System.out.println("observer1: " + v);
279 lastValueForSubscriber1.set(v);
280 }
281
282 };
283
284 final AtomicReference<String> lastValueForSubscriber2 = new AtomicReference<>();
285 final CountDownLatch oneReceived = new CountDownLatch(1);
286 final CountDownLatch makeSlow = new CountDownLatch(1);
287 final CountDownLatch completed = new CountDownLatch(1);
288 Observer<String> observer2 = new DefaultObserver<String>() {
289
290 @Override
291 public void onComplete() {
292 completed.countDown();
293 }
294
295 @Override
296 public void onError(Throwable e) {
297
298 }
299
300 @Override
301 public void onNext(String v) {
302 System.out.println("observer2: " + v);
303 if (v.equals("one")) {
304 oneReceived.countDown();
305 } else {
306 try {
307 makeSlow.await();
308 } catch (InterruptedException e) {
309 e.printStackTrace();
310 }
311 lastValueForSubscriber2.set(v);
312 }
313 }
314
315 };
316
317 ReplaySubject<String> subject = ReplaySubject.create();
318 subject.subscribe(observer1);
319 subject.onNext("one");
320 assertEquals("one", lastValueForSubscriber1.get());
321 subject.onNext("two");
322 assertEquals("two", lastValueForSubscriber1.get());
323
324 // use subscribeOn to make this async otherwise we deadlock as we are using CountDownLatches
325 subject.subscribeOn(Schedulers.newThread()).subscribe(observer2);
326
327 System.out.println("before waiting for one");
328
329 // wait until observer2 starts having replay occur
330 oneReceived.await();
331
332 System.out.println("after waiting for one");
333
334 subject.onNext("three");
335
336 System.out.println("sent three");
337
338 // if subscription blocked existing subscribers then 'makeSlow' would cause this to not be there yet
339 assertEquals("three", lastValueForSubscriber1.get());
340
341 System.out.println("about to send onComplete");
342
343 subject.onComplete();
344
345 System.out.println("completed subject");
346
347 // release
348 makeSlow.countDown();
349
350 System.out.println("makeSlow released");
351
352 completed.await();
353 // all of them should be emitted with the last being "three"
354 assertEquals("three", lastValueForSubscriber2.get());
355
356 }
357
358 @Test
359 public void subscriptionLeak() {
360 ReplaySubject<Object> subject = ReplaySubject.create();
361
362 Disposable d = subject.subscribe();
363
364 assertEquals(1, subject.observerCount());
365
366 d.dispose();
367
368 assertEquals(0, subject.observerCount());
369 }
370
371 @Test
372 public void unsubscriptionCase() {
373 ReplaySubject<String> src = ReplaySubject.create();
374
375 for (int i = 0; i < 10; i++) {
376 final Observer<Object> o = TestHelper.mockObserver();
377 InOrder inOrder = inOrder(o);
378 String v = "" + i;
379 src.onNext(v);
380 System.out.printf("Turn: %d%n", i);
381 src.firstElement()
382 .toObservable()
383 .flatMap(new Function<String, Observable<String>>() {
384
385 @Override
386 public Observable<String> apply(String t1) {
387 return Observable.just(t1 + ", " + t1);
388 }
389 })
390 .subscribe(new DefaultObserver<String>() {
391 @Override
392 public void onNext(String t) {
393 System.out.println(t);
394 o.onNext(t);
395 }
396
397 @Override
398 public void onError(Throwable e) {
399 o.onError(e);
400 }
401
402 @Override
403 public void onComplete() {
404 o.onComplete();
405 }
406 });
407 inOrder.verify(o).onNext("0, 0");
408 inOrder.verify(o).onComplete();
409 verify(o, never()).onError(any(Throwable.class));
410 }
411 }
412
413 @Test
414 public void terminateOnce() {
415 ReplaySubject<Integer> source = ReplaySubject.create();
416 source.onNext(1);
417 source.onNext(2);
418 source.onComplete();
419
420 final Observer<Integer> o = TestHelper.mockObserver();
421
422 source.subscribe(new DefaultObserver<Integer>() {
423
424 @Override
425 public void onNext(Integer t) {
426 o.onNext(t);
427 }
428
429 @Override
430 public void onError(Throwable e) {
431 o.onError(e);
432 }
433
434 @Override
435 public void onComplete() {
436 o.onComplete();
437 }
438 });
439
440 verify(o).onNext(1);
441 verify(o).onNext(2);
442 verify(o).onComplete();
443 verify(o, never()).onError(any(Throwable.class));
444 }
445
446 @Test
447 public void replay1AfterTermination() {
448 ReplaySubject<Integer> source = ReplaySubject.createWithSize(1);
449
450 source.onNext(1);
451 source.onNext(2);
452 source.onComplete();
453
454 for (int i = 0; i < 1; i++) {
455 Observer<Integer> o = TestHelper.mockObserver();
456
457 source.subscribe(o);
458
459 verify(o, never()).onNext(1);
460 verify(o).onNext(2);
461 verify(o).onComplete();
462 verify(o, never()).onError(any(Throwable.class));
463 }
464 }
465
466 @Test
467 public void replay1Directly() {
468 ReplaySubject<Integer> source = ReplaySubject.createWithSize(1);
469
470 Observer<Integer> o = TestHelper.mockObserver();
471
472 source.onNext(1);
473 source.onNext(2);
474
475 source.subscribe(o);
476
477 source.onNext(3);
478 source.onComplete();
479
480 verify(o, never()).onNext(1);
481 verify(o).onNext(2);
482 verify(o).onNext(3);
483 verify(o).onComplete();
484 verify(o, never()).onError(any(Throwable.class));
485 }
486
487 @Test
488 public void replayTimestampedAfterTermination() {
489 TestScheduler scheduler = new TestScheduler();
490 ReplaySubject<Integer> source = ReplaySubject.createWithTime(1, TimeUnit.SECONDS, scheduler);
491
492 source.onNext(1);
493
494 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
495
496 source.onNext(2);
497
498 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
499
500 source.onNext(3);
501 source.onComplete();
502
503 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
504
505 Observer<Integer> o = TestHelper.mockObserver();
506
507 source.subscribe(o);
508
509 verify(o, never()).onNext(1);
510 verify(o, never()).onNext(2);
511 verify(o, never()).onNext(3);
512 verify(o).onComplete();
513 verify(o, never()).onError(any(Throwable.class));
514 }
515
516 @Test
517 public void replayTimestampedDirectly() {
518 TestScheduler scheduler = new TestScheduler();
519 ReplaySubject<Integer> source = ReplaySubject.createWithTime(1, TimeUnit.SECONDS, scheduler);
520
521 source.onNext(1);
522
523 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
524
525 Observer<Integer> o = TestHelper.mockObserver();
526
527 source.subscribe(o);
528
529 source.onNext(2);
530
531 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
532
533 source.onNext(3);
534
535 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
536
537 source.onComplete();
538
539 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
540
541 verify(o, never()).onError(any(Throwable.class));
542 verify(o, never()).onNext(1);
543 verify(o).onNext(2);
544 verify(o).onNext(3);
545 verify(o).onComplete();
546 }
547
548 @Test
549 public void currentStateMethodsNormal() {
550 ReplaySubject<Object> as = ReplaySubject.create();
551
552 assertFalse(as.hasThrowable());
553 assertFalse(as.hasComplete());
554 assertNull(as.getThrowable());
555
556 as.onNext(1);
557
558 assertFalse(as.hasThrowable());
559 assertFalse(as.hasComplete());
560 assertNull(as.getThrowable());
561
562 as.onComplete();
563
564 assertFalse(as.hasThrowable());
565 assertTrue(as.hasComplete());
566 assertNull(as.getThrowable());
567 }
568
569 @Test
570 public void currentStateMethodsEmpty() {
571 ReplaySubject<Object> as = ReplaySubject.create();
572
573 assertFalse(as.hasThrowable());
574 assertFalse(as.hasComplete());
575 assertNull(as.getThrowable());
576
577 as.onComplete();
578
579 assertFalse(as.hasThrowable());
580 assertTrue(as.hasComplete());
581 assertNull(as.getThrowable());
582 }
583
584 @Test
585 public void currentStateMethodsError() {
586 ReplaySubject<Object> as = ReplaySubject.create();
587
588 assertFalse(as.hasThrowable());
589 assertFalse(as.hasComplete());
590 assertNull(as.getThrowable());
591
592 as.onError(new TestException());
593
594 assertTrue(as.hasThrowable());
595 assertFalse(as.hasComplete());
596 assertTrue(as.getThrowable() instanceof TestException);
597 }
598
599 @Test
600 public void sizeAndHasAnyValueUnbounded() {
601 ReplaySubject<Object> rs = ReplaySubject.create();
602
603 assertEquals(0, rs.size());
604 assertFalse(rs.hasValue());
605
606 rs.onNext(1);
607
608 assertEquals(1, rs.size());
609 assertTrue(rs.hasValue());
610
611 rs.onNext(1);
612
613 assertEquals(2, rs.size());
614 assertTrue(rs.hasValue());
615
616 rs.onComplete();
617
618 assertEquals(2, rs.size());
619 assertTrue(rs.hasValue());
620 }
621
622 @Test
623 public void sizeAndHasAnyValueEffectivelyUnbounded() {
624 ReplaySubject<Object> rs = ReplaySubject.createUnbounded();
625
626 assertEquals(0, rs.size());
627 assertFalse(rs.hasValue());
628
629 rs.onNext(1);
630
631 assertEquals(1, rs.size());
632 assertTrue(rs.hasValue());
633
634 rs.onNext(1);
635
636 assertEquals(2, rs.size());
637 assertTrue(rs.hasValue());
638
639 rs.onComplete();
640
641 assertEquals(2, rs.size());
642 assertTrue(rs.hasValue());
643 }
644
645 @Test
646 public void sizeAndHasAnyValueUnboundedError() {
647 ReplaySubject<Object> rs = ReplaySubject.create();
648
649 assertEquals(0, rs.size());
650 assertFalse(rs.hasValue());
651
652 rs.onNext(1);
653
654 assertEquals(1, rs.size());
655 assertTrue(rs.hasValue());
656
657 rs.onNext(1);
658
659 assertEquals(2, rs.size());
660 assertTrue(rs.hasValue());
661
662 rs.onError(new TestException());
663
664 assertEquals(2, rs.size());
665 assertTrue(rs.hasValue());
666 }
667
668 @Test
669 public void sizeAndHasAnyValueEffectivelyUnboundedError() {
670 ReplaySubject<Object> rs = ReplaySubject.createUnbounded();
671
672 assertEquals(0, rs.size());
673 assertFalse(rs.hasValue());
674
675 rs.onNext(1);
676
677 assertEquals(1, rs.size());
678 assertTrue(rs.hasValue());
679
680 rs.onNext(1);
681
682 assertEquals(2, rs.size());
683 assertTrue(rs.hasValue());
684
685 rs.onError(new TestException());
686
687 assertEquals(2, rs.size());
688 assertTrue(rs.hasValue());
689 }
690
691 @Test
692 public void sizeAndHasAnyValueUnboundedEmptyError() {
693 ReplaySubject<Object> rs = ReplaySubject.create();
694
695 rs.onError(new TestException());
696
697 assertEquals(0, rs.size());
698 assertFalse(rs.hasValue());
699 }
700
701 @Test
702 public void sizeAndHasAnyValueEffectivelyUnboundedEmptyError() {
703 ReplaySubject<Object> rs = ReplaySubject.createUnbounded();
704
705 rs.onError(new TestException());
706
707 assertEquals(0, rs.size());
708 assertFalse(rs.hasValue());
709 }
710
711 @Test
712 public void sizeAndHasAnyValueUnboundedEmptyCompleted() {
713 ReplaySubject<Object> rs = ReplaySubject.create();
714
715 rs.onComplete();
716
717 assertEquals(0, rs.size());
718 assertFalse(rs.hasValue());
719 }
720
721 @Test
722 public void sizeAndHasAnyValueEffectivelyUnboundedEmptyCompleted() {
723 ReplaySubject<Object> rs = ReplaySubject.createUnbounded();
724
725 rs.onComplete();
726
727 assertEquals(0, rs.size());
728 assertFalse(rs.hasValue());
729 }
730
731 @Test
732 public void sizeAndHasAnyValueSizeBounded() {
733 ReplaySubject<Object> rs = ReplaySubject.createWithSize(1);
734
735 assertEquals(0, rs.size());
736 assertFalse(rs.hasValue());
737
738 for (int i = 0; i < 1000; i++) {
739 rs.onNext(i);
740
741 assertEquals(1, rs.size());
742 assertTrue(rs.hasValue());
743 }
744
745 rs.onComplete();
746
747 assertEquals(1, rs.size());
748 assertTrue(rs.hasValue());
749 }
750
751 @Test
752 public void sizeAndHasAnyValueTimeBounded() {
753 TestScheduler to = new TestScheduler();
754 ReplaySubject<Object> rs = ReplaySubject.createWithTime(1, TimeUnit.SECONDS, to);
755
756 assertEquals(0, rs.size());
757 assertFalse(rs.hasValue());
758
759 for (int i = 0; i < 1000; i++) {
760 rs.onNext(i);
761 assertEquals(1, rs.size());
762 assertTrue(rs.hasValue());
763 to.advanceTimeBy(2, TimeUnit.SECONDS);
764 assertEquals(0, rs.size());
765 assertFalse(rs.hasValue());
766 }
767
768 rs.onComplete();
769
770 assertEquals(0, rs.size());
771 assertFalse(rs.hasValue());
772 }
773
774 @Test
775 public void getValues() {
776 ReplaySubject<Object> rs = ReplaySubject.create();
777 Object[] expected = new Object[10];
778 for (int i = 0; i < expected.length; i++) {
779 expected[i] = i;
780 rs.onNext(i);
781 assertArrayEquals(Arrays.copyOf(expected, i + 1), rs.getValues());
782 }
783 rs.onComplete();
784
785 assertArrayEquals(expected, rs.getValues());
786
787 }
788
789 @Test
790 public void getValuesUnbounded() {
791 ReplaySubject<Object> rs = ReplaySubject.createUnbounded();
792 Object[] expected = new Object[10];
793 for (int i = 0; i < expected.length; i++) {
794 expected[i] = i;
795 rs.onNext(i);
796 assertArrayEquals(Arrays.copyOf(expected, i + 1), rs.getValues());
797 }
798 rs.onComplete();
799
800 assertArrayEquals(expected, rs.getValues());
801
802 }
803
804 @Test
805 public void createInvalidCapacity() {
806 try {
807 ReplaySubject.create(-99);
808 fail("Didn't throw IllegalArgumentException");
809 } catch (IllegalArgumentException ex) {
810 assertEquals("capacityHint > 0 required but it was -99", ex.getMessage());
811 }
812 }
813
814 @Test
815 public void createWithSizeInvalidCapacity() {
816 try {
817 ReplaySubject.createWithSize(-99);
818 fail("Didn't throw IllegalArgumentException");
819 } catch (IllegalArgumentException ex) {
820 assertEquals("maxSize > 0 required but it was -99", ex.getMessage());
821 }
822 }
823
824 @Test
825 public void createWithTimeAndSizeInvalidCapacity() {
826 try {
827 ReplaySubject.createWithTimeAndSize(1, TimeUnit.DAYS, Schedulers.computation(), -99);
828 fail("Didn't throw IllegalArgumentException");
829 } catch (IllegalArgumentException ex) {
830 assertEquals("maxSize > 0 required but it was -99", ex.getMessage());
831 }
832 }
833
834 @Test
835 public void hasSubscribers() {
836 ReplaySubject<Integer> rp = ReplaySubject.create();
837
838 assertFalse(rp.hasObservers());
839
840 TestObserver<Integer> to = rp.test();
841
842 assertTrue(rp.hasObservers());
843
844 to.dispose();
845
846 assertFalse(rp.hasObservers());
847 }
848
849 @Test
850 public void peekStateUnbounded() {
851 ReplaySubject<Integer> rp = ReplaySubject.create();
852
853 rp.onNext(1);
854
855 assertEquals((Integer)1, rp.getValue());
856
857 assertEquals(1, rp.getValues()[0]);
858 }
859
860 @Test
861 public void peekStateTimeAndSize() {
862 ReplaySubject<Integer> rp = ReplaySubject.createWithTimeAndSize(1, TimeUnit.DAYS, Schedulers.computation(), 1);
863
864 rp.onNext(1);
865
866 assertEquals((Integer)1, rp.getValue());
867
868 assertEquals(1, rp.getValues()[0]);
869
870 rp.onNext(2);
871
872 assertEquals((Integer)2, rp.getValue());
873
874 assertEquals(2, rp.getValues()[0]);
875
876 assertEquals((Integer)2, rp.getValues(new Integer[0])[0]);
877
878 assertEquals((Integer)2, rp.getValues(new Integer[1])[0]);
879
880 Integer[] a = new Integer[2];
881 assertEquals((Integer)2, rp.getValues(a)[0]);
882 assertNull(a[1]);
883 }
884
885 @Test
886 public void peekStateTimeAndSizeValue() {
887 ReplaySubject<Integer> rp = ReplaySubject.createWithTimeAndSize(1, TimeUnit.DAYS, Schedulers.computation(), 1);
888
889 assertNull(rp.getValue());
890
891 assertEquals(0, rp.getValues().length);
892
893 assertNull(rp.getValues(new Integer[2])[0]);
894
895 rp.onComplete();
896
897 assertNull(rp.getValue());
898
899 assertEquals(0, rp.getValues().length);
900
901 assertNull(rp.getValues(new Integer[2])[0]);
902
903 rp = ReplaySubject.createWithTimeAndSize(1, TimeUnit.DAYS, Schedulers.computation(), 1);
904 rp.onError(new TestException());
905
906 assertNull(rp.getValue());
907
908 assertEquals(0, rp.getValues().length);
909
910 assertNull(rp.getValues(new Integer[2])[0]);
911 }
912
913 @Test
914 public void peekStateTimeAndSizeValueExpired() {
915 TestScheduler scheduler = new TestScheduler();
916 ReplaySubject<Integer> rp = ReplaySubject.createWithTime(1, TimeUnit.DAYS, scheduler);
917
918 assertNull(rp.getValue());
919 assertNull(rp.getValues(new Integer[2])[0]);
920
921 rp.onNext(2);
922
923 assertEquals((Integer)2, rp.getValue());
924 assertEquals(2, rp.getValues()[0]);
925
926 scheduler.advanceTimeBy(2, TimeUnit.DAYS);
927
928 assertNull(rp.getValue());
929 assertEquals(0, rp.getValues().length);
930 assertNull(rp.getValues(new Integer[2])[0]);
931 }
932
933 @Test
934 public void capacityHint() {
935 ReplaySubject<Integer> rp = ReplaySubject.create(8);
936
937 for (int i = 0; i < 15; i++) {
938 rp.onNext(i);
939 }
940 rp.onComplete();
941
942 rp.test().assertResult(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14);
943 }
944
945 @Test
946 public void subscribeCancelRace() {
947 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
948 final TestObserver<Integer> to = new TestObserver<>();
949
950 final ReplaySubject<Integer> rp = ReplaySubject.create();
951
952 Runnable r1 = new Runnable() {
953 @Override
954 public void run() {
955 rp.subscribe(to);
956 }
957 };
958
959 Runnable r2 = new Runnable() {
960 @Override
961 public void run() {
962 to.dispose();
963 }
964 };
965
966 TestHelper.race(r1, r2);
967 }
968 }
969
970 @Test
971 public void subscribeAfterDone() {
972 ReplaySubject<Integer> rp = ReplaySubject.create();
973 rp.onComplete();
974
975 Disposable bs = Disposable.empty();
976
977 rp.onSubscribe(bs);
978
979 assertTrue(bs.isDisposed());
980 }
981
982 @Test
983 public void subscribeRace() {
984 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
985 final ReplaySubject<Integer> rp = ReplaySubject.create();
986
987 Runnable r1 = new Runnable() {
988 @Override
989 public void run() {
990 rp.test();
991 }
992 };
993
994 TestHelper.race(r1, r1);
995 }
996 }
997
998 @Test
999 public void cancelUpfront() {
1000 ReplaySubject<Integer> rp = ReplaySubject.create();
1001 rp.test();
1002 rp.test();
1003
1004 TestObserver<Integer> to = rp.test(true);
1005
1006 assertEquals(2, rp.observerCount());
1007
1008 to.assertEmpty();
1009 }
1010
1011 @Test
1012 public void cancelRace() {
1013 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
1014
1015 final ReplaySubject<Integer> rp = ReplaySubject.create();
1016 final TestObserver<Integer> to1 = rp.test();
1017 final TestObserver<Integer> to2 = rp.test();
1018
1019 Runnable r1 = new Runnable() {
1020 @Override
1021 public void run() {
1022 to1.dispose();
1023 }
1024 };
1025
1026 Runnable r2 = new Runnable() {
1027 @Override
1028 public void run() {
1029 to2.dispose();
1030 }
1031 };
1032
1033 TestHelper.race(r1, r2);
1034
1035 assertFalse(rp.hasObservers());
1036 }
1037 }
1038
1039 @Test
1040 public void sizeboundReplayError() {
1041 ReplaySubject<Integer> rp = ReplaySubject.createWithSize(2);
1042
1043 rp.onNext(1);
1044 rp.onNext(2);
1045 rp.onNext(3);
1046 rp.onNext(4);
1047 rp.onError(new TestException());
1048
1049 rp.test()
1050 .assertFailure(TestException.class, 3, 4);
1051 }
1052
1053 @Test
1054 public void sizeAndTimeBoundReplayError() {
1055 ReplaySubject<Integer> rp = ReplaySubject.createWithTimeAndSize(1, TimeUnit.DAYS, Schedulers.single(), 2);
1056
1057 rp.onNext(1);
1058 rp.onNext(2);
1059 rp.onNext(3);
1060 rp.onNext(4);
1061 rp.onError(new TestException());
1062
1063 rp.test()
1064 .assertFailure(TestException.class, 3, 4);
1065 }
1066
1067 @Test
1068 public void timedSkipOld() {
1069 TestScheduler scheduler = new TestScheduler();
1070
1071 ReplaySubject<Integer> rp = ReplaySubject.createWithTimeAndSize(1, TimeUnit.SECONDS, scheduler, 2);
1072
1073 rp.onNext(1);
1074 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
1075
1076 rp.test()
1077 .assertEmpty();
1078 }
1079
1080 @Test
1081 public void takeSizeAndTime() {
1082 TestScheduler scheduler = new TestScheduler();
1083
1084 ReplaySubject<Integer> rp = ReplaySubject.createWithTimeAndSize(1, TimeUnit.SECONDS, scheduler, 2);
1085
1086 rp.onNext(1);
1087 rp.onNext(2);
1088 rp.onNext(3);
1089
1090 rp
1091 .take(1)
1092 .test()
1093 .assertResult(2);
1094 }
1095
1096 @Test
1097 public void takeSize() {
1098 ReplaySubject<Integer> rp = ReplaySubject.createWithSize(2);
1099
1100 rp.onNext(1);
1101 rp.onNext(2);
1102 rp.onNext(3);
1103
1104 rp
1105 .take(1)
1106 .test()
1107 .assertResult(2);
1108 }
1109
1110 @Test
1111 public void reentrantDrain() {
1112 TestScheduler scheduler = new TestScheduler();
1113
1114 final ReplaySubject<Integer> rp = ReplaySubject.createWithTimeAndSize(1, TimeUnit.SECONDS, scheduler, 2);
1115
1116 TestObserver<Integer> to = new TestObserver<Integer>() {
1117 @Override
1118 public void onNext(Integer t) {
1119 if (t == 1) {
1120 rp.onNext(2);
1121 }
1122 super.onNext(t);
1123 }
1124 };
1125
1126 rp.subscribe(to);
1127
1128 rp.onNext(1);
1129 rp.onComplete();
1130
1131 to.assertResult(1, 2);
1132 }
1133
1134 @Test
1135 public void dispose() {
1136 TestHelper.checkDisposed(ReplaySubject.create());
1137
1138 TestHelper.checkDisposed(ReplaySubject.createUnbounded());
1139
1140 TestHelper.checkDisposed(ReplaySubject.createWithSize(10));
1141
1142 TestHelper.checkDisposed(ReplaySubject.createWithTimeAndSize(1, TimeUnit.SECONDS, Schedulers.single(), 10));
1143 }
1144
1145 @Test
1146 public void timedNoOutdatedData() {
1147 TestScheduler scheduler = new TestScheduler();
1148
1149 ReplaySubject<Integer> source = ReplaySubject.createWithTime(2, TimeUnit.SECONDS, scheduler);
1150 source.onNext(1);
1151 source.onComplete();
1152
1153 source.test().assertResult(1);
1154
1155 source.test().assertResult(1);
1156
1157 scheduler.advanceTimeBy(3, TimeUnit.SECONDS);
1158
1159 source.test().assertResult();
1160 }
1161
1162 @Test
1163 public void noHeadRetentionCompleteSize() {
1164 ReplaySubject<Integer> source = ReplaySubject.createWithSize(1);
1165
1166 source.onNext(1);
1167 source.onNext(2);
1168 source.onComplete();
1169
1170 SizeBoundReplayBuffer<Integer> buf = (SizeBoundReplayBuffer<Integer>)source.buffer;
1171
1172 assertNull(buf.head.value);
1173
1174 Object o = buf.head;
1175
1176 source.cleanupBuffer();
1177
1178 assertSame(o, buf.head);
1179 }
1180
1181 @Test
1182 public void noHeadRetentionSize() {
1183 ReplaySubject<Integer> source = ReplaySubject.createWithSize(1);
1184
1185 source.onNext(1);
1186 source.onNext(2);
1187
1188 SizeBoundReplayBuffer<Integer> buf = (SizeBoundReplayBuffer<Integer>)source.buffer;
1189
1190 assertNotNull(buf.head.value);
1191
1192 source.cleanupBuffer();
1193
1194 assertNull(buf.head.value);
1195
1196 Object o = buf.head;
1197
1198 source.cleanupBuffer();
1199
1200 assertSame(o, buf.head);
1201 }
1202
1203 @Test
1204 public void noHeadRetentionCompleteTime() {
1205 ReplaySubject<Integer> source = ReplaySubject.createWithTime(1, TimeUnit.MINUTES, Schedulers.computation());
1206
1207 source.onNext(1);
1208 source.onNext(2);
1209 source.onComplete();
1210
1211 SizeAndTimeBoundReplayBuffer<Integer> buf = (SizeAndTimeBoundReplayBuffer<Integer>)source.buffer;
1212
1213 assertNull(buf.head.value);
1214
1215 Object o = buf.head;
1216
1217 source.cleanupBuffer();
1218
1219 assertSame(o, buf.head);
1220 }
1221
1222 @Test
1223 public void noHeadRetentionTime() {
1224 TestScheduler sch = new TestScheduler();
1225
1226 ReplaySubject<Integer> source = ReplaySubject.createWithTime(1, TimeUnit.MILLISECONDS, sch);
1227
1228 source.onNext(1);
1229
1230 sch.advanceTimeBy(2, TimeUnit.MILLISECONDS);
1231
1232 source.onNext(2);
1233
1234 SizeAndTimeBoundReplayBuffer<Integer> buf = (SizeAndTimeBoundReplayBuffer<Integer>)source.buffer;
1235
1236 assertNotNull(buf.head.value);
1237
1238 source.cleanupBuffer();
1239
1240 assertNull(buf.head.value);
1241
1242 Object o = buf.head;
1243
1244 source.cleanupBuffer();
1245
1246 assertSame(o, buf.head);
1247 }
1248
1249 @Test
1250 public void noBoundedRetentionViaThreadLocal() throws Exception {
1251 final ReplaySubject<byte[]> rs = ReplaySubject.createWithSize(1);
1252
1253 Observable<byte[]> source = rs.take(1)
1254 .concatMap(new Function<byte[], Observable<byte[]>>() {
1255 @Override
1256 public Observable<byte[]> apply(byte[] v) throws Exception {
1257 return rs;
1258 }
1259 })
1260 .takeLast(1)
1261 ;
1262
1263 System.out.println("Bounded Replay Leak check: Wait before GC");
1264 Thread.sleep(1000);
1265
1266 System.out.println("Bounded Replay Leak check: GC");
1267 System.gc();
1268
1269 Thread.sleep(500);
1270
1271 final MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
1272 MemoryUsage memHeap = memoryMXBean.getHeapMemoryUsage();
1273 long initial = memHeap.getUsed();
1274
1275 System.out.printf("Bounded Replay Leak check: Starting: %.3f MB%n", initial / 1024.0 / 1024.0);
1276
1277 final AtomicLong after = new AtomicLong();
1278
1279 source.subscribe(new Consumer<byte[]>() {
1280 @Override
1281 public void accept(byte[] v) throws Exception {
1282 System.out.println("Bounded Replay Leak check: Wait before GC 2");
1283 Thread.sleep(1000);
1284
1285 System.out.println("Bounded Replay Leak check: GC 2");
1286 System.gc();
1287
1288 Thread.sleep(500);
1289
1290 after.set(memoryMXBean.getHeapMemoryUsage().getUsed());
1291 }
1292 });
1293
1294 for (int i = 0; i < 200; i++) {
1295 rs.onNext(new byte[1024 * 1024]);
1296 }
1297 rs.onComplete();
1298
1299 System.out.printf("Bounded Replay Leak check: After: %.3f MB%n", after.get() / 1024.0 / 1024.0);
1300
1301 if (initial + 100 * 1024 * 1024 < after.get()) {
1302 Assert.fail("Bounded Replay Leak check: Memory leak detected: " + (initial / 1024.0 / 1024.0)
1303 + " -> " + after.get() / 1024.0 / 1024.0);
1304 }
1305 }
1306
1307 @Test
1308 public void timeAndSizeNoTerminalTruncationOnTimechange() {
1309 ReplaySubject<Integer> rs = ReplaySubject.createWithTimeAndSize(1, TimeUnit.SECONDS, new TimesteppingScheduler(), 1);
1310
1311 TestObserver<Integer> to = rs.test();
1312
1313 rs.onNext(1);
1314 rs.cleanupBuffer();
1315 rs.onComplete();
1316
1317 to.assertNoErrors()
1318 .assertComplete();
1319 }
1320
1321 @Test
1322 public void timeAndSizeNoTerminalTruncationOnTimechange2() {
1323 ReplaySubject<Integer> rs = ReplaySubject.createWithTimeAndSize(1, TimeUnit.SECONDS, new TimesteppingScheduler(), 1);
1324
1325 TestObserver<Integer> to = rs.test();
1326
1327 rs.onNext(1);
1328 rs.cleanupBuffer();
1329 rs.onNext(2);
1330 rs.cleanupBuffer();
1331 rs.onComplete();
1332
1333 to.assertNoErrors()
1334 .assertComplete();
1335 }
1336
1337 @Test
1338 public void timeAndSizeNoTerminalTruncationOnTimechange3() {
1339 ReplaySubject<Integer> rs = ReplaySubject.createWithTimeAndSize(1, TimeUnit.SECONDS, new TimesteppingScheduler(), 1);
1340
1341 TestObserver<Integer> to = rs.test();
1342
1343 rs.onNext(1);
1344 rs.onNext(2);
1345 rs.onComplete();
1346
1347 to.assertNoErrors()
1348 .assertComplete();
1349 }
1350
1351 @Test
1352 public void timeAndSizeNoTerminalTruncationOnTimechange4() {
1353 ReplaySubject<Integer> rs = ReplaySubject.createWithTimeAndSize(1, TimeUnit.SECONDS, new TimesteppingScheduler(), 10);
1354
1355 TestObserver<Integer> to = rs.test();
1356
1357 rs.onNext(1);
1358 rs.onNext(2);
1359 rs.onComplete();
1360
1361 to.assertNoErrors()
1362 .assertComplete();
1363 }
1364
1365 @Test
1366 public void timeAndSizeRemoveCorrectNumberOfOld() {
1367 TestScheduler scheduler = new TestScheduler();
1368 ReplaySubject<Integer> rs = ReplaySubject.createWithTimeAndSize(1, TimeUnit.SECONDS, scheduler, 2);
1369
1370 rs.onNext(1);
1371 rs.onNext(2);
1372 rs.onNext(3); // remove 1 due to maxSize, size == 2
1373
1374 scheduler.advanceTimeBy(2, TimeUnit.SECONDS);
1375
1376 rs.onNext(4); // remove 2 due to maxSize, remove 3 due to age, size == 1
1377 rs.onNext(5); // size == 2
1378
1379 rs.test().assertValuesOnly(4, 5);
1380 }
1381 }