Debian Codegraph @

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