Debian Codegraph @

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