Debian Codegraph @

src/test/java/io/reactivex/rxjava3/subjects/SerializedSubjectTest.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
18 import java.util.*;
19 import java.util.concurrent.TimeUnit;
20
21 import org.junit.Test;
22
23 import io.reactivex.rxjava3.annotations.NonNull;
24 import io.reactivex.rxjava3.core.Observable;
25 import io.reactivex.rxjava3.core.RxJavaTest;
26 import io.reactivex.rxjava3.disposables.Disposable;
27 import io.reactivex.rxjava3.exceptions.TestException;
28 import io.reactivex.rxjava3.observers.TestObserver;
29 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
30 import io.reactivex.rxjava3.testsupport.*;
31
32 public class SerializedSubjectTest extends RxJavaTest {
33
34 @Test
35 public void basic() {
36 SerializedSubject<String> subject = new SerializedSubject<>(PublishSubject.<String>create());
37 TestObserver<String> to = new TestObserver<>();
38 subject.subscribe(to);
39 subject.onNext("hello");
40 subject.onComplete();
41 to.awaitDone(5, TimeUnit.SECONDS);
42 to.assertValue("hello");
43 }
44
45 @Test
46 public void asyncSubjectValueRelay() {
47 AsyncSubject<Integer> async = AsyncSubject.create();
48 async.onNext(1);
49 async.onComplete();
50 Subject<Integer> serial = async.toSerialized();
51
52 assertFalse(serial.hasObservers());
53 assertTrue(serial.hasComplete());
54 assertFalse(serial.hasThrowable());
55 assertNull(serial.getThrowable());
56 assertEquals((Integer)1, async.getValue());
57 assertTrue(async.hasValue());
58 }
59
60 @Test
61 public void asyncSubjectValueEmpty() {
62 AsyncSubject<Integer> async = AsyncSubject.create();
63 async.onComplete();
64 Subject<Integer> serial = async.toSerialized();
65
66 assertFalse(serial.hasObservers());
67 assertTrue(serial.hasComplete());
68 assertFalse(serial.hasThrowable());
69 assertNull(serial.getThrowable());
70 assertNull(async.getValue());
71 assertFalse(async.hasValue());
72 }
73
74 @Test
75 public void asyncSubjectValueError() {
76 AsyncSubject<Integer> async = AsyncSubject.create();
77 TestException te = new TestException();
78 async.onError(te);
79 Subject<Integer> serial = async.toSerialized();
80
81 assertFalse(serial.hasObservers());
82 assertFalse(serial.hasComplete());
83 assertTrue(serial.hasThrowable());
84 assertSame(te, serial.getThrowable());
85 assertNull(async.getValue());
86 assertFalse(async.hasValue());
87 }
88
89 @Test
90 public void publishSubjectValueRelay() {
91 PublishSubject<Integer> async = PublishSubject.create();
92 async.onNext(1);
93 async.onComplete();
94 Subject<Integer> serial = async.toSerialized();
95
96 assertFalse(serial.hasObservers());
97 assertTrue(serial.hasComplete());
98 assertFalse(serial.hasThrowable());
99 assertNull(serial.getThrowable());
100 }
101
102 @Test
103 public void publishSubjectValueEmpty() {
104 PublishSubject<Integer> async = PublishSubject.create();
105 async.onComplete();
106 Subject<Integer> serial = async.toSerialized();
107
108 assertFalse(serial.hasObservers());
109 assertTrue(serial.hasComplete());
110 assertFalse(serial.hasThrowable());
111 assertNull(serial.getThrowable());
112 }
113
114 @Test
115 public void publishSubjectValueError() {
116 PublishSubject<Integer> async = PublishSubject.create();
117 TestException te = new TestException();
118 async.onError(te);
119 Subject<Integer> serial = async.toSerialized();
120
121 assertFalse(serial.hasObservers());
122 assertFalse(serial.hasComplete());
123 assertTrue(serial.hasThrowable());
124 assertSame(te, serial.getThrowable());
125 }
126
127 @Test
128 public void behaviorSubjectValueRelay() {
129 BehaviorSubject<Integer> async = BehaviorSubject.create();
130 async.onNext(1);
131 async.onComplete();
132 Subject<Integer> serial = async.toSerialized();
133
134 assertFalse(serial.hasObservers());
135 assertTrue(serial.hasComplete());
136 assertFalse(serial.hasThrowable());
137 assertNull(serial.getThrowable());
138 assertNull(async.getValue());
139 assertFalse(async.hasValue());
140 }
141
142 @Test
143 public void behaviorSubjectValueRelayIncomplete() {
144 BehaviorSubject<Integer> async = BehaviorSubject.create();
145 async.onNext(1);
146 Subject<Integer> serial = async.toSerialized();
147
148 assertFalse(serial.hasObservers());
149 assertFalse(serial.hasComplete());
150 assertFalse(serial.hasThrowable());
151 assertNull(serial.getThrowable());
152 assertEquals((Integer)1, async.getValue());
153 assertTrue(async.hasValue());
154 }
155
156 @Test
157 public void behaviorSubjectIncompleteEmpty() {
158 BehaviorSubject<Integer> async = BehaviorSubject.create();
159 Subject<Integer> serial = async.toSerialized();
160
161 assertFalse(serial.hasObservers());
162 assertFalse(serial.hasComplete());
163 assertFalse(serial.hasThrowable());
164 assertNull(serial.getThrowable());
165 assertNull(async.getValue());
166 assertFalse(async.hasValue());
167 }
168
169 @Test
170 public void behaviorSubjectEmpty() {
171 BehaviorSubject<Integer> async = BehaviorSubject.create();
172 async.onComplete();
173 Subject<Integer> serial = async.toSerialized();
174
175 assertFalse(serial.hasObservers());
176 assertTrue(serial.hasComplete());
177 assertFalse(serial.hasThrowable());
178 assertNull(serial.getThrowable());
179 assertNull(async.getValue());
180 assertFalse(async.hasValue());
181 }
182
183 @Test
184 public void behaviorSubjectError() {
185 BehaviorSubject<Integer> async = BehaviorSubject.create();
186 TestException te = new TestException();
187 async.onError(te);
188 Subject<Integer> serial = async.toSerialized();
189
190 assertFalse(serial.hasObservers());
191 assertFalse(serial.hasComplete());
192 assertTrue(serial.hasThrowable());
193 assertSame(te, serial.getThrowable());
194 assertNull(async.getValue());
195 assertFalse(async.hasValue());
196 }
197
198 @Test
199 public void replaySubjectValueRelay() {
200 ReplaySubject<Integer> async = ReplaySubject.create();
201 async.onNext(1);
202 async.onComplete();
203 Subject<Integer> serial = async.toSerialized();
204
205 assertFalse(serial.hasObservers());
206 assertTrue(serial.hasComplete());
207 assertFalse(serial.hasThrowable());
208 assertNull(serial.getThrowable());
209 assertEquals((Integer)1, async.getValue());
210 assertTrue(async.hasValue());
211 assertArrayEquals(new Object[] { 1 }, async.getValues());
212 assertArrayEquals(new Integer[] { 1 }, async.getValues(new Integer[0]));
213 assertArrayEquals(new Integer[] { 1 }, async.getValues(new Integer[] { 0 }));
214 assertArrayEquals(new Integer[] { 1, null }, async.getValues(new Integer[] { 0, 0 }));
215 }
216
217 @Test
218 public void replaySubjectValueRelayIncomplete() {
219 ReplaySubject<Integer> async = ReplaySubject.create();
220 async.onNext(1);
221 Subject<Integer> serial = async.toSerialized();
222
223 assertFalse(serial.hasObservers());
224 assertFalse(serial.hasComplete());
225 assertFalse(serial.hasThrowable());
226 assertNull(serial.getThrowable());
227 assertEquals((Integer)1, async.getValue());
228 assertTrue(async.hasValue());
229 assertArrayEquals(new Object[] { 1 }, async.getValues());
230 assertArrayEquals(new Integer[] { 1 }, async.getValues(new Integer[0]));
231 assertArrayEquals(new Integer[] { 1 }, async.getValues(new Integer[] { 0 }));
232 assertArrayEquals(new Integer[] { 1, null }, async.getValues(new Integer[] { 0, 0 }));
233 }
234
235 @Test
236 public void replaySubjectValueRelayBounded() {
237 ReplaySubject<Integer> async = ReplaySubject.createWithSize(1);
238 async.onNext(0);
239 async.onNext(1);
240 async.onComplete();
241 Subject<Integer> serial = async.toSerialized();
242
243 assertFalse(serial.hasObservers());
244 assertTrue(serial.hasComplete());
245 assertFalse(serial.hasThrowable());
246 assertNull(serial.getThrowable());
247 assertEquals((Integer)1, async.getValue());
248 assertTrue(async.hasValue());
249 assertArrayEquals(new Object[] { 1 }, async.getValues());
250 assertArrayEquals(new Integer[] { 1 }, async.getValues(new Integer[0]));
251 assertArrayEquals(new Integer[] { 1 }, async.getValues(new Integer[] { 0 }));
252 assertArrayEquals(new Integer[] { 1, null }, async.getValues(new Integer[] { 0, 0 }));
253 }
254
255 @Test
256 public void replaySubjectValueRelayBoundedIncomplete() {
257 ReplaySubject<Integer> async = ReplaySubject.createWithSize(1);
258 async.onNext(0);
259 async.onNext(1);
260 Subject<Integer> serial = async.toSerialized();
261
262 assertFalse(serial.hasObservers());
263 assertFalse(serial.hasComplete());
264 assertFalse(serial.hasThrowable());
265 assertNull(serial.getThrowable());
266 assertEquals((Integer)1, async.getValue());
267 assertTrue(async.hasValue());
268 assertArrayEquals(new Object[] { 1 }, async.getValues());
269 assertArrayEquals(new Integer[] { 1 }, async.getValues(new Integer[0]));
270 assertArrayEquals(new Integer[] { 1 }, async.getValues(new Integer[] { 0 }));
271 assertArrayEquals(new Integer[] { 1, null }, async.getValues(new Integer[] { 0, 0 }));
272 }
273
274 @Test
275 public void replaySubjectValueRelayBoundedEmptyIncomplete() {
276 ReplaySubject<Integer> async = ReplaySubject.createWithSize(1);
277 Subject<Integer> serial = async.toSerialized();
278
279 assertFalse(serial.hasObservers());
280 assertFalse(serial.hasComplete());
281 assertFalse(serial.hasThrowable());
282 assertNull(serial.getThrowable());
283 assertNull(async.getValue());
284 assertFalse(async.hasValue());
285 assertArrayEquals(new Object[] { }, async.getValues());
286 assertArrayEquals(new Integer[] { }, async.getValues(new Integer[0]));
287 assertArrayEquals(new Integer[] { null }, async.getValues(new Integer[] { 0 }));
288 assertArrayEquals(new Integer[] { null, 0 }, async.getValues(new Integer[] { 0, 0 }));
289 }
290
291 @Test
292 public void replaySubjectValueRelayEmptyIncomplete() {
293 ReplaySubject<Integer> async = ReplaySubject.create();
294 Subject<Integer> serial = async.toSerialized();
295
296 assertFalse(serial.hasObservers());
297 assertFalse(serial.hasComplete());
298 assertFalse(serial.hasThrowable());
299 assertNull(serial.getThrowable());
300 assertNull(async.getValue());
301 assertFalse(async.hasValue());
302 assertArrayEquals(new Object[] { }, async.getValues());
303 assertArrayEquals(new Integer[] { }, async.getValues(new Integer[0]));
304 assertArrayEquals(new Integer[] { null }, async.getValues(new Integer[] { 0 }));
305 assertArrayEquals(new Integer[] { null, 0 }, async.getValues(new Integer[] { 0, 0 }));
306 }
307
308 @Test
309 public void replaySubjectEmpty() {
310 ReplaySubject<Integer> async = ReplaySubject.create();
311 async.onComplete();
312 Subject<Integer> serial = async.toSerialized();
313
314 assertFalse(serial.hasObservers());
315 assertTrue(serial.hasComplete());
316 assertFalse(serial.hasThrowable());
317 assertNull(serial.getThrowable());
318 assertNull(async.getValue());
319 assertFalse(async.hasValue());
320 assertArrayEquals(new Object[] { }, async.getValues());
321 assertArrayEquals(new Integer[] { }, async.getValues(new Integer[0]));
322 assertArrayEquals(new Integer[] { null }, async.getValues(new Integer[] { 0 }));
323 assertArrayEquals(new Integer[] { null, 0 }, async.getValues(new Integer[] { 0, 0 }));
324 }
325
326 @Test
327 public void replaySubjectError() {
328 ReplaySubject<Integer> async = ReplaySubject.create();
329 TestException te = new TestException();
330 async.onError(te);
331 Subject<Integer> serial = async.toSerialized();
332
333 assertFalse(serial.hasObservers());
334 assertFalse(serial.hasComplete());
335 assertTrue(serial.hasThrowable());
336 assertSame(te, serial.getThrowable());
337 assertNull(async.getValue());
338 assertFalse(async.hasValue());
339 assertArrayEquals(new Object[] { }, async.getValues());
340 assertArrayEquals(new Integer[] { }, async.getValues(new Integer[0]));
341 assertArrayEquals(new Integer[] { null }, async.getValues(new Integer[] { 0 }));
342 assertArrayEquals(new Integer[] { null, 0 }, async.getValues(new Integer[] { 0, 0 }));
343 }
344
345 @Test
346 public void replaySubjectBoundedEmpty() {
347 ReplaySubject<Integer> async = ReplaySubject.createWithSize(1);
348 async.onComplete();
349 Subject<Integer> serial = async.toSerialized();
350
351 assertFalse(serial.hasObservers());
352 assertTrue(serial.hasComplete());
353 assertFalse(serial.hasThrowable());
354 assertNull(serial.getThrowable());
355 assertNull(async.getValue());
356 assertFalse(async.hasValue());
357 assertArrayEquals(new Object[] { }, async.getValues());
358 assertArrayEquals(new Integer[] { }, async.getValues(new Integer[0]));
359 assertArrayEquals(new Integer[] { null }, async.getValues(new Integer[] { 0 }));
360 assertArrayEquals(new Integer[] { null, 0 }, async.getValues(new Integer[] { 0, 0 }));
361 }
362
363 @Test
364 public void replaySubjectBoundedError() {
365 ReplaySubject<Integer> async = ReplaySubject.createWithSize(1);
366 TestException te = new TestException();
367 async.onError(te);
368 Subject<Integer> serial = async.toSerialized();
369
370 assertFalse(serial.hasObservers());
371 assertFalse(serial.hasComplete());
372 assertTrue(serial.hasThrowable());
373 assertSame(te, serial.getThrowable());
374 assertNull(async.getValue());
375 assertFalse(async.hasValue());
376 assertArrayEquals(new Object[] { }, async.getValues());
377 assertArrayEquals(new Integer[] { }, async.getValues(new Integer[0]));
378 assertArrayEquals(new Integer[] { null }, async.getValues(new Integer[] { 0 }));
379 assertArrayEquals(new Integer[] { null, 0 }, async.getValues(new Integer[] { 0, 0 }));
380 }
381
382 @Test
383 public void dontWrapSerializedSubjectAgain() {
384 PublishSubject<Object> s = PublishSubject.create();
385 Subject<Object> s1 = s.toSerialized();
386 Subject<Object> s2 = s1.toSerialized();
387 assertSame(s1, s2);
388 }
389
390 @Test
391 public void normal() {
392 Subject<Integer> s = PublishSubject.<Integer>create().toSerialized();
393
394 TestObserver<Integer> to = s.test();
395
396 Observable.range(1, 10).subscribe(s);
397
398 to.assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
399
400 assertFalse(s.hasObservers());
401
402 s.onNext(11);
403
404 List<Throwable> errors = TestHelper.trackPluginErrors();
405 try {
406 s.onError(new TestException());
407
408 TestHelper.assertUndeliverable(errors, 0, TestException.class);
409 } finally {
410 RxJavaPlugins.reset();
411 }
412 s.onComplete();
413
414 Disposable bs = Disposable.empty();
415 s.onSubscribe(bs);
416 assertTrue(bs.isDisposed());
417 }
418
419 @Test
420 public void onNextOnNextRace() {
421 Set<Integer> expectedSet = new HashSet<>(Arrays.asList(1, 2));
422
423 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
424 final Subject<Integer> s = PublishSubject.<Integer>create().toSerialized();
425
426 TestObserverEx<Integer> to = s.to(TestHelper.<Integer>testConsumer());
427
428 Runnable r1 = new Runnable() {
429 @Override
430 public void run() {
431 s.onNext(1);
432 }
433 };
434
435 Runnable r2 = new Runnable() {
436 @Override
437 public void run() {
438 s.onNext(2);
439 }
440 };
441
442 TestHelper.race(r1, r2);
443
444 to.assertSubscribed()
445 .assertNoErrors()
446 .assertNotComplete()
447 .assertValueCount(2)
448 ;
449
450 Set<Integer> actualSet = new HashSet<>(to.values());
451 assertEquals("" + actualSet, expectedSet, actualSet);
452 }
453 }
454
455 @Test
456 public void onNextOnErrorRace() {
457 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
458 final Subject<Integer> s = PublishSubject.<Integer>create().toSerialized();
459
460 TestObserver<Integer> to = s.test();
461
462 final TestException ex = new TestException();
463
464 Runnable r1 = new Runnable() {
465 @Override
466 public void run() {
467 s.onNext(1);
468 }
469 };
470
471 Runnable r2 = new Runnable() {
472 @Override
473 public void run() {
474 s.onError(ex);
475 }
476 };
477
478 TestHelper.race(r1, r2);
479
480 to.assertError(ex).assertNotComplete();
481
482 if (to.values().size() != 0) {
483 to.assertValue(1);
484 }
485 }
486 }
487
488 @Test
489 public void onNextOnCompleteRace() {
490 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
491 final Subject<Integer> s = PublishSubject.<Integer>create().toSerialized();
492
493 TestObserver<Integer> to = s.test();
494
495 Runnable r1 = new Runnable() {
496 @Override
497 public void run() {
498 s.onNext(1);
499 }
500 };
501
502 Runnable r2 = new Runnable() {
503 @Override
504 public void run() {
505 s.onComplete();
506 }
507 };
508
509 TestHelper.race(r1, r2);
510
511 to.assertComplete().assertNoErrors();
512
513 if (to.values().size() != 0) {
514 to.assertValue(1);
515 }
516 }
517 }
518
519 @Test
520 public void onNextOnSubscribeRace() {
521 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
522 final Subject<Integer> s = PublishSubject.<Integer>create().toSerialized();
523
524 TestObserver<Integer> to = s.test();
525
526 final Disposable bs = Disposable.empty();
527
528 Runnable r1 = new Runnable() {
529 @Override
530 public void run() {
531 s.onNext(1);
532 }
533 };
534
535 Runnable r2 = new Runnable() {
536 @Override
537 public void run() {
538 s.onSubscribe(bs);
539 }
540 };
541
542 TestHelper.race(r1, r2);
543
544 to.assertValue(1).assertNotComplete().assertNoErrors();
545 }
546 }
547
548 @Test
549 public void onCompleteOnSubscribeRace() {
550 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
551 final Subject<Integer> s = PublishSubject.<Integer>create().toSerialized();
552
553 TestObserver<Integer> to = s.test();
554
555 final Disposable bs = Disposable.empty();
556
557 Runnable r1 = new Runnable() {
558 @Override
559 public void run() {
560 s.onComplete();
561 }
562 };
563
564 Runnable r2 = new Runnable() {
565 @Override
566 public void run() {
567 s.onSubscribe(bs);
568 }
569 };
570
571 TestHelper.race(r1, r2);
572
573 to.assertResult();
574 }
575 }
576
577 @Test
578 public void onCompleteOnCompleteRace() {
579 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
580 final Subject<Integer> s = PublishSubject.<Integer>create().toSerialized();
581
582 TestObserver<Integer> to = s.test();
583
584 Runnable r1 = new Runnable() {
585 @Override
586 public void run() {
587 s.onComplete();
588 }
589 };
590
591 Runnable r2 = new Runnable() {
592 @Override
593 public void run() {
594 s.onComplete();
595 }
596 };
597
598 TestHelper.race(r1, r2);
599
600 to.assertResult();
601 }
602 }
603
604 @Test
605 public void onErrorOnErrorRace() {
606 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
607 final Subject<Integer> s = PublishSubject.<Integer>create().toSerialized();
608
609 TestObserver<Integer> to = s.test();
610
611 final TestException ex = new TestException();
612
613 List<Throwable> errors = TestHelper.trackPluginErrors();
614 try {
615 Runnable r1 = new Runnable() {
616 @Override
617 public void run() {
618 s.onError(ex);
619 }
620 };
621
622 Runnable r2 = new Runnable() {
623 @Override
624 public void run() {
625 s.onError(ex);
626 }
627 };
628
629 TestHelper.race(r1, r2);
630
631 to.assertFailure(TestException.class);
632
633 TestHelper.assertUndeliverable(errors, 0, TestException.class);
634 } finally {
635 RxJavaPlugins.reset();
636 }
637 }
638 }
639
640 @Test
641 public void onSubscribeOnSubscribeRace() {
642 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
643 final Subject<Integer> s = PublishSubject.<Integer>create().toSerialized();
644
645 TestObserver<Integer> to = s.test();
646
647 final Disposable bs1 = Disposable.empty();
648 final Disposable bs2 = Disposable.empty();
649
650 Runnable r1 = new Runnable() {
651 @Override
652 public void run() {
653 s.onSubscribe(bs1);
654 }
655 };
656
657 Runnable r2 = new Runnable() {
658 @Override
659 public void run() {
660 s.onSubscribe(bs2);
661 }
662 };
663
664 TestHelper.race(r1, r2);
665
666 to.assertEmpty();
667 }
668 }
669
670 @Test
671 public void onErrorQueued() {
672 Subject<Integer> sp = PublishSubject.<Integer>create().toSerialized();
673
674 TestObserver<Integer> to = new TestObserver<Integer>() {
675 @Override
676 public void onNext(@NonNull Integer t) {
677 super.onNext(t);
678 if (t == 1) {
679 sp.onNext(2);
680 sp.onNext(3);
681 sp.onSubscribe(Disposable.empty());
682 sp.onError(new TestException());
683 }
684 }
685 };
686
687 sp.subscribe(to);
688
689 sp.onNext(1);
690
691 to.assertFailure(TestException.class, 1); // errors skip ahead
692 }
693
694 @Test
695 public void onCompleteQueued() {
696 Subject<Integer> sp = PublishSubject.<Integer>create().toSerialized();
697
698 TestObserver<Integer> to = new TestObserver<Integer>() {
699 @Override
700 public void onNext(@NonNull Integer t) {
701 super.onNext(t);
702 if (t == 1) {
703 sp.onNext(2);
704 sp.onNext(3);
705 sp.onComplete();
706 }
707 }
708 };
709
710 sp.subscribe(to);
711
712 sp.onNext(1);
713
714 to.assertResult(1, 2, 3);
715 }
716 }