Debian Codegraph @

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