Debian Codegraph @

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