Debian Codegraph @

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