Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/single/SingleFlatMapIterableFlowableTest.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.single;
15
16 import static org.junit.Assert.*;
17
18 import java.util.*;
19 import java.util.concurrent.TimeUnit;
20
21 import org.junit.Test;
22 import org.reactivestreams.Subscription;
23
24 import io.reactivex.rxjava3.annotations.NonNull;
25 import io.reactivex.rxjava3.core.*;
26 import io.reactivex.rxjava3.exceptions.TestException;
27 import io.reactivex.rxjava3.functions.Function;
28 import io.reactivex.rxjava3.internal.util.CrashingIterable;
29 import io.reactivex.rxjava3.operators.QueueFuseable;
30 import io.reactivex.rxjava3.operators.QueueSubscription;
31 import io.reactivex.rxjava3.schedulers.Schedulers;
32 import io.reactivex.rxjava3.subjects.*;
33 import io.reactivex.rxjava3.subscribers.TestSubscriber;
34 import io.reactivex.rxjava3.testsupport.*;
35
36 public class SingleFlatMapIterableFlowableTest extends RxJavaTest {
37
38 @Test
39 public void normal() {
40
41 Single.just(1).flattenAsFlowable(new Function<Integer, Iterable<Integer>>() {
42 @Override
43 public Iterable<Integer> apply(Integer v) throws Exception {
44 return Arrays.asList(v, v + 1);
45 }
46 })
47 .test()
48 .assertResult(1, 2);
49 }
50
51 @Test
52 public void emptyIterable() {
53
54 Single.just(1).flattenAsFlowable(new Function<Integer, Iterable<Integer>>() {
55 @Override
56 public Iterable<Integer> apply(Integer v) throws Exception {
57 return Collections.<Integer>emptyList();
58 }
59 })
60 .test()
61 .assertResult();
62 }
63
64 @Test
65 public void error() {
66
67 Single.<Integer>error(new TestException()).flattenAsFlowable(new Function<Integer, Iterable<Integer>>() {
68 @Override
69 public Iterable<Integer> apply(Integer v) throws Exception {
70 return Arrays.asList(v, v + 1);
71 }
72 })
73 .test()
74 .assertFailure(TestException.class);
75 }
76
77 @Test
78 public void backpressure() {
79
80 TestSubscriber<Integer> ts = Single.just(1).flattenAsFlowable(new Function<Integer, Iterable<Integer>>() {
81 @Override
82 public Iterable<Integer> apply(Integer v) throws Exception {
83 return Arrays.asList(v, v + 1);
84 }
85 })
86 .test(0);
87
88 ts.assertEmpty();
89
90 ts.request(1);
91
92 ts.assertValue(1);
93
94 ts.request(1);
95
96 ts.assertResult(1, 2);
97 }
98
99 @Test
100 public void take() {
101 Single.just(1).flattenAsFlowable(new Function<Integer, Iterable<Integer>>() {
102 @Override
103 public Iterable<Integer> apply(Integer v) throws Exception {
104 return Arrays.asList(v, v + 1);
105 }
106 })
107 .take(1)
108 .test()
109 .assertResult(1);
110 }
111
112 @Test
113 public void fused() {
114 TestSubscriberEx<Integer> ts = new TestSubscriberEx<Integer>().setInitialFusionMode(QueueFuseable.ANY);
115
116 Single.just(1).flattenAsFlowable(new Function<Integer, Iterable<Integer>>() {
117 @Override
118 public Iterable<Integer> apply(Integer v) throws Exception {
119 return Arrays.asList(v, v + 1);
120 }
121 })
122 .subscribe(ts);
123
124 ts.assertFuseable()
125 .assertFusionMode(QueueFuseable.ASYNC)
126 .assertResult(1, 2);
127 ;
128 }
129
130 @Test
131 public void fusedNoSync() {
132 TestSubscriberEx<Integer> ts = new TestSubscriberEx<Integer>().setInitialFusionMode(QueueFuseable.SYNC);
133
134 Single.just(1).flattenAsFlowable(new Function<Integer, Iterable<Integer>>() {
135 @Override
136 public Iterable<Integer> apply(Integer v) throws Exception {
137 return Arrays.asList(v, v + 1);
138 }
139 })
140 .subscribe(ts);
141
142 ts.assertFuseable()
143 .assertFusionMode(QueueFuseable.NONE)
144 .assertResult(1, 2);
145 ;
146 }
147
148 @Test
149 public void iteratorCrash() {
150
151 Single.just(1).flattenAsFlowable(new Function<Integer, Iterable<Integer>>() {
152 @Override
153 public Iterable<Integer> apply(Integer v) throws Exception {
154 return new CrashingIterable(1, 100, 100);
155 }
156 })
157 .to(TestHelper.<Integer>testConsumer())
158 .assertFailureAndMessage(TestException.class, "iterator()");
159 }
160
161 @Test
162 public void hasNextCrash() {
163
164 Single.just(1).flattenAsFlowable(new Function<Integer, Iterable<Integer>>() {
165 @Override
166 public Iterable<Integer> apply(Integer v) throws Exception {
167 return new CrashingIterable(100, 1, 100);
168 }
169 })
170 .to(TestHelper.<Integer>testConsumer())
171 .assertFailureAndMessage(TestException.class, "hasNext()");
172 }
173
174 @Test
175 public void nextCrash() {
176
177 Single.just(1).flattenAsFlowable(new Function<Integer, Iterable<Integer>>() {
178 @Override
179 public Iterable<Integer> apply(Integer v) throws Exception {
180 return new CrashingIterable(100, 100, 1);
181 }
182 })
183 .to(TestHelper.<Integer>testConsumer())
184 .assertFailureAndMessage(TestException.class, "next()");
185 }
186
187 @Test
188 public void hasNextCrash2() {
189
190 Single.just(1).flattenAsFlowable(new Function<Integer, Iterable<Integer>>() {
191 @Override
192 public Iterable<Integer> apply(Integer v) throws Exception {
193 return new CrashingIterable(100, 2, 100);
194 }
195 })
196 .to(TestHelper.<Integer>testConsumer())
197 .assertFailureAndMessage(TestException.class, "hasNext()", 0);
198 }
199
200 @Test
201 public void async1() {
202 Single.just(1)
203 .flattenAsFlowable(new Function<Object, Iterable<Integer>>() {
204 @Override
205 public Iterable<Integer> apply(Object v) throws Exception {
206 Integer[] array = new Integer[1000 * 1000];
207 Arrays.fill(array, 1);
208 return Arrays.asList(array);
209 }
210 })
211 .hide()
212 .observeOn(Schedulers.single())
213 .to(TestHelper.<Integer>testConsumer())
214 .awaitDone(5, TimeUnit.SECONDS)
215 .assertSubscribed()
216 .assertValueCount(1000 * 1000)
217 .assertNoErrors()
218 .assertComplete();
219 }
220
221 @Test
222 public void async2() {
223 Single.just(1)
224 .flattenAsFlowable(new Function<Object, Iterable<Integer>>() {
225 @Override
226 public Iterable<Integer> apply(Object v) throws Exception {
227 Integer[] array = new Integer[1000 * 1000];
228 Arrays.fill(array, 1);
229 return Arrays.asList(array);
230 }
231 })
232 .observeOn(Schedulers.single())
233 .to(TestHelper.<Integer>testConsumer())
234 .awaitDone(5, TimeUnit.SECONDS)
235 .assertSubscribed()
236 .assertValueCount(1000 * 1000)
237 .assertNoErrors()
238 .assertComplete();
239 }
240
241 @Test
242 public void async3() {
243 Single.just(1)
244 .flattenAsFlowable(new Function<Object, Iterable<Integer>>() {
245 @Override
246 public Iterable<Integer> apply(Object v) throws Exception {
247 Integer[] array = new Integer[1000 * 1000];
248 Arrays.fill(array, 1);
249 return Arrays.asList(array);
250 }
251 })
252 .take(500 * 1000)
253 .observeOn(Schedulers.single())
254 .to(TestHelper.<Integer>testConsumer())
255 .awaitDone(5, TimeUnit.SECONDS)
256 .assertSubscribed()
257 .assertValueCount(500 * 1000)
258 .assertNoErrors()
259 .assertComplete();
260 }
261
262 @Test
263 public void async4() {
264 Single.just(1)
265 .flattenAsFlowable(new Function<Object, Iterable<Integer>>() {
266 @Override
267 public Iterable<Integer> apply(Object v) throws Exception {
268 Integer[] array = new Integer[1000 * 1000];
269 Arrays.fill(array, 1);
270 return Arrays.asList(array);
271 }
272 })
273 .observeOn(Schedulers.single())
274 .take(500 * 1000)
275 .to(TestHelper.<Integer>testConsumer())
276 .awaitDone(5, TimeUnit.SECONDS)
277 .assertSubscribed()
278 .assertValueCount(500 * 1000)
279 .assertNoErrors()
280 .assertComplete();
281 }
282
283 @Test
284 public void fusedEmptyCheck() {
285 Single.just(1)
286 .flattenAsFlowable(new Function<Object, Iterable<Integer>>() {
287 @Override
288 public Iterable<Integer> apply(Object v) throws Exception {
289 return Arrays.asList(1, 2, 3);
290 }
291 }).subscribe(new FlowableSubscriber<Integer>() {
292 QueueSubscription<Integer> qs;
293 @SuppressWarnings("unchecked")
294 @Override
295 public void onSubscribe(Subscription s) {
296 qs = (QueueSubscription<Integer>)s;
297
298 assertEquals(QueueFuseable.ASYNC, qs.requestFusion(QueueFuseable.ANY));
299 }
300
301 @Override
302 public void onNext(Integer value) {
303 assertFalse(qs.isEmpty());
304
305 qs.clear();
306
307 assertTrue(qs.isEmpty());
308
309 qs.cancel();
310 }
311
312 @Override
313 public void onError(Throwable e) {
314 }
315
316 @Override
317 public void onComplete() {
318 }
319 });
320 }
321
322 @Test
323 public void hasNextThrowsUnbounded() {
324 Single.just(1)
325 .flattenAsFlowable(new Function<Object, Iterable<Integer>>() {
326 @Override
327 public Iterable<Integer> apply(Object v) throws Exception {
328 return new CrashingIterable(100, 2, 100);
329 }
330 })
331 .to(TestHelper.<Integer>testConsumer())
332 .assertFailureAndMessage(TestException.class, "hasNext()", 0);
333 }
334
335 @Test
336 public void nextThrowsUnbounded() {
337 Single.just(1)
338 .flattenAsFlowable(new Function<Object, Iterable<Integer>>() {
339 @Override
340 public Iterable<Integer> apply(Object v) throws Exception {
341 return new CrashingIterable(100, 100, 1);
342 }
343 })
344 .to(TestHelper.<Integer>testConsumer())
345 .assertFailureAndMessage(TestException.class, "next()");
346 }
347
348 @Test
349 public void hasNextThrows() {
350 Single.just(1)
351 .flattenAsFlowable(new Function<Object, Iterable<Integer>>() {
352 @Override
353 public Iterable<Integer> apply(Object v) throws Exception {
354 return new CrashingIterable(100, 2, 100);
355 }
356 })
357 .to(TestHelper.<Integer>testSubscriber(2L))
358 .assertFailureAndMessage(TestException.class, "hasNext()", 0);
359 }
360
361 @Test
362 public void nextThrows() {
363 Single.just(1)
364 .flattenAsFlowable(new Function<Object, Iterable<Integer>>() {
365 @Override
366 public Iterable<Integer> apply(Object v) throws Exception {
367 return new CrashingIterable(100, 100, 1);
368 }
369 })
370 .to(TestHelper.<Integer>testSubscriber(2L))
371 .assertFailureAndMessage(TestException.class, "next()");
372 }
373
374 @Test
375 public void requestBefore() {
376 for (int i = 0; i < 500; i++) {
377 final PublishSubject<Integer> ps = PublishSubject.create();
378
379 ps.singleElement().flattenAsFlowable(
380 new Function<Integer, Iterable<Integer>>() {
381 @Override
382 public Iterable<Integer> apply(Integer v) throws Exception {
383 return Arrays.asList(1, 2, 3);
384 }
385 })
386 .test(5L)
387 .assertEmpty();
388 }
389 }
390
391 @Test
392 public void requestCreateInnerRace() {
393 final Integer[] a = new Integer[1000];
394 Arrays.fill(a, 1);
395
396 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
397 final PublishSubject<Integer> ps = PublishSubject.create();
398
399 ps.onNext(1);
400
401 final TestSubscriber<Integer> ts = ps.singleElement().flattenAsFlowable(
402 new Function<Integer, Iterable<Integer>>() {
403 @Override
404 public Iterable<Integer> apply(Integer v) throws Exception {
405 return Arrays.asList(a);
406 }
407 })
408 .test(0L);
409
410 Runnable r1 = new Runnable() {
411 @Override
412 public void run() {
413 ps.onComplete();
414 for (int i = 0; i < 500; i++) {
415 ts.request(1);
416 }
417 }
418 };
419
420 Runnable r2 = new Runnable() {
421 @Override
422 public void run() {
423 for (int i = 0; i < 500; i++) {
424 ts.request(1);
425 }
426 }
427 };
428
429 TestHelper.race(r1, r2);
430 }
431 }
432
433 @Test
434 public void cancelCreateInnerRace() {
435 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
436 final PublishSubject<Integer> ps = PublishSubject.create();
437
438 ps.onNext(1);
439
440 final TestSubscriber<Integer> ts = ps.singleElement().flattenAsFlowable(
441 new Function<Integer, Iterable<Integer>>() {
442 @Override
443 public Iterable<Integer> apply(Integer v) throws Exception {
444 return Arrays.asList(1, 2, 3);
445 }
446 })
447 .test(0L);
448
449 Runnable r1 = new Runnable() {
450 @Override
451 public void run() {
452 ps.onComplete();
453 }
454 };
455
456 Runnable r2 = new Runnable() {
457 @Override
458 public void run() {
459 ts.cancel();
460 }
461 };
462
463 TestHelper.race(r1, r2);
464 }
465 }
466
467 @Test
468 public void slowPathCancelAfterHasNext() {
469 final Integer[] a = new Integer[1000];
470 Arrays.fill(a, 1);
471
472 final TestSubscriber<Integer> ts = new TestSubscriber<>(0L);
473
474 Single.just(1)
475 .flattenAsFlowable(new Function<Integer, Iterable<Integer>>() {
476 @Override
477 public Iterable<Integer> apply(Integer v) throws Exception {
478 return new Iterable<Integer>() {
479 @Override
480 public Iterator<Integer> iterator() {
481 return new Iterator<Integer>() {
482 int count;
483 @Override
484 public boolean hasNext() {
485 if (count++ == 2) {
486 ts.cancel();
487 }
488 return true;
489 }
490
491 @Override
492 public Integer next() {
493 return 1;
494 }
495
496 @Override
497 public void remove() {
498 throw new UnsupportedOperationException();
499 }
500 };
501 }
502 };
503 }
504 })
505 .subscribe(ts);
506
507 ts.request(3);
508 ts.assertValues(1, 1).assertNoErrors().assertNotComplete();
509 }
510
511 @Test
512 public void fastPathCancelAfterHasNext() {
513 final Integer[] a = new Integer[1000];
514 Arrays.fill(a, 1);
515
516 final TestSubscriber<Integer> ts = new TestSubscriber<>(0L);
517
518 Single.just(1)
519 .flattenAsFlowable(new Function<Integer, Iterable<Integer>>() {
520 @Override
521 public Iterable<Integer> apply(Integer v) throws Exception {
522 return new Iterable<Integer>() {
523 @Override
524 public Iterator<Integer> iterator() {
525 return new Iterator<Integer>() {
526 int count;
527 @Override
528 public boolean hasNext() {
529 if (count++ == 2) {
530 ts.cancel();
531 }
532 return true;
533 }
534
535 @Override
536 public Integer next() {
537 return 1;
538 }
539
540 @Override
541 public void remove() {
542 throw new UnsupportedOperationException();
543 }
544 };
545 }
546 };
547 }
548 })
549 .subscribe(ts);
550
551 ts.request(Long.MAX_VALUE);
552 ts.assertValues(1, 1).assertNoErrors().assertNotComplete();
553 }
554
555 @Test
556 public void requestIteratorRace() {
557 final Integer[] a = new Integer[1000];
558 Arrays.fill(a, 1);
559
560 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
561 final PublishSubject<Integer> ps = PublishSubject.create();
562
563 final TestSubscriber<Integer> ts = ps.singleOrError().flattenAsFlowable(new Function<Integer, Iterable<Integer>>() {
564 @Override
565 public Iterable<Integer> apply(Integer v) throws Exception {
566 return Arrays.asList(a);
567 }
568 }).test();
569
570 Runnable r1 = new Runnable() {
571 @Override
572 public void run() {
573 for (int i = 0; i < 1000; i++) {
574 ts.request(1);
575 }
576 }
577 };
578
579 Runnable r2 = new Runnable() {
580 @Override
581 public void run() {
582 ps.onNext(1);
583 ps.onComplete();
584 }
585 };
586
587 TestHelper.race(r1, r2);
588 }
589 }
590
591 @Test
592 public void doubleOnSubscribe() {
593 TestHelper.checkDoubleOnSubscribeSingleToFlowable(s -> s.flattenAsFlowable(v -> Collections.emptyList()));
594 }
595
596 @Test
597 public void badRequest() {
598 TestHelper.assertBadRequestReported(SingleSubject.create().flattenAsFlowable(v -> Collections.emptyList()));
599 }
600
601 @Test
602 public void slowPatchCancelAfterOnNext() {
603 TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
604 @Override
605 public void onNext(@NonNull Integer t) {
606 super.onNext(t);
607 cancel();
608 onComplete();
609 }
610 };
611
612 Single.just(1)
613 .flattenAsFlowable(v -> Arrays.asList(1, 2))
614 .subscribe(ts);
615
616 ts.assertResult(1);
617 }
618
619 @Test
620 public void onSuccessRequestRace() {
621 List<Object> list = Arrays.asList(1);
622 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
623
624 SingleSubject<Integer> ss = SingleSubject.create();
625
626 TestSubscriber<Object> ts = ss.flattenAsFlowable(v -> list)
627 .test(0L);
628
629 TestHelper.race(
630 () -> ss.onSuccess(1),
631 () -> ts.request(1)
632 );
633
634 ts.assertResult(1);
635 }
636 }
637 }