Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableFlatMapTest.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 import static org.mockito.ArgumentMatchers.any;
18 import static org.mockito.Mockito.*;
19
20 import java.io.IOException;
21 import java.util.*;
22 import java.util.concurrent.*;
23 import java.util.concurrent.atomic.AtomicInteger;
24
25 import org.junit.*;
26
27 import io.reactivex.rxjava3.annotations.NonNull;
28 import io.reactivex.rxjava3.core.*;
29 import io.reactivex.rxjava3.core.Observable;
30 import io.reactivex.rxjava3.core.Observer;
31 import io.reactivex.rxjava3.disposables.Disposable;
32 import io.reactivex.rxjava3.exceptions.*;
33 import io.reactivex.rxjava3.functions.*;
34 import io.reactivex.rxjava3.internal.functions.Functions;
35 import io.reactivex.rxjava3.observers.TestObserver;
36 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
37 import io.reactivex.rxjava3.schedulers.Schedulers;
38 import io.reactivex.rxjava3.subjects.*;
39 import io.reactivex.rxjava3.testsupport.*;
40
41 public class ObservableFlatMapTest extends RxJavaTest {
42 @Test
43 public void normal() {
44 Observer<Object> o = TestHelper.mockObserver();
45
46 final List<Integer> list = Arrays.asList(1, 2, 3);
47
48 Function<Integer, List<Integer>> func = new Function<Integer, List<Integer>>() {
49 @Override
50 public List<Integer> apply(Integer t1) {
51 return list;
52 }
53 };
54 BiFunction<Integer, Integer, Integer> resFunc = new BiFunction<Integer, Integer, Integer>() {
55
56 @Override
57 public Integer apply(Integer t1, Integer t2) {
58 return t1 | t2;
59 }
60 };
61
62 List<Integer> source = Arrays.asList(16, 32, 64);
63
64 Observable.fromIterable(source).flatMapIterable(func, resFunc).subscribe(o);
65
66 for (Integer s : source) {
67 for (Integer v : list) {
68 verify(o).onNext(s | v);
69 }
70 }
71 verify(o).onComplete();
72 verify(o, never()).onError(any(Throwable.class));
73 }
74
75 @Test
76 public void collectionFunctionThrows() {
77 Observer<Object> o = TestHelper.mockObserver();
78
79 Function<Integer, List<Integer>> func = new Function<Integer, List<Integer>>() {
80 @Override
81 public List<Integer> apply(Integer t1) {
82 throw new TestException();
83 }
84 };
85 BiFunction<Integer, Integer, Integer> resFunc = new BiFunction<Integer, Integer, Integer>() {
86
87 @Override
88 public Integer apply(Integer t1, Integer t2) {
89 return t1 | t2;
90 }
91 };
92
93 List<Integer> source = Arrays.asList(16, 32, 64);
94
95 Observable.fromIterable(source).flatMapIterable(func, resFunc).subscribe(o);
96
97 verify(o, never()).onComplete();
98 verify(o, never()).onNext(any());
99 verify(o).onError(any(TestException.class));
100 }
101
102 @Test
103 public void resultFunctionThrows() {
104 Observer<Object> o = TestHelper.mockObserver();
105
106 final List<Integer> list = Arrays.asList(1, 2, 3);
107
108 Function<Integer, List<Integer>> func = new Function<Integer, List<Integer>>() {
109 @Override
110 public List<Integer> apply(Integer t1) {
111 return list;
112 }
113 };
114 BiFunction<Integer, Integer, Integer> resFunc = new BiFunction<Integer, Integer, Integer>() {
115
116 @Override
117 public Integer apply(Integer t1, Integer t2) {
118 throw new TestException();
119 }
120 };
121
122 List<Integer> source = Arrays.asList(16, 32, 64);
123
124 Observable.fromIterable(source).flatMapIterable(func, resFunc).subscribe(o);
125
126 verify(o, never()).onComplete();
127 verify(o, never()).onNext(any());
128 verify(o).onError(any(TestException.class));
129 }
130
131 @Test
132 public void mergeError() {
133 Observer<Object> o = TestHelper.mockObserver();
134
135 Function<Integer, Observable<Integer>> func = new Function<Integer, Observable<Integer>>() {
136 @Override
137 public Observable<Integer> apply(Integer t1) {
138 return Observable.error(new TestException());
139 }
140 };
141 BiFunction<Integer, Integer, Integer> resFunc = new BiFunction<Integer, Integer, Integer>() {
142
143 @Override
144 public Integer apply(Integer t1, Integer t2) {
145 return t1 | t2;
146 }
147 };
148
149 List<Integer> source = Arrays.asList(16, 32, 64);
150
151 Observable.fromIterable(source).flatMap(func, resFunc).subscribe(o);
152
153 verify(o, never()).onComplete();
154 verify(o, never()).onNext(any());
155 verify(o).onError(any(TestException.class));
156 }
157
158 <T, R> Function<T, R> just(final R value) {
159 return new Function<T, R>() {
160
161 @Override
162 public R apply(T t1) {
163 return value;
164 }
165 };
166 }
167
168 <R> Supplier<R> just0(final R value) {
169 return new Supplier<R>() {
170
171 @Override
172 public R get() {
173 return value;
174 }
175 };
176 }
177
178 @Test
179 public void flatMapTransformsNormal() {
180 Observable<Integer> onNext = Observable.fromIterable(Arrays.asList(1, 2, 3));
181 Observable<Integer> onComplete = Observable.fromIterable(Arrays.asList(4));
182 Observable<Integer> onError = Observable.fromIterable(Arrays.asList(5));
183
184 Observable<Integer> source = Observable.fromIterable(Arrays.asList(10, 20, 30));
185
186 Observer<Object> o = TestHelper.mockObserver();
187
188 source.flatMap(just(onNext), just(onError), just0(onComplete)).subscribe(o);
189
190 verify(o, times(3)).onNext(1);
191 verify(o, times(3)).onNext(2);
192 verify(o, times(3)).onNext(3);
193 verify(o).onNext(4);
194 verify(o).onComplete();
195
196 verify(o, never()).onNext(5);
197 verify(o, never()).onError(any(Throwable.class));
198 }
199
200 @Test
201 public void flatMapTransformsException() {
202 Observable<Integer> onNext = Observable.fromIterable(Arrays.asList(1, 2, 3));
203 Observable<Integer> onComplete = Observable.fromIterable(Arrays.asList(4));
204 Observable<Integer> onError = Observable.fromIterable(Arrays.asList(5));
205
206 Observable<Integer> source = Observable.concat(
207 Observable.fromIterable(Arrays.asList(10, 20, 30)),
208 Observable.<Integer> error(new RuntimeException("Forced failure!"))
209 );
210
211 Observer<Object> o = TestHelper.mockObserver();
212
213 source.flatMap(just(onNext), just(onError), just0(onComplete)).subscribe(o);
214
215 verify(o, times(3)).onNext(1);
216 verify(o, times(3)).onNext(2);
217 verify(o, times(3)).onNext(3);
218 verify(o).onNext(5);
219 verify(o).onComplete();
220 verify(o, never()).onNext(4);
221
222 verify(o, never()).onError(any(Throwable.class));
223 }
224
225 <R> Supplier<R> funcThrow0(R r) {
226 return new Supplier<R>() {
227 @Override
228 public R get() {
229 throw new TestException();
230 }
231 };
232 }
233
234 <T, R> Function<T, R> funcThrow(T t, R r) {
235 return new Function<T, R>() {
236 @Override
237 public R apply(T t) {
238 throw new TestException();
239 }
240 };
241 }
242
243 @Test
244 public void flatMapTransformsOnNextFuncThrows() {
245 Observable<Integer> onComplete = Observable.fromIterable(Arrays.asList(4));
246 Observable<Integer> onError = Observable.fromIterable(Arrays.asList(5));
247
248 Observable<Integer> source = Observable.fromIterable(Arrays.asList(10, 20, 30));
249
250 Observer<Object> o = TestHelper.mockObserver();
251
252 source.flatMap(funcThrow(1, onError), just(onError), just0(onComplete)).subscribe(o);
253
254 verify(o).onError(any(TestException.class));
255 verify(o, never()).onNext(any());
256 verify(o, never()).onComplete();
257 }
258
259 @Test
260 public void flatMapTransformsOnErrorFuncThrows() {
261 Observable<Integer> onNext = Observable.fromIterable(Arrays.asList(1, 2, 3));
262 Observable<Integer> onComplete = Observable.fromIterable(Arrays.asList(4));
263 Observable<Integer> onError = Observable.fromIterable(Arrays.asList(5));
264
265 Observable<Integer> source = Observable.error(new TestException());
266
267 Observer<Object> o = TestHelper.mockObserver();
268
269 source.flatMap(just(onNext), funcThrow((Throwable) null, onError), just0(onComplete)).subscribe(o);
270
271 verify(o).onError(any(CompositeException.class));
272 verify(o, never()).onNext(any());
273 verify(o, never()).onComplete();
274 }
275
276 @Test
277 public void flatMapTransformsOnCompletedFuncThrows() {
278 Observable<Integer> onNext = Observable.fromIterable(Arrays.asList(1, 2, 3));
279 Observable<Integer> onComplete = Observable.fromIterable(Arrays.asList(4));
280 Observable<Integer> onError = Observable.fromIterable(Arrays.asList(5));
281
282 Observable<Integer> source = Observable.fromIterable(Arrays.<Integer> asList());
283
284 Observer<Object> o = TestHelper.mockObserver();
285
286 source.flatMap(just(onNext), just(onError), funcThrow0(onComplete)).subscribe(o);
287
288 verify(o).onError(any(TestException.class));
289 verify(o, never()).onNext(any());
290 verify(o, never()).onComplete();
291 }
292
293 @Test
294 public void flatMapTransformsMergeException() {
295 Observable<Integer> onNext = Observable.error(new TestException());
296 Observable<Integer> onComplete = Observable.fromIterable(Arrays.asList(4));
297 Observable<Integer> onError = Observable.fromIterable(Arrays.asList(5));
298
299 Observable<Integer> source = Observable.fromIterable(Arrays.asList(10, 20, 30));
300
301 Observer<Object> o = TestHelper.mockObserver();
302
303 source.flatMap(just(onNext), just(onError), funcThrow0(onComplete)).subscribe(o);
304
305 verify(o).onError(any(TestException.class));
306 verify(o, never()).onNext(any());
307 verify(o, never()).onComplete();
308 }
309
310 private static <T> Observable<T> composer(Observable<T> source, final AtomicInteger subscriptionCount, final int m) {
311 return source.doOnSubscribe(new Consumer<Disposable>() {
312 @Override
313 public void accept(Disposable d) {
314 int n = subscriptionCount.getAndIncrement();
315 if (n >= m) {
316 Assert.fail("Too many subscriptions! " + (n + 1));
317 }
318 }
319 }).doOnComplete(new Action() {
320 @Override
321 public void run() {
322 int n = subscriptionCount.decrementAndGet();
323 if (n < 0) {
324 Assert.fail("Too many unsubscriptions! " + (n - 1));
325 }
326 }
327 });
328 }
329
330 @Test
331 public void flatMapMaxConcurrent() {
332 final int m = 4;
333 final AtomicInteger subscriptionCount = new AtomicInteger();
334 Observable<Integer> source = Observable.range(1, 10)
335 .flatMap(new Function<Integer, Observable<Integer>>() {
336 @Override
337 public Observable<Integer> apply(Integer t1) {
338 return composer(Observable.range(t1 * 10, 2), subscriptionCount, m)
339 .subscribeOn(Schedulers.computation());
340 }
341 }, m);
342
343 TestObserver<Integer> to = new TestObserver<>();
344
345 source.subscribe(to);
346
347 to.awaitDone(5, TimeUnit.SECONDS);
348 to.assertNoErrors();
349 Set<Integer> expected = new HashSet<>(Arrays.asList(
350 10, 11, 20, 21, 30, 31, 40, 41, 50, 51, 60, 61, 70, 71, 80, 81, 90, 91, 100, 101
351 ));
352 Assert.assertEquals(expected.size(), to.values().size());
353 Assert.assertTrue(expected.containsAll(to.values()));
354 }
355
356 @Test
357 public void flatMapSelectorMaxConcurrent() {
358 final int m = 4;
359 final AtomicInteger subscriptionCount = new AtomicInteger();
360 Observable<Integer> source = Observable.range(1, 10)
361 .flatMap(new Function<Integer, Observable<Integer>>() {
362 @Override
363 public Observable<Integer> apply(Integer t1) {
364 return composer(Observable.range(t1 * 10, 2), subscriptionCount, m)
365 .subscribeOn(Schedulers.computation());
366 }
367 }, new BiFunction<Integer, Integer, Integer>() {
368 @Override
369 public Integer apply(Integer t1, Integer t2) {
370 return t1 * 1000 + t2;
371 }
372 }, m);
373
374 TestObserver<Integer> to = new TestObserver<>();
375
376 source.subscribe(to);
377
378 to.awaitDone(5, TimeUnit.SECONDS);
379 to.assertNoErrors();
380 Set<Integer> expected = new HashSet<>(Arrays.asList(
381 1010, 1011, 2020, 2021, 3030, 3031, 4040, 4041, 5050, 5051,
382 6060, 6061, 7070, 7071, 8080, 8081, 9090, 9091, 10100, 10101
383 ));
384 Assert.assertEquals(expected.size(), to.values().size());
385 System.out.println("--> testFlatMapSelectorMaxConcurrent: " + to.values());
386 Assert.assertTrue(expected.containsAll(to.values()));
387 }
388
389 @Test
390 public void flatMapTransformsMaxConcurrentNormalLoop() {
391 for (int i = 0; i < 1000; i++) {
392 if (i % 100 == 0) {
393 System.out.println("testFlatMapTransformsMaxConcurrentNormalLoop => " + i);
394 }
395 flatMapTransformsMaxConcurrentNormal();
396 }
397 }
398
399 @Test
400 public void flatMapTransformsMaxConcurrentNormal() {
401 final int m = 2;
402 final AtomicInteger subscriptionCount = new AtomicInteger();
403 Observable<Integer> onNext =
404 composer(
405 Observable.fromIterable(Arrays.asList(1, 2, 3))
406 .observeOn(Schedulers.computation())
407 ,
408 subscriptionCount, m)
409 .subscribeOn(Schedulers.computation())
410 ;
411
412 Observable<Integer> onComplete = composer(Observable.fromIterable(Arrays.asList(4)), subscriptionCount, m)
413 .subscribeOn(Schedulers.computation());
414
415 Observable<Integer> onError = Observable.fromIterable(Arrays.asList(5));
416
417 Observable<Integer> source = Observable.fromIterable(Arrays.asList(10, 20, 30));
418
419 Observer<Object> o = TestHelper.mockObserver();
420 TestObserverEx<Object> to = new TestObserverEx<>(o);
421
422 Function<Throwable, Observable<Integer>> just = just(onError);
423 source.flatMap(just(onNext), just, just0(onComplete), m).subscribe(to);
424
425 to.awaitDone(1, TimeUnit.SECONDS);
426 to.assertNoErrors();
427 to.assertTerminated();
428
429 verify(o, times(3)).onNext(1);
430 verify(o, times(3)).onNext(2);
431 verify(o, times(3)).onNext(3);
432 verify(o).onNext(4);
433 verify(o).onComplete();
434
435 verify(o, never()).onNext(5);
436 verify(o, never()).onError(any(Throwable.class));
437 }
438
439 @Test
440 public void flatMapRangeMixedAsyncLoop() {
441 for (int i = 0; i < 2000; i++) {
442 if (i % 10 == 0) {
443 System.out.println("flatMapRangeAsyncLoop > " + i);
444 }
445 TestObserverEx<Integer> to = new TestObserverEx<>();
446 Observable.range(0, 1000)
447 .flatMap(new Function<Integer, Observable<Integer>>() {
448 final Random rnd = new Random();
449 @Override
450 public Observable<Integer> apply(Integer t) {
451 Observable<Integer> r = Observable.just(t);
452 if (rnd.nextBoolean()) {
453 r = r.hide();
454 }
455 return r;
456 }
457 })
458 .observeOn(Schedulers.computation())
459 .subscribe(to);
460
461 to.awaitDone(2500, TimeUnit.MILLISECONDS);
462 if (to.completions() == 0) {
463 System.out.println(to.values().size());
464 }
465 to.assertTerminated();
466 to.assertNoErrors();
467 List<Integer> list = to.values();
468 if (list.size() < 1000) {
469 Set<Integer> set = new HashSet<>(list);
470 for (int j = 0; j < 1000; j++) {
471 if (!set.contains(j)) {
472 System.out.println(j + " missing");
473 }
474 }
475 }
476 assertEquals(1000, list.size());
477 }
478 }
479
480 @Test
481 public void flatMapIntPassthruAsync() {
482 for (int i = 0; i < 1000; i++) {
483 TestObserver<Integer> to = new TestObserver<>();
484
485 Observable.range(1, 1000).flatMap(new Function<Integer, Observable<Integer>>() {
486 @Override
487 public Observable<Integer> apply(Integer t) {
488 return Observable.just(1).subscribeOn(Schedulers.computation());
489 }
490 }).subscribe(to);
491
492 to.awaitDone(5, TimeUnit.SECONDS);
493 to.assertNoErrors();
494 to.assertComplete();
495 to.assertValueCount(1000);
496 }
497 }
498
499 @Test
500 public void flatMapTwoNestedSync() {
501 for (final int n : new int[] { 1, 1000, 1000000 }) {
502 TestObserver<Integer> to = new TestObserver<>();
503
504 Observable.just(1, 2).flatMap(new Function<Integer, Observable<Integer>>() {
505 @Override
506 public Observable<Integer> apply(Integer t) {
507 return Observable.range(1, n);
508 }
509 }).subscribe(to);
510
511 System.out.println("flatMapTwoNestedSync >> @ " + n);
512 to.assertNoErrors();
513 to.assertComplete();
514 to.assertValueCount(n * 2);
515 }
516 }
517
518 @Test
519 public void flatMapBiMapper() {
520 Observable.just(1)
521 .flatMap(new Function<Integer, ObservableSource<Integer>>() {
522 @Override
523 public ObservableSource<Integer> apply(Integer v) throws Exception {
524 return Observable.just(v * 10);
525 }
526 }, new BiFunction<Integer, Integer, Integer>() {
527 @Override
528 public Integer apply(Integer a, Integer b) throws Exception {
529 return a + b;
530 }
531 }, true)
532 .test()
533 .assertResult(11);
534 }
535
536 @Test
537 public void flatMapBiMapperWithError() {
538 Observable.just(1)
539 .flatMap(new Function<Integer, ObservableSource<Integer>>() {
540 @Override
541 public ObservableSource<Integer> apply(Integer v) throws Exception {
542 return Observable.just(v * 10).concatWith(Observable.<Integer>error(new TestException()));
543 }
544 }, new BiFunction<Integer, Integer, Integer>() {
545 @Override
546 public Integer apply(Integer a, Integer b) throws Exception {
547 return a + b;
548 }
549 }, true)
550 .test()
551 .assertFailure(TestException.class, 11);
552 }
553
554 @Test
555 public void flatMapBiMapperMaxConcurrency() {
556 Observable.just(1, 2)
557 .flatMap(new Function<Integer, ObservableSource<Integer>>() {
558 @Override
559 public ObservableSource<Integer> apply(Integer v) throws Exception {
560 return Observable.just(v * 10);
561 }
562 }, new BiFunction<Integer, Integer, Integer>() {
563 @Override
564 public Integer apply(Integer a, Integer b) throws Exception {
565 return a + b;
566 }
567 }, true, 1)
568 .test()
569 .assertResult(11, 22);
570 }
571
572 @Test
573 public void flatMapEmpty() {
574 assertSame(Observable.empty(), Observable.empty().flatMap(new Function<Object, ObservableSource<Object>>() {
575 @Override
576 public ObservableSource<Object> apply(Object v) throws Exception {
577 return Observable.just(v);
578 }
579 }));
580 }
581
582 @Test
583 public void mergeScalar() {
584 Observable.merge(Observable.just(Observable.just(1)))
585 .test()
586 .assertResult(1);
587 }
588
589 @Test
590 public void mergeScalar2() {
591 Observable.merge(Observable.just(Observable.just(1)).hide())
592 .test()
593 .assertResult(1);
594 }
595
596 @Test
597 public void mergeScalarEmpty() {
598 Observable.merge(Observable.just(Observable.empty()).hide())
599 .test()
600 .assertResult();
601 }
602
603 @Test
604 public void mergeScalarError() {
605 Observable.merge(Observable.just(Observable.fromCallable(new Callable<Object>() {
606 @Override
607 public Object call() throws Exception {
608 throw new TestException();
609 }
610 })).hide())
611 .test()
612 .assertFailure(TestException.class);
613 }
614
615 @Test
616 public void scalarReentrant() {
617 final PublishSubject<Observable<Integer>> ps = PublishSubject.create();
618
619 TestObserver<Integer> to = new TestObserver<Integer>() {
620 @Override
621 public void onNext(Integer t) {
622 super.onNext(t);
623 if (t == 1) {
624 ps.onNext(Observable.just(2));
625 }
626 }
627 };
628
629 Observable.merge(ps)
630 .subscribe(to);
631
632 ps.onNext(Observable.just(1));
633 ps.onComplete();
634
635 to.assertResult(1, 2);
636 }
637
638 @Test
639 public void scalarReentrant2() {
640 final PublishSubject<Observable<Integer>> ps = PublishSubject.create();
641
642 TestObserver<Integer> to = new TestObserver<Integer>() {
643 @Override
644 public void onNext(Integer t) {
645 super.onNext(t);
646 if (t == 1) {
647 ps.onNext(Observable.just(2));
648 }
649 }
650 };
651
652 Observable.merge(ps, 2)
653 .subscribe(to);
654
655 ps.onNext(Observable.just(1));
656 ps.onComplete();
657
658 to.assertResult(1, 2);
659 }
660
661 @Test
662 public void innerCompleteCancelRace() {
663 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
664 final PublishSubject<Integer> ps = PublishSubject.create();
665
666 final TestObserver<Integer> to = Observable.merge(Observable.just(ps)).test();
667
668 Runnable r1 = new Runnable() {
669 @Override
670 public void run() {
671 ps.onComplete();
672 }
673 };
674
675 Runnable r2 = new Runnable() {
676 @Override
677 public void run() {
678 to.dispose();
679 }
680 };
681
682 TestHelper.race(r1, r2);
683 }
684 }
685
686 @Test
687 public void fusedInnerThrows() {
688 Observable.just(1).hide()
689 .flatMap(new Function<Integer, ObservableSource<Object>>() {
690 @Override
691 public ObservableSource<Object> apply(Integer v) throws Exception {
692 return Observable.range(1, 2).map(new Function<Integer, Object>() {
693 @Override
694 public Object apply(Integer w) throws Exception {
695 throw new TestException();
696 }
697 });
698 }
699 })
700 .test()
701 .assertFailure(TestException.class);
702 }
703
704 @Test
705 public void fusedInnerThrows2() {
706 TestObserverEx<Integer> to = Observable.range(1, 2).hide()
707 .flatMap(new Function<Integer, ObservableSource<Integer>>() {
708 @Override
709 public ObservableSource<Integer> apply(Integer v) throws Exception {
710 return Observable.range(1, 2).map(new Function<Integer, Integer>() {
711 @Override
712 public Integer apply(Integer w) throws Exception {
713 throw new TestException();
714 }
715 });
716 }
717 }, true)
718 .to(TestHelper.<Integer>testConsumer())
719 .assertFailure(CompositeException.class);
720
721 List<Throwable> errors = TestHelper.errorList(to);
722
723 TestHelper.assertError(errors, 0, TestException.class);
724
725 TestHelper.assertError(errors, 1, TestException.class);
726 }
727
728 @Test
729 public void noCrossBoundaryFusion() {
730 for (int i = 0; i < 500; i++) {
731 TestObserver<Object> to = Observable.merge(
732 Observable.just(1).observeOn(Schedulers.single()).map(new Function<Integer, Object>() {
733 @Override
734 public Object apply(Integer v) throws Exception {
735 return Thread.currentThread().getName().substring(0, 4);
736 }
737 }),
738 Observable.just(1).observeOn(Schedulers.computation()).map(new Function<Integer, Object>() {
739 @Override
740 public Object apply(Integer v) throws Exception {
741 return Thread.currentThread().getName().substring(0, 4);
742 }
743 })
744 )
745 .test()
746 .awaitDone(5, TimeUnit.SECONDS)
747 .assertValueCount(2);
748
749 List<Object> list = to.values();
750
751 assertTrue(list.toString(), list.contains("RxSi"));
752 assertTrue(list.toString(), list.contains("RxCo"));
753 }
754 }
755
756 @Test
757 public void cancelScalarDrainRace() {
758 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
759 List<Throwable> errors = TestHelper.trackPluginErrors();
760 try {
761
762 final PublishSubject<Observable<Integer>> ps = PublishSubject.create();
763
764 final TestObserver<Integer> to = ps.flatMap(Functions.<Observable<Integer>>identity()).test();
765
766 Runnable r1 = new Runnable() {
767 @Override
768 public void run() {
769 to.dispose();
770 }
771 };
772 Runnable r2 = new Runnable() {
773 @Override
774 public void run() {
775 ps.onComplete();
776 }
777 };
778
779 TestHelper.race(r1, r2);
780
781 assertTrue(errors.toString(), errors.isEmpty());
782 } finally {
783 RxJavaPlugins.reset();
784 }
785 }
786 }
787
788 @Test
789 public void cancelDrainRace() {
790 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
791 for (int j = 1; j < 50; j += 5) {
792 List<Throwable> errors = TestHelper.trackPluginErrors();
793 try {
794
795 final PublishSubject<Observable<Integer>> ps = PublishSubject.create();
796
797 final TestObserver<Integer> to = ps.flatMap(Functions.<Observable<Integer>>identity()).test();
798
799 final PublishSubject<Integer> just = PublishSubject.create();
800 final PublishSubject<Integer> just2 = PublishSubject.create();
801 ps.onNext(just);
802 ps.onNext(just2);
803
804 Runnable r1 = new Runnable() {
805 @Override
806 public void run() {
807 just2.onNext(1);
808 to.dispose();
809 }
810 };
811 Runnable r2 = new Runnable() {
812 @Override
813 public void run() {
814 just.onNext(1);
815 }
816 };
817
818 TestHelper.race(r1, r2);
819
820 assertTrue(errors.toString(), errors.isEmpty());
821 } finally {
822 RxJavaPlugins.reset();
823 }
824 }
825 }
826 }
827
828 @Test
829 public void iterableMapperFunctionReturnsNull() {
830 Observable.just(1)
831 .flatMapIterable(new Function<Integer, Iterable<Object>>() {
832 @Override
833 public Iterable<Object> apply(Integer v) throws Exception {
834 return null;
835 }
836 }, new BiFunction<Integer, Object, Object>() {
837 @Override
838 public Object apply(Integer v, Object w) throws Exception {
839 return v;
840 }
841 })
842 .to(TestHelper.<Object>testConsumer())
843 .assertFailureAndMessage(NullPointerException.class, "The mapper returned a null Iterable");
844 }
845
846 @Test
847 public void combinerMapperFunctionReturnsNull() {
848 Observable.just(1)
849 .flatMap(new Function<Integer, Observable<Object>>() {
850 @Override
851 public Observable<Object> apply(Integer v) throws Exception {
852 return null;
853 }
854 }, new BiFunction<Integer, Object, Object>() {
855 @Override
856 public Object apply(Integer v, Object w) throws Exception {
857 return v;
858 }
859 })
860 .to(TestHelper.<Object>testConsumer())
861 .assertFailureAndMessage(NullPointerException.class, "The mapper returned a null ObservableSource");
862 }
863
864 @Test
865 public void failingFusedInnerCancelsSource() {
866 final AtomicInteger counter = new AtomicInteger();
867 Observable.range(1, 5)
868 .doOnNext(new Consumer<Integer>() {
869 @Override
870 public void accept(Integer v) throws Exception {
871 counter.getAndIncrement();
872 }
873 })
874 .flatMap(new Function<Integer, Observable<Integer>>() {
875 @Override
876 public Observable<Integer> apply(Integer v)
877 throws Exception {
878 return Observable.<Integer>fromIterable(new Iterable<Integer>() {
879 @Override
880 public Iterator<Integer> iterator() {
881 return new Iterator<Integer>() {
882 @Override
883 public boolean hasNext() {
884 return true;
885 }
886
887 @Override
888 public Integer next() {
889 throw new TestException();
890 }
891
892 @Override
893 public void remove() {
894 throw new UnsupportedOperationException();
895 }
896 };
897 }
898 });
899 }
900 })
901 .test()
902 .assertFailure(TestException.class);
903
904 assertEquals(1, counter.get());
905 }
906
907 @Test
908 public void scalarQueueNoOverflow() {
909 List<Throwable> errors = TestHelper.trackPluginErrors();
910 try {
911 final PublishSubject<Integer> ps = PublishSubject.create();
912
913 TestObserver<Integer> to = ps.flatMap(new Function<Integer, Observable<Integer>>() {
914 @Override
915 public Observable<Integer> apply(Integer v)
916 throws Exception {
917 return Observable.just(v + 1);
918 }
919 }, 1)
920 .subscribeWith(new TestObserver<Integer>() {
921 @Override
922 public void onNext(Integer t) {
923 super.onNext(t);
924 if (t == 1) {
925 for (int i = 1; i < 10; i++) {
926 ps.onNext(i);
927 }
928 ps.onComplete();
929 }
930 }
931 });
932
933 ps.onNext(0);
934
935 if (!errors.isEmpty()) {
936 to.onError(new CompositeException(errors));
937 }
938
939 to.assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
940 } finally {
941 RxJavaPlugins.reset();
942 }
943 }
944
945 @Test
946 public void scalarQueueNoOverflowHidden() {
947 final PublishSubject<Integer> ps = PublishSubject.create();
948
949 TestObserver<Integer> to = ps.flatMap(new Function<Integer, Observable<Integer>>() {
950 @Override
951 public Observable<Integer> apply(Integer v)
952 throws Exception {
953 return Observable.just(v + 1).hide();
954 }
955 }, 1)
956 .subscribeWith(new TestObserver<Integer>() {
957 @Override
958 public void onNext(Integer t) {
959 super.onNext(t);
960 if (t == 1) {
961 for (int i = 1; i < 10; i++) {
962 ps.onNext(i);
963 }
964 ps.onComplete();
965 }
966 }
967 });
968
969 ps.onNext(0);
970
971 to.assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
972 }
973
974 @Test
975 public void fusedSourceCrashResumeWithNextSource() {
976 final UnicastSubject<Integer> fusedSource = UnicastSubject.create();
977 TestObserver<Integer> to = new TestObserver<>();
978
979 ObservableFlatMap.MergeObserver<Integer, Integer> merger =
980 new ObservableFlatMap.MergeObserver<>(to, new Function<Integer, Observable<Integer>>() {
981 @Override
982 public Observable<Integer> apply(Integer t)
983 throws Exception {
984 if (t == 0) {
985 return fusedSource
986 .map(new Function<Integer, Integer>() {
987 @Override
988 public Integer apply(Integer v)
989 throws Exception {
990 throw new TestException();
991 }
992 })
993 .compose(TestHelper.<Integer>observableStripBoundary());
994 }
995 return Observable.range(10 * t, 5);
996 }
997 }, true, Integer.MAX_VALUE, 128);
998
999 merger.onSubscribe(Disposable.empty());
1000 merger.getAndIncrement();
1001
1002 merger.onNext(0);
1003 merger.onNext(1);
1004 merger.onNext(2);
1005
1006 assertTrue(fusedSource.hasObservers());
1007
1008 fusedSource.onNext(-1);
1009
1010 merger.drainLoop();
1011
1012 to.assertValuesOnly(10, 11, 12, 13, 14, 20, 21, 22, 23, 24);
1013 }
1014
1015 @Test
1016 public void maxConcurrencySustained() {
1017 final PublishSubject<Integer> ps1 = PublishSubject.create();
1018 final PublishSubject<Integer> ps2 = PublishSubject.create();
1019 PublishSubject<Integer> ps3 = PublishSubject.create();
1020 PublishSubject<Integer> ps4 = PublishSubject.create();
1021
1022 TestObserver<Integer> to = Observable.just(ps1, ps2, ps3, ps4)
1023 .flatMap(new Function<PublishSubject<Integer>, ObservableSource<Integer>>() {
1024 @Override
1025 public ObservableSource<Integer> apply(PublishSubject<Integer> v) throws Exception {
1026 return v;
1027 }
1028 }, 2)
1029 .doOnNext(new Consumer<Integer>() {
1030 @Override
1031 public void accept(Integer v) throws Exception {
1032 if (v == 1) {
1033 // this will make sure the drain loop detects two completed
1034 // inner sources and replaces them with fresh ones
1035 ps1.onComplete();
1036 ps2.onComplete();
1037 }
1038 }
1039 })
1040 .test();
1041
1042 ps1.onNext(1);
1043
1044 assertFalse(ps1.hasObservers());
1045 assertFalse(ps2.hasObservers());
1046 assertTrue(ps3.hasObservers());
1047 assertTrue(ps4.hasObservers());
1048
1049 to.dispose();
1050
1051 assertFalse(ps3.hasObservers());
1052 assertFalse(ps4.hasObservers());
1053 }
1054
1055 @Test
1056 public void undeliverableUponCancel() {
1057 TestHelper.checkUndeliverableUponCancel(new ObservableConverter<Integer, Observable<Integer>>() {
1058 @Override
1059 public Observable<Integer> apply(Observable<Integer> upstream) {
1060 return upstream.flatMap(new Function<Integer, Observable<Integer>>() {
1061 @Override
1062 public Observable<Integer> apply(Integer v) throws Throwable {
1063 return Observable.just(v).hide();
1064 }
1065 });
1066 }
1067 });
1068 }
1069
1070 @Test
1071 public void undeliverableUponCancelDelayError() {
1072 TestHelper.checkUndeliverableUponCancel(new ObservableConverter<Integer, Observable<Integer>>() {
1073 @Override
1074 public Observable<Integer> apply(Observable<Integer> upstream) {
1075 return upstream.flatMap(new Function<Integer, Observable<Integer>>() {
1076 @Override
1077 public Observable<Integer> apply(Integer v) throws Throwable {
1078 return Observable.just(v).hide();
1079 }
1080 }, true);
1081 }
1082 });
1083 }
1084
1085 @Test
1086 public void mainErrorsInnerCancelled() {
1087 PublishSubject<Integer> ps1 = PublishSubject.create();
1088 PublishSubject<Integer> ps2 = PublishSubject.create();
1089
1090 ps1
1091 .flatMap(v -> ps2)
1092 .test();
1093
1094 ps1.onNext(1);
1095 assertTrue("No subscribers?", ps2.hasObservers());
1096
1097 ps1.onError(new TestException());
1098
1099 assertFalse("Has subscribers?", ps2.hasObservers());
1100 }
1101
1102 @Test
1103 public void innerErrorsMainCancelled() {
1104 PublishSubject<Integer> ps1 = PublishSubject.create();
1105 PublishSubject<Integer> ps2 = PublishSubject.create();
1106
1107 ps1
1108 .flatMap(v -> ps2)
1109 .test();
1110
1111 ps1.onNext(1);
1112 assertTrue("No subscribers?", ps2.hasObservers());
1113
1114 ps2.onError(new TestException());
1115
1116 assertFalse("Has subscribers?", ps1.hasObservers());
1117 }
1118
1119 @Test
1120 public void signalsAfterMapperCrash() throws Throwable {
1121 TestHelper.withErrorTracking(errors -> {
1122 new Observable<Integer>() {
1123 @Override
1124 protected void subscribeActual(@NonNull Observer<? super @NonNull Integer> observer) {
1125 observer.onSubscribe(Disposable.empty());
1126 observer.onNext(1);
1127 observer.onNext(2);
1128 observer.onComplete();
1129 observer.onError(new IOException());
1130 }
1131 }
1132 .flatMap(v -> {
1133 throw new TestException();
1134 })
1135 .test()
1136 .assertFailure(TestException.class);
1137
1138 TestHelper.assertUndeliverable(errors, 0, IOException.class);
1139 });
1140 }
1141
1142 @Test
1143 public void scalarQueueTerminate() {
1144 PublishSubject<Integer> ps = PublishSubject.create();
1145 TestObserver<Integer> to = new TestObserver<>();
1146
1147 ps
1148 .flatMap(v -> Observable.just(v))
1149 .doOnNext(v -> {
1150 if (v == 1) {
1151 ps.onNext(2);
1152 ps.onNext(3);
1153 }
1154 })
1155 .take(2)
1156 .subscribe(to);
1157
1158 ps.onNext(1);
1159
1160 to.assertResult(1, 2);
1161 }
1162
1163 @Test
1164 public void scalarQueueCompleteMain() throws Exception {
1165 PublishSubject<Integer> ps = PublishSubject.create();
1166 TestObserver<Integer> to = new TestObserver<>();
1167 CountDownLatch cdl = new CountDownLatch(1);
1168 ps
1169 .flatMap(v -> Observable.just(v))
1170 .doOnNext(v -> {
1171 if (v == 1) {
1172 ps.onNext(2);
1173 TestHelper.raceOther(() -> ps.onComplete(), cdl);
1174 }
1175 })
1176 .subscribe(to);
1177
1178 ps.onNext(1);
1179
1180 cdl.await();
1181 to.assertResult(1, 2);
1182 }
1183
1184 @Test
1185 public void fusedInnerCrash() {
1186 UnicastSubject<Integer> us = UnicastSubject.create();
1187 PublishSubject<Integer> ps = PublishSubject.create();
1188
1189 TestObserver<Integer> to = Observable.just(
1190 ps,
1191 us.map(v -> {
1192 if (v == 10) {
1193 throw new TestException();
1194 }
1195 return v;
1196 })
1197 .compose(TestHelper.observableStripBoundary())
1198 )
1199 .flatMap(v -> v, true)
1200 .doOnNext(v -> {
1201 if (v == 1) {
1202 ps.onNext(2);
1203 us.onNext(10);
1204 }
1205 })
1206 .test();
1207
1208 ps.onNext(1);
1209 ps.onComplete();
1210
1211 to.assertFailure(TestException.class, 1, 2);
1212 }
1213
1214 @Test
1215 public void fusedInnerCrash2() {
1216 UnicastSubject<Integer> us = UnicastSubject.create();
1217 PublishSubject<Integer> ps = PublishSubject.create();
1218
1219 TestObserver<Integer> to = Observable.just(
1220 us.map(v -> {
1221 if (v == 10) {
1222 throw new TestException();
1223 }
1224 return v;
1225 })
1226 .compose(TestHelper.observableStripBoundary())
1227 , ps
1228 )
1229 .flatMap(v -> v, true)
1230 .doOnNext(v -> {
1231 if (v == 1) {
1232 ps.onNext(2);
1233 us.onNext(10);
1234 }
1235 })
1236 .test();
1237
1238 ps.onNext(1);
1239 ps.onComplete();
1240
1241 to.assertFailure(TestException.class, 1, 2);
1242 }
1243
1244 @Test(timeout = 5000)
1245 public void mixedScalarAsync() {
1246 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
1247 Observable
1248 .range(0, 20)
1249 .flatMap(
1250 integer -> {
1251 if (integer % 5 != 0) {
1252 return Observable
1253 .just(integer);
1254 }
1255
1256 return Observable
1257 .just(-integer)
1258 .observeOn(Schedulers.computation());
1259 },
1260 false,
1261 1
1262 )
1263 .ignoreElements()
1264 .blockingAwait();
1265 }
1266 }
1267 }