Debian Codegraph @

src/test/java/io/reactivex/rxjava3/subjects/BehaviorSubjectTest.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.any;
18 import static org.mockito.Mockito.*;
19
20 import java.util.List;
21 import java.util.concurrent.*;
22 import java.util.concurrent.atomic.AtomicReference;
23
24 import org.junit.*;
25 import org.mockito.*;
26
27 import io.reactivex.rxjava3.core.*;
28 import io.reactivex.rxjava3.disposables.*;
29 import io.reactivex.rxjava3.exceptions.TestException;
30 import io.reactivex.rxjava3.functions.Function;
31 import io.reactivex.rxjava3.observers.*;
32 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
33 import io.reactivex.rxjava3.schedulers.Schedulers;
34 import io.reactivex.rxjava3.subjects.BehaviorSubject.BehaviorDisposable;
35 import io.reactivex.rxjava3.testsupport.TestHelper;
36
37 public class BehaviorSubjectTest extends SubjectTest<Integer> {
38
39 private final Throwable testException = new Throwable();
40
41 @Override
42 protected Subject<Integer> create() {
43 return BehaviorSubject.create();
44 }
45
46 @Test
47 public void thatSubscriberReceivesDefaultValueAndSubsequentEvents() {
48 BehaviorSubject<String> subject = BehaviorSubject.createDefault("default");
49
50 Observer<String> observer = TestHelper.mockObserver();
51 subject.subscribe(observer);
52
53 subject.onNext("one");
54 subject.onNext("two");
55 subject.onNext("three");
56
57 verify(observer, times(1)).onNext("default");
58 verify(observer, times(1)).onNext("one");
59 verify(observer, times(1)).onNext("two");
60 verify(observer, times(1)).onNext("three");
61 verify(observer, Mockito.never()).onError(testException);
62 verify(observer, Mockito.never()).onComplete();
63 }
64
65 @Test
66 public void thatSubscriberReceivesLatestAndThenSubsequentEvents() {
67 BehaviorSubject<String> subject = BehaviorSubject.createDefault("default");
68
69 subject.onNext("one");
70
71 Observer<String> observer = TestHelper.mockObserver();
72 subject.subscribe(observer);
73
74 subject.onNext("two");
75 subject.onNext("three");
76
77 verify(observer, Mockito.never()).onNext("default");
78 verify(observer, times(1)).onNext("one");
79 verify(observer, times(1)).onNext("two");
80 verify(observer, times(1)).onNext("three");
81 verify(observer, Mockito.never()).onError(testException);
82 verify(observer, Mockito.never()).onComplete();
83 }
84
85 @Test
86 public void subscribeThenOnComplete() {
87 BehaviorSubject<String> subject = BehaviorSubject.createDefault("default");
88
89 Observer<String> observer = TestHelper.mockObserver();
90 subject.subscribe(observer);
91
92 subject.onNext("one");
93 subject.onComplete();
94
95 verify(observer, times(1)).onNext("default");
96 verify(observer, times(1)).onNext("one");
97 verify(observer, Mockito.never()).onError(any(Throwable.class));
98 verify(observer, times(1)).onComplete();
99 }
100
101 @Test
102 public void subscribeToCompletedOnlyEmitsOnComplete() {
103 BehaviorSubject<String> subject = BehaviorSubject.createDefault("default");
104 subject.onNext("one");
105 subject.onComplete();
106
107 Observer<String> observer = TestHelper.mockObserver();
108 subject.subscribe(observer);
109
110 verify(observer, never()).onNext("default");
111 verify(observer, never()).onNext("one");
112 verify(observer, Mockito.never()).onError(any(Throwable.class));
113 verify(observer, times(1)).onComplete();
114 }
115
116 @Test
117 public void subscribeToErrorOnlyEmitsOnError() {
118 BehaviorSubject<String> subject = BehaviorSubject.createDefault("default");
119 subject.onNext("one");
120 RuntimeException re = new RuntimeException("test error");
121 subject.onError(re);
122
123 Observer<String> observer = TestHelper.mockObserver();
124 subject.subscribe(observer);
125
126 verify(observer, never()).onNext("default");
127 verify(observer, never()).onNext("one");
128 verify(observer, times(1)).onError(re);
129 verify(observer, never()).onComplete();
130 }
131
132 @Test
133 public void completedStopsEmittingData() {
134 BehaviorSubject<Integer> channel = BehaviorSubject.createDefault(2013);
135 Observer<Object> observerA = TestHelper.mockObserver();
136 Observer<Object> observerB = TestHelper.mockObserver();
137 Observer<Object> observerC = TestHelper.mockObserver();
138
139 TestObserver<Object> to = new TestObserver<>(observerA);
140
141 channel.subscribe(to);
142 channel.subscribe(observerB);
143
144 InOrder inOrderA = inOrder(observerA);
145 InOrder inOrderB = inOrder(observerB);
146 InOrder inOrderC = inOrder(observerC);
147
148 inOrderA.verify(observerA).onNext(2013);
149 inOrderB.verify(observerB).onNext(2013);
150
151 channel.onNext(42);
152
153 inOrderA.verify(observerA).onNext(42);
154 inOrderB.verify(observerB).onNext(42);
155
156 to.dispose();
157 inOrderA.verifyNoMoreInteractions();
158
159 channel.onNext(4711);
160
161 inOrderB.verify(observerB).onNext(4711);
162
163 channel.onComplete();
164
165 inOrderB.verify(observerB).onComplete();
166
167 channel.subscribe(observerC);
168
169 inOrderC.verify(observerC).onComplete();
170
171 channel.onNext(13);
172
173 inOrderB.verifyNoMoreInteractions();
174 inOrderC.verifyNoMoreInteractions();
175 }
176
177 @Test
178 public void completedAfterErrorIsNotSent() {
179 BehaviorSubject<String> subject = BehaviorSubject.createDefault("default");
180
181 Observer<String> observer = TestHelper.mockObserver();
182 subject.subscribe(observer);
183
184 subject.onNext("one");
185 subject.onError(testException);
186 subject.onNext("two");
187 subject.onComplete();
188
189 verify(observer, times(1)).onNext("default");
190 verify(observer, times(1)).onNext("one");
191 verify(observer, times(1)).onError(testException);
192 verify(observer, never()).onNext("two");
193 verify(observer, never()).onComplete();
194 }
195
196 @Test
197 public void completedAfterErrorIsNotSent2() {
198 BehaviorSubject<String> subject = BehaviorSubject.createDefault("default");
199
200 Observer<String> observer = TestHelper.mockObserver();
201 subject.subscribe(observer);
202
203 subject.onNext("one");
204 subject.onError(testException);
205 subject.onNext("two");
206 subject.onComplete();
207
208 verify(observer, times(1)).onNext("default");
209 verify(observer, times(1)).onNext("one");
210 verify(observer, times(1)).onError(testException);
211 verify(observer, never()).onNext("two");
212 verify(observer, never()).onComplete();
213
214 Observer<Object> o2 = TestHelper.mockObserver();
215 subject.subscribe(o2);
216 verify(o2, times(1)).onError(testException);
217 verify(o2, never()).onNext(any());
218 verify(o2, never()).onComplete();
219 }
220
221 @Test
222 public void completedAfterErrorIsNotSent3() {
223 BehaviorSubject<String> subject = BehaviorSubject.createDefault("default");
224
225 Observer<String> observer = TestHelper.mockObserver();
226 subject.subscribe(observer);
227
228 subject.onNext("one");
229 subject.onComplete();
230 subject.onNext("two");
231 subject.onComplete();
232
233 verify(observer, times(1)).onNext("default");
234 verify(observer, times(1)).onNext("one");
235 verify(observer, times(1)).onComplete();
236 verify(observer, never()).onError(any(Throwable.class));
237 verify(observer, never()).onNext("two");
238
239 Observer<Object> o2 = TestHelper.mockObserver();
240 subject.subscribe(o2);
241 verify(o2, times(1)).onComplete();
242 verify(o2, never()).onNext(any());
243 verify(observer, never()).onError(any(Throwable.class));
244 }
245
246 @Test
247 public void unsubscriptionCase() {
248 BehaviorSubject<String> src = BehaviorSubject.createDefault("null"); // FIXME was plain null which is not allowed
249
250 for (int i = 0; i < 10; i++) {
251 final Observer<Object> o = TestHelper.mockObserver();
252 InOrder inOrder = inOrder(o);
253 String v = "" + i;
254 src.onNext(v);
255 System.out.printf("Turn: %d%n", i);
256 src.firstElement()
257 .toObservable()
258 .flatMap(new Function<String, Observable<String>>() {
259
260 @Override
261 public Observable<String> apply(String t1) {
262 return Observable.just(t1 + ", " + t1);
263 }
264 })
265 .subscribe(new DefaultObserver<String>() {
266 @Override
267 public void onNext(String t) {
268 o.onNext(t);
269 }
270
271 @Override
272 public void onError(Throwable e) {
273 o.onError(e);
274 }
275
276 @Override
277 public void onComplete() {
278 o.onComplete();
279 }
280 });
281 inOrder.verify(o).onNext(v + ", " + v);
282 inOrder.verify(o).onComplete();
283 verify(o, never()).onError(any(Throwable.class));
284 }
285 }
286
287 @Test
288 public void startEmpty() {
289 BehaviorSubject<Integer> source = BehaviorSubject.create();
290 final Observer<Object> o = TestHelper.mockObserver();
291 InOrder inOrder = inOrder(o);
292
293 source.subscribe(o);
294
295 inOrder.verify(o, never()).onNext(any());
296 inOrder.verify(o, never()).onComplete();
297
298 source.onNext(1);
299
300 source.onComplete();
301
302 source.onNext(2);
303
304 verify(o, never()).onError(any(Throwable.class));
305
306 inOrder.verify(o).onNext(1);
307 inOrder.verify(o).onComplete();
308 inOrder.verifyNoMoreInteractions();
309 }
310
311 @Test
312 public void startEmptyThenAddOne() {
313 BehaviorSubject<Integer> source = BehaviorSubject.create();
314 final Observer<Object> o = TestHelper.mockObserver();
315 InOrder inOrder = inOrder(o);
316
317 source.onNext(1);
318
319 source.subscribe(o);
320
321 inOrder.verify(o).onNext(1);
322
323 source.onComplete();
324
325 source.onNext(2);
326
327 inOrder.verify(o).onComplete();
328 inOrder.verifyNoMoreInteractions();
329
330 verify(o, never()).onError(any(Throwable.class));
331
332 }
333
334 @Test
335 public void startEmptyCompleteWithOne() {
336 BehaviorSubject<Integer> source = BehaviorSubject.create();
337 final Observer<Object> o = TestHelper.mockObserver();
338
339 source.onNext(1);
340 source.onComplete();
341
342 source.onNext(2);
343
344 source.subscribe(o);
345
346 verify(o).onComplete();
347 verify(o, never()).onError(any(Throwable.class));
348 verify(o, never()).onNext(any());
349 }
350
351 @Test
352 public void takeOneSubscriber() {
353 BehaviorSubject<Integer> source = BehaviorSubject.createDefault(1);
354 final Observer<Object> o = TestHelper.mockObserver();
355
356 source.take(1).subscribe(o);
357
358 verify(o).onNext(1);
359 verify(o).onComplete();
360 verify(o, never()).onError(any(Throwable.class));
361
362 assertEquals(0, source.subscriberCount());
363 assertFalse(source.hasObservers());
364 }
365
366 @Test
367 public void emissionSubscriptionRace() throws Exception {
368 Scheduler s = Schedulers.io();
369 Scheduler.Worker worker = Schedulers.io().createWorker();
370 try {
371 for (int i = 0; i < 50000; i++) {
372 if (i % 1000 == 0) {
373 System.out.println(i);
374 }
375 final BehaviorSubject<Object> rs = BehaviorSubject.create();
376
377 final CountDownLatch finish = new CountDownLatch(1);
378 final CountDownLatch start = new CountDownLatch(1);
379
380 worker.schedule(new Runnable() {
381 @Override
382 public void run() {
383 try {
384 start.await();
385 } catch (Exception e1) {
386 e1.printStackTrace();
387 }
388 rs.onNext(1);
389 }
390 });
391
392 final AtomicReference<Object> o = new AtomicReference<>();
393
394 rs.subscribeOn(s).observeOn(Schedulers.io())
395 .subscribe(new DefaultObserver<Object>() {
396
397 @Override
398 public void onComplete() {
399 o.set(-1);
400 finish.countDown();
401 }
402
403 @Override
404 public void onError(Throwable e) {
405 o.set(e);
406 finish.countDown();
407 }
408
409 @Override
410 public void onNext(Object t) {
411 o.set(t);
412 finish.countDown();
413 }
414
415 });
416 start.countDown();
417
418 if (!finish.await(5, TimeUnit.SECONDS)) {
419 System.out.println(o.get());
420 System.out.println(rs.hasObservers());
421 rs.onComplete();
422 Assert.fail("Timeout @ " + i);
423 break;
424 } else {
425 Assert.assertEquals(1, o.get());
426 worker.schedule(new Runnable() {
427 @Override
428 public void run() {
429 rs.onComplete();
430 }
431 });
432 }
433 }
434 } finally {
435 worker.dispose();
436 }
437 }
438
439 @Test
440 public void currentStateMethodsNormalEmptyStart() {
441 BehaviorSubject<Object> as = BehaviorSubject.create();
442
443 assertFalse(as.hasValue());
444 assertFalse(as.hasThrowable());
445 assertFalse(as.hasComplete());
446 assertNull(as.getValue());
447 assertNull(as.getThrowable());
448
449 as.onNext(1);
450
451 assertTrue(as.hasValue());
452 assertFalse(as.hasThrowable());
453 assertFalse(as.hasComplete());
454 assertEquals(1, as.getValue());
455 assertNull(as.getThrowable());
456
457 as.onComplete();
458
459 assertFalse(as.hasValue());
460 assertFalse(as.hasThrowable());
461 assertTrue(as.hasComplete());
462 assertNull(as.getValue());
463 assertNull(as.getThrowable());
464 }
465
466 @Test
467 public void currentStateMethodsNormalSomeStart() {
468 BehaviorSubject<Object> as = BehaviorSubject.createDefault((Object)1);
469
470 assertTrue(as.hasValue());
471 assertFalse(as.hasThrowable());
472 assertFalse(as.hasComplete());
473 assertEquals(1, as.getValue());
474 assertNull(as.getThrowable());
475
476 as.onNext(2);
477
478 assertTrue(as.hasValue());
479 assertFalse(as.hasThrowable());
480 assertFalse(as.hasComplete());
481 assertEquals(2, as.getValue());
482 assertNull(as.getThrowable());
483
484 as.onComplete();
485 assertFalse(as.hasValue());
486 assertFalse(as.hasThrowable());
487 assertTrue(as.hasComplete());
488 assertNull(as.getValue());
489 assertNull(as.getThrowable());
490 }
491
492 @Test
493 public void currentStateMethodsEmpty() {
494 BehaviorSubject<Object> as = BehaviorSubject.create();
495
496 assertFalse(as.hasValue());
497 assertFalse(as.hasThrowable());
498 assertFalse(as.hasComplete());
499 assertNull(as.getValue());
500 assertNull(as.getThrowable());
501
502 as.onComplete();
503
504 assertFalse(as.hasValue());
505 assertFalse(as.hasThrowable());
506 assertTrue(as.hasComplete());
507 assertNull(as.getValue());
508 assertNull(as.getThrowable());
509 }
510
511 @Test
512 public void currentStateMethodsError() {
513 BehaviorSubject<Object> as = BehaviorSubject.create();
514
515 assertFalse(as.hasValue());
516 assertFalse(as.hasThrowable());
517 assertFalse(as.hasComplete());
518 assertNull(as.getValue());
519 assertNull(as.getThrowable());
520
521 as.onError(new TestException());
522
523 assertFalse(as.hasValue());
524 assertTrue(as.hasThrowable());
525 assertFalse(as.hasComplete());
526 assertNull(as.getValue());
527 assertTrue(as.getThrowable() instanceof TestException);
528 }
529
530 @Test
531 public void cancelOnArrival() {
532 BehaviorSubject<Object> p = BehaviorSubject.create();
533
534 assertFalse(p.hasObservers());
535
536 p.test(true).assertEmpty();
537
538 assertFalse(p.hasObservers());
539 }
540
541 @Test
542 public void onSubscribe() {
543 BehaviorSubject<Object> p = BehaviorSubject.create();
544
545 Disposable bs = Disposable.empty();
546
547 p.onSubscribe(bs);
548
549 assertFalse(bs.isDisposed());
550
551 p.onComplete();
552
553 bs = Disposable.empty();
554
555 p.onSubscribe(bs);
556
557 assertTrue(bs.isDisposed());
558 }
559
560 @Test
561 public void onErrorAfterComplete() {
562 BehaviorSubject<Object> p = BehaviorSubject.create();
563
564 p.onComplete();
565
566 List<Throwable> errors = TestHelper.trackPluginErrors();
567 try {
568 p.onError(new TestException());
569
570 TestHelper.assertUndeliverable(errors, 0, TestException.class);
571 } finally {
572 RxJavaPlugins.reset();
573 }
574 }
575
576 @Test
577 public void cancelOnArrival2() {
578 BehaviorSubject<Object> p = BehaviorSubject.create();
579
580 TestObserver<Object> to = p.test();
581
582 p.test(true).assertEmpty();
583
584 p.onNext(1);
585 p.onComplete();
586
587 to.assertResult(1);
588 }
589
590 @Test
591 public void addRemoveRace() {
592 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
593 final BehaviorSubject<Object> p = BehaviorSubject.create();
594
595 final TestObserver<Object> to = p.test();
596
597 Runnable r1 = new Runnable() {
598 @Override
599 public void run() {
600 p.test();
601 }
602 };
603
604 Runnable r2 = new Runnable() {
605 @Override
606 public void run() {
607 to.dispose();
608 }
609 };
610
611 TestHelper.race(r1, r2);
612 }
613 }
614
615 @SuppressWarnings({ "rawtypes", "unchecked" })
616 @Test
617 public void subscribeOnNextRace() {
618 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
619 final BehaviorSubject<Object> p = BehaviorSubject.createDefault((Object)1);
620
621 final TestObserver[] to = { null };
622
623 Runnable r1 = new Runnable() {
624 @Override
625 public void run() {
626 to[0] = p.test();
627 }
628 };
629
630 Runnable r2 = new Runnable() {
631 @Override
632 public void run() {
633 p.onNext(2);
634 }
635 };
636
637 TestHelper.race(r1, r2);
638
639 if (to[0].values().size() == 1) {
640 to[0].assertValue(2).assertNoErrors().assertNotComplete();
641 } else {
642 to[0].assertValues(1, 2).assertNoErrors().assertNotComplete();
643 }
644 }
645 }
646
647 @Test
648 public void innerDisposed() {
649 BehaviorSubject.create()
650 .subscribe(new Observer<Object>() {
651 @Override
652 public void onSubscribe(Disposable d) {
653 assertFalse(d.isDisposed());
654
655 d.dispose();
656
657 assertTrue(d.isDisposed());
658 }
659
660 @Override
661 public void onNext(Object value) {
662
663 }
664
665 @Override
666 public void onError(Throwable e) {
667
668 }
669
670 @Override
671 public void onComplete() {
672
673 }
674 });
675 }
676
677 @Test
678 public void completeSubscribeRace() throws Exception {
679 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
680 final BehaviorSubject<Object> p = BehaviorSubject.create();
681
682 final TestObserver<Object> to = new TestObserver<>();
683
684 Runnable r1 = new Runnable() {
685 @Override
686 public void run() {
687 p.subscribe(to);
688 }
689 };
690
691 Runnable r2 = new Runnable() {
692 @Override
693 public void run() {
694 p.onComplete();
695 }
696 };
697
698 TestHelper.race(r1, r2);
699
700 to.assertResult();
701 }
702 }
703
704 @Test
705 public void errorSubscribeRace() throws Exception {
706 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
707 final BehaviorSubject<Object> p = BehaviorSubject.create();
708
709 final TestObserver<Object> to = new TestObserver<>();
710
711 final TestException ex = new TestException();
712
713 Runnable r1 = new Runnable() {
714 @Override
715 public void run() {
716 p.subscribe(to);
717 }
718 };
719
720 Runnable r2 = new Runnable() {
721 @Override
722 public void run() {
723 p.onError(ex);
724 }
725 };
726
727 TestHelper.race(r1, r2);
728
729 to.assertFailure(TestException.class);
730 }
731 }
732
733 @Test
734 public void behaviorDisposableDisposeState() {
735 BehaviorSubject<Integer> bs = BehaviorSubject.create();
736 bs.onNext(1);
737
738 TestObserver<Integer> to = new TestObserver<>();
739
740 BehaviorDisposable<Integer> bd = new BehaviorDisposable<>(to, bs);
741 to.onSubscribe(bd);
742
743 assertFalse(bd.isDisposed());
744
745 bd.dispose();
746
747 assertTrue(bd.isDisposed());
748
749 bd.dispose();
750
751 assertTrue(bd.isDisposed());
752
753 assertTrue(bd.test(2));
754
755 bd.emitFirst();
756
757 to.assertEmpty();
758
759 bd.emitNext(2, 0);
760 }
761
762 @Test
763 public void emitFirstDisposeRace() {
764 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
765
766 BehaviorSubject<Integer> bs = BehaviorSubject.create();
767 bs.onNext(1);
768
769 TestObserver<Integer> to = new TestObserver<>();
770
771 final BehaviorDisposable<Integer> bd = new BehaviorDisposable<>(to, bs);
772 to.onSubscribe(bd);
773
774 Runnable r1 = new Runnable() {
775 @Override
776 public void run() {
777 bd.emitFirst();
778 }
779 };
780 Runnable r2 = new Runnable() {
781 @Override
782 public void run() {
783 bd.dispose();
784 }
785 };
786
787 TestHelper.race(r1, r2);
788 }
789 }
790
791 @Test
792 public void emitNextDisposeRace() {
793 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
794
795 BehaviorSubject<Integer> bs = BehaviorSubject.create();
796 bs.onNext(1);
797
798 TestObserver<Integer> to = new TestObserver<>();
799
800 final BehaviorDisposable<Integer> bd = new BehaviorDisposable<>(to, bs);
801 to.onSubscribe(bd);
802
803 Runnable r1 = new Runnable() {
804 @Override
805 public void run() {
806 bd.emitNext(2, 0);
807 }
808 };
809 Runnable r2 = new Runnable() {
810 @Override
811 public void run() {
812 bd.dispose();
813 }
814 };
815
816 TestHelper.race(r1, r2);
817 }
818 }
819
820 @Test
821 public void emittingEmitNext() {
822 BehaviorSubject<Integer> bs = BehaviorSubject.create();
823 bs.onNext(1);
824
825 TestObserver<Integer> to = new TestObserver<>();
826
827 final BehaviorDisposable<Integer> bd = new BehaviorDisposable<>(to, bs);
828 to.onSubscribe(bd);
829
830 bd.emitting = true;
831 bd.emitNext(2, 1);
832 bd.emitNext(3, 2);
833
834 assertNotNull(bd.queue);
835 }
836
837 @Test
838 public void hasObservers() {
839 BehaviorSubject<Integer> bs = BehaviorSubject.create();
840
841 assertFalse(bs.hasObservers());
842
843 TestObserver<Integer> to = bs.test();
844
845 assertTrue(bs.hasObservers());
846
847 to.dispose();
848
849 assertFalse(bs.hasObservers());
850 }
851 }