Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/mixed/FlowableConcatMapMaybeTest.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.TimeUnit;
20 import java.util.concurrent.atomic.AtomicReference;
21
22 import org.junit.Test;
23 import org.reactivestreams.Subscriber;
24
25 import io.reactivex.rxjava3.core.*;
26 import io.reactivex.rxjava3.disposables.Disposable;
27 import io.reactivex.rxjava3.exceptions.*;
28 import io.reactivex.rxjava3.functions.Function;
29 import io.reactivex.rxjava3.internal.functions.Functions;
30 import io.reactivex.rxjava3.internal.operators.mixed.FlowableConcatMapMaybe.ConcatMapMaybeSubscriber;
31 import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
32 import io.reactivex.rxjava3.internal.util.ErrorMode;
33 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
34 import io.reactivex.rxjava3.processors.*;
35 import io.reactivex.rxjava3.schedulers.Schedulers;
36 import io.reactivex.rxjava3.subjects.MaybeSubject;
37 import io.reactivex.rxjava3.subscribers.TestSubscriber;
38 import io.reactivex.rxjava3.testsupport.*;
39
40 public class FlowableConcatMapMaybeTest extends RxJavaTest {
41
42 @Test
43 public void simple() {
44 Flowable.range(1, 5)
45 .concatMapMaybe(new Function<Integer, MaybeSource<Integer>>() {
46 @Override
47 public MaybeSource<Integer> apply(Integer v)
48 throws Exception {
49 return Maybe.just(v);
50 }
51 })
52 .test()
53 .assertResult(1, 2, 3, 4, 5);
54 }
55
56 @Test
57 public void simpleLongPrefetch() {
58 Flowable.range(1, 1024)
59 .concatMapMaybe(Maybe::just, 32)
60 .test()
61 .assertValueCount(1024)
62 .assertNoErrors()
63 .assertComplete();
64 }
65
66 @Test
67 public void simpleLongPrefetchHidden() {
68 Flowable.range(1, 1024).hide()
69 .concatMapMaybe(Maybe::just, 32)
70 .test()
71 .assertValueCount(1024)
72 .assertNoErrors()
73 .assertComplete();
74 }
75
76 @Test
77 public void backpressure() {
78 TestSubscriber<Integer> ts = Flowable.range(1, 1024)
79 .concatMapMaybe(new Function<Integer, MaybeSource<Integer>>() {
80 @Override
81 public MaybeSource<Integer> apply(Integer v)
82 throws Exception {
83 return Maybe.just(v);
84 }
85 }, 32)
86 .test(0);
87
88 for (int i = 1; i <= 1024; i++) {
89 ts.assertValueCount(i - 1)
90 .assertNoErrors()
91 .assertNotComplete()
92 .requestMore(1)
93 .assertValueCount(i)
94 .assertNoErrors();
95 }
96
97 ts.assertComplete();
98 }
99
100 @Test
101 public void empty() {
102 Flowable.range(1, 10)
103 .concatMapMaybe(new Function<Integer, MaybeSource<Integer>>() {
104 @Override
105 public MaybeSource<Integer> apply(Integer v)
106 throws Exception {
107 return Maybe.empty();
108 }
109 })
110 .test()
111 .assertResult();
112 }
113
114 @Test
115 public void mixed() {
116 Flowable.range(1, 10)
117 .concatMapMaybe(new Function<Integer, MaybeSource<Integer>>() {
118 @Override
119 public MaybeSource<Integer> apply(Integer v)
120 throws Exception {
121 if (v % 2 == 0) {
122 return Maybe.just(v);
123 }
124 return Maybe.empty();
125 }
126 })
127 .test()
128 .assertResult(2, 4, 6, 8, 10);
129 }
130
131 @Test
132 public void mixedLong() {
133 TestSubscriberEx<Integer> ts = Flowable.range(1, 1024)
134 .concatMapMaybe(new Function<Integer, MaybeSource<Integer>>() {
135 @Override
136 public MaybeSource<Integer> apply(Integer v)
137 throws Exception {
138 if (v % 2 == 0) {
139 return Maybe.just(v).subscribeOn(Schedulers.computation());
140 }
141 return Maybe.<Integer>empty().subscribeOn(Schedulers.computation());
142 }
143 })
144 .to(TestHelper.<Integer>testConsumer())
145 .awaitDone(5, TimeUnit.SECONDS)
146 .assertValueCount(512)
147 .assertNoErrors()
148 .assertComplete()
149 ;
150
151 for (int i = 0; i < 512; i ++) {
152 ts.assertValueAt(i, (i + 1) * 2);
153 }
154 }
155
156 @Test
157 public void mainError() {
158 Flowable.error(new TestException())
159 .concatMapMaybe(Functions.justFunction(Maybe.just(1)))
160 .test()
161 .assertFailure(TestException.class);
162 }
163
164 @Test
165 public void innerError() {
166 Flowable.just(1)
167 .concatMapMaybe(Functions.justFunction(Maybe.error(new TestException())))
168 .test()
169 .assertFailure(TestException.class);
170 }
171
172 @Test
173 public void mainBoundaryErrorInnerSuccess() {
174 PublishProcessor<Integer> pp = PublishProcessor.create();
175 MaybeSubject<Integer> ms = MaybeSubject.create();
176
177 TestSubscriber<Integer> ts = pp.concatMapMaybeDelayError(Functions.justFunction(ms), false).test();
178
179 ts.assertEmpty();
180
181 pp.onNext(1);
182
183 assertTrue(ms.hasObservers());
184
185 pp.onError(new TestException());
186
187 assertTrue(ms.hasObservers());
188
189 ts.assertEmpty();
190
191 ms.onSuccess(1);
192
193 ts.assertFailure(TestException.class, 1);
194 }
195
196 @Test
197 public void mainBoundaryErrorInnerEmpty() {
198 PublishProcessor<Integer> pp = PublishProcessor.create();
199 MaybeSubject<Integer> ms = MaybeSubject.create();
200
201 TestSubscriber<Integer> ts = pp.concatMapMaybeDelayError(Functions.justFunction(ms), false).test();
202
203 ts.assertEmpty();
204
205 pp.onNext(1);
206
207 assertTrue(ms.hasObservers());
208
209 pp.onError(new TestException());
210
211 assertTrue(ms.hasObservers());
212
213 ts.assertEmpty();
214
215 ms.onComplete();
216
217 ts.assertFailure(TestException.class);
218 }
219
220 @Test
221 public void doubleOnSubscribe() {
222 TestHelper.checkDoubleOnSubscribeFlowable(
223 new Function<Flowable<Object>, Flowable<Object>>() {
224 @Override
225 public Flowable<Object> apply(Flowable<Object> f)
226 throws Exception {
227 return f.concatMapMaybeDelayError(
228 Functions.justFunction(Maybe.empty()));
229 }
230 }
231 );
232 }
233
234 @Test
235 public void queueOverflow() {
236 List<Throwable> errors = TestHelper.trackPluginErrors();
237 try {
238 new Flowable<Integer>() {
239 @Override
240 protected void subscribeActual(Subscriber<? super Integer> s) {
241 s.onSubscribe(new BooleanSubscription());
242 s.onNext(1);
243 s.onNext(2);
244 s.onNext(3);
245 s.onError(new TestException());
246 }
247 }
248 .concatMapMaybe(
249 Functions.justFunction(Maybe.never()), 1
250 )
251 .test()
252 .assertFailure(MissingBackpressureException.class);
253
254 TestHelper.assertUndeliverable(errors, 0, TestException.class);
255 } finally {
256 RxJavaPlugins.reset();
257 }
258 }
259
260 @Test
261 public void limit() {
262 Flowable.range(1, 5)
263 .concatMapMaybe(new Function<Integer, MaybeSource<Integer>>() {
264 @Override
265 public MaybeSource<Integer> apply(Integer v)
266 throws Exception {
267 return Maybe.just(v);
268 }
269 })
270 .take(3)
271 .test()
272 .assertResult(1, 2, 3);
273 }
274
275 @Test
276 public void cancel() {
277 Flowable.range(1, 5)
278 .concatMapMaybe(new Function<Integer, MaybeSource<Integer>>() {
279 @Override
280 public MaybeSource<Integer> apply(Integer v)
281 throws Exception {
282 return Maybe.just(v);
283 }
284 })
285 .test(3)
286 .assertValues(1, 2, 3)
287 .assertNoErrors()
288 .assertNotComplete()
289 .cancel();
290 }
291
292 @Test
293 public void innerErrorAfterMainError() {
294 List<Throwable> errors = TestHelper.trackPluginErrors();
295 try {
296 final PublishProcessor<Integer> pp = PublishProcessor.create();
297
298 final AtomicReference<MaybeObserver<? super Integer>> obs = new AtomicReference<>();
299
300 TestSubscriberEx<Integer> ts = pp.concatMapMaybe(
301 new Function<Integer, MaybeSource<Integer>>() {
302 @Override
303 public MaybeSource<Integer> apply(Integer v)
304 throws Exception {
305 return new Maybe<Integer>() {
306 @Override
307 protected void subscribeActual(
308 MaybeObserver<? super Integer> observer) {
309 observer.onSubscribe(Disposable.empty());
310 obs.set(observer);
311 }
312 };
313 }
314 }
315 ).to(TestHelper.<Integer>testConsumer());
316
317 pp.onNext(1);
318
319 pp.onError(new TestException("outer"));
320 obs.get().onError(new TestException("inner"));
321
322 ts.assertFailureAndMessage(TestException.class, "outer");
323
324 TestHelper.assertUndeliverable(errors, 0, TestException.class, "inner");
325 } finally {
326 RxJavaPlugins.reset();
327 }
328 }
329
330 @Test
331 public void delayAllErrors() {
332 TestSubscriberEx<Object> ts = Flowable.range(1, 5)
333 .concatMapMaybeDelayError(new Function<Integer, MaybeSource<? extends Object>>() {
334 @Override
335 public MaybeSource<? extends Object> apply(Integer v)
336 throws Exception {
337 return Maybe.error(new TestException());
338 }
339 })
340 .to(TestHelper.<Object>testConsumer())
341 .assertFailure(CompositeException.class)
342 ;
343
344 CompositeException ce = (CompositeException)ts.errors().get(0);
345 assertEquals(5, ce.getExceptions().size());
346 }
347
348 @Test
349 public void mapperCrash() {
350 final PublishProcessor<Integer> pp = PublishProcessor.create();
351
352 TestSubscriber<Object> ts = pp
353 .concatMapMaybe(new Function<Integer, MaybeSource<? extends Object>>() {
354 @Override
355 public MaybeSource<? extends Object> apply(Integer v)
356 throws Exception {
357 throw new TestException();
358 }
359 })
360 .test();
361
362 ts.assertEmpty();
363
364 assertTrue(pp.hasSubscribers());
365
366 pp.onNext(1);
367
368 ts.assertFailure(TestException.class);
369
370 assertFalse(pp.hasSubscribers());
371 }
372
373 @Test
374 public void cancelNoConcurrentClean() {
375 TestSubscriber<Integer> ts = new TestSubscriber<>();
376 ConcatMapMaybeSubscriber<Integer, Integer> operator =
377 new ConcatMapMaybeSubscriber<>(
378 ts, Functions.justFunction(Maybe.<Integer>never()), 16, ErrorMode.IMMEDIATE);
379
380 operator.onSubscribe(new BooleanSubscription());
381
382 operator.queue.offer(1);
383
384 operator.getAndIncrement();
385
386 ts.cancel();
387
388 assertFalse(operator.queue.isEmpty());
389
390 operator.addAndGet(-2);
391
392 operator.cancel();
393
394 assertTrue(operator.queue.isEmpty());
395 }
396
397 @Test
398 public void innerSuccessDisposeRace() {
399 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
400
401 final MaybeSubject<Integer> ms = MaybeSubject.create();
402
403 final TestSubscriber<Integer> ts = Flowable.just(1)
404 .hide()
405 .concatMapMaybe(Functions.justFunction(ms))
406 .test();
407
408 Runnable r1 = new Runnable() {
409 @Override
410 public void run() {
411 ms.onSuccess(1);
412 }
413 };
414 Runnable r2 = new Runnable() {
415 @Override
416 public void run() {
417 ts.cancel();
418 }
419 };
420
421 TestHelper.race(r1, r2);
422
423 ts.assertNoErrors();
424 }
425 }
426
427 @Test
428 public void undeliverableUponCancel() {
429 TestHelper.checkUndeliverableUponCancel(new FlowableConverter<Integer, Flowable<Integer>>() {
430 @Override
431 public Flowable<Integer> apply(Flowable<Integer> upstream) {
432 return upstream.concatMapMaybe(new Function<Integer, Maybe<Integer>>() {
433 @Override
434 public Maybe<Integer> apply(Integer v) throws Throwable {
435 return Maybe.just(v).hide();
436 }
437 });
438 }
439 });
440 }
441
442 @Test
443 public void undeliverableUponCancelDelayError() {
444 TestHelper.checkUndeliverableUponCancel(new FlowableConverter<Integer, Flowable<Integer>>() {
445 @Override
446 public Flowable<Integer> apply(Flowable<Integer> upstream) {
447 return upstream.concatMapMaybeDelayError(new Function<Integer, Maybe<Integer>>() {
448 @Override
449 public Maybe<Integer> apply(Integer v) throws Throwable {
450 return Maybe.just(v).hide();
451 }
452 }, false, 2);
453 }
454 });
455 }
456
457 @Test
458 public void undeliverableUponCancelDelayErrorTillEnd() {
459 TestHelper.checkUndeliverableUponCancel(new FlowableConverter<Integer, Flowable<Integer>>() {
460 @Override
461 public Flowable<Integer> apply(Flowable<Integer> upstream) {
462 return upstream.concatMapMaybeDelayError(new Function<Integer, Maybe<Integer>>() {
463 @Override
464 public Maybe<Integer> apply(Integer v) throws Throwable {
465 return Maybe.just(v).hide();
466 }
467 }, true, 2);
468 }
469 });
470 }
471
472 @Test
473 public void basicNonFused() {
474 Flowable.range(1, 5).hide()
475 .concatMapMaybe(v -> Maybe.just(v).hide())
476 .test()
477 .assertResult(1, 2, 3, 4, 5);
478 }
479
480 @Test
481 public void basicSyncFused() {
482 Flowable.range(1, 5)
483 .concatMapMaybe(v -> Maybe.just(v).hide())
484 .test()
485 .assertResult(1, 2, 3, 4, 5);
486 }
487
488 @Test
489 public void basicAsyncFused() {
490 UnicastProcessor<Integer> up = UnicastProcessor.create();
491 TestHelper.emit(up, 1, 2, 3, 4, 5);
492
493 up
494 .concatMapMaybe(v -> Maybe.just(v).hide())
495 .test()
496 .assertResult(1, 2, 3, 4, 5);
497 }
498
499 @Test
500 public void basicFusionRejected() {
501 TestHelper.<Integer>rejectFlowableFusion()
502 .concatMapMaybe(v -> Maybe.just(v).hide())
503 .test()
504 .assertEmpty();
505 }
506
507 @Test
508 public void fusedPollCrash() {
509 Flowable.range(1, 5)
510 .map(v -> {
511 if (v == 3) {
512 throw new TestException();
513 }
514 return v;
515 })
516 .compose(TestHelper.flowableStripBoundary())
517 .concatMapMaybe(v -> Maybe.just(v).hide())
518 .test()
519 .assertFailure(TestException.class, 1, 2);
520 }
521 }