Debian Codegraph @

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