Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/mixed/FlowableSwitchMapSingleTest.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.AtomicReference;
20
21 import io.reactivex.rxjava3.disposables.Disposable;
22 import org.junit.Test;
23 import org.reactivestreams.*;
24
25 import io.reactivex.rxjava3.core.*;
26 import io.reactivex.rxjava3.exceptions.*;
27 import io.reactivex.rxjava3.functions.*;
28 import io.reactivex.rxjava3.internal.functions.Functions;
29 import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
30 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
31 import io.reactivex.rxjava3.processors.PublishProcessor;
32 import io.reactivex.rxjava3.subjects.SingleSubject;
33 import io.reactivex.rxjava3.subscribers.TestSubscriber;
34 import io.reactivex.rxjava3.testsupport.*;
35
36 public class FlowableSwitchMapSingleTest extends RxJavaTest {
37
38 @Test
39 public void simple() {
40 Flowable.range(1, 5)
41 .switchMapSingle(new Function<Integer, SingleSource<Integer>>() {
42 @Override
43 public SingleSource<Integer> apply(Integer v)
44 throws Exception {
45 return Single.just(v);
46 }
47 })
48 .test()
49 .assertResult(1, 2, 3, 4, 5);
50 }
51
52 @Test
53 public void mainError() {
54 Flowable.error(new TestException())
55 .switchMapSingle(Functions.justFunction(Single.never()))
56 .test()
57 .assertFailure(TestException.class);
58 }
59
60 @Test
61 public void innerError() {
62 Flowable.just(1)
63 .switchMapSingle(Functions.justFunction(Single.error(new TestException())))
64 .test()
65 .assertFailure(TestException.class);
66 }
67
68 @Test
69 public void doubleOnSubscribe() {
70 TestHelper.checkDoubleOnSubscribeFlowable(new Function<Flowable<Object>, Publisher<Object>>() {
71 @Override
72 public Publisher<Object> apply(Flowable<Object> f)
73 throws Exception {
74 return f
75 .switchMapSingle(Functions.justFunction(Single.never()));
76 }
77 }
78 );
79 }
80
81 @Test
82 public void limit() {
83 Flowable.range(1, 5)
84 .switchMapSingle(new Function<Integer, SingleSource<Integer>>() {
85 @Override
86 public SingleSource<Integer> apply(Integer v)
87 throws Exception {
88 return Single.just(v);
89 }
90 })
91 .take(3)
92 .test()
93 .assertResult(1, 2, 3);
94 }
95
96 @Test
97 public void switchOver() {
98 PublishProcessor<Integer> pp = PublishProcessor.create();
99
100 final SingleSubject<Integer> ms1 = SingleSubject.create();
101 final SingleSubject<Integer> ms2 = SingleSubject.create();
102
103 TestSubscriber<Integer> ts = pp.switchMapSingle(new Function<Integer, SingleSource<Integer>>() {
104 @Override
105 public SingleSource<Integer> apply(Integer v)
106 throws Exception {
107 if (v == 1) {
108 return ms1;
109 }
110 return ms2;
111 }
112 }).test();
113
114 ts.assertEmpty();
115
116 pp.onNext(1);
117
118 ts.assertEmpty();
119
120 assertTrue(ms1.hasObservers());
121
122 pp.onNext(2);
123
124 assertFalse(ms1.hasObservers());
125 assertTrue(ms2.hasObservers());
126
127 ms2.onError(new TestException());
128
129 assertFalse(pp.hasSubscribers());
130
131 ts.assertFailure(TestException.class);
132 }
133
134 @Test
135 public void switchOverDelayError() {
136 PublishProcessor<Integer> pp = PublishProcessor.create();
137
138 final SingleSubject<Integer> ms1 = SingleSubject.create();
139 final SingleSubject<Integer> ms2 = SingleSubject.create();
140
141 TestSubscriber<Integer> ts = pp.switchMapSingleDelayError(new Function<Integer, SingleSource<Integer>>() {
142 @Override
143 public SingleSource<Integer> apply(Integer v)
144 throws Exception {
145 if (v == 1) {
146 return ms1;
147 }
148 return ms2;
149 }
150 }).test();
151
152 ts.assertEmpty();
153
154 pp.onNext(1);
155
156 ts.assertEmpty();
157
158 assertTrue(ms1.hasObservers());
159
160 pp.onNext(2);
161
162 assertFalse(ms1.hasObservers());
163 assertTrue(ms2.hasObservers());
164
165 ms2.onError(new TestException());
166
167 ts.assertEmpty();
168
169 assertTrue(pp.hasSubscribers());
170
171 pp.onComplete();
172
173 ts.assertFailure(TestException.class);
174 }
175
176 @Test
177 public void mainErrorInnerCompleteDelayError() {
178 PublishProcessor<Integer> pp = PublishProcessor.create();
179
180 final SingleSubject<Integer> ms = SingleSubject.create();
181
182 TestSubscriber<Integer> ts = pp.switchMapSingleDelayError(new Function<Integer, SingleSource<Integer>>() {
183 @Override
184 public SingleSource<Integer> apply(Integer v)
185 throws Exception {
186 return ms;
187 }
188 }).test();
189
190 ts.assertEmpty();
191
192 pp.onNext(1);
193
194 ts.assertEmpty();
195
196 assertTrue(ms.hasObservers());
197
198 pp.onError(new TestException());
199
200 assertTrue(ms.hasObservers());
201
202 ts.assertEmpty();
203
204 ms.onSuccess(1);
205
206 ts.assertFailure(TestException.class, 1);
207 }
208
209 @Test
210 public void mainErrorInnerSuccessDelayError() {
211 PublishProcessor<Integer> pp = PublishProcessor.create();
212
213 final SingleSubject<Integer> ms = SingleSubject.create();
214
215 TestSubscriber<Integer> ts = pp.switchMapSingleDelayError(new Function<Integer, SingleSource<Integer>>() {
216 @Override
217 public SingleSource<Integer> apply(Integer v)
218 throws Exception {
219 return ms;
220 }
221 }).test();
222
223 ts.assertEmpty();
224
225 pp.onNext(1);
226
227 ts.assertEmpty();
228
229 assertTrue(ms.hasObservers());
230
231 pp.onError(new TestException());
232
233 assertTrue(ms.hasObservers());
234
235 ts.assertEmpty();
236
237 ms.onSuccess(1);
238
239 ts.assertFailure(TestException.class, 1);
240 }
241
242 @Test
243 public void mapperCrash() {
244 Flowable.just(1)
245 .switchMapSingle(new Function<Integer, SingleSource<? extends Object>>() {
246 @Override
247 public SingleSource<? extends Object> apply(Integer v)
248 throws Exception {
249 throw new TestException();
250 }
251 })
252 .test()
253 .assertFailure(TestException.class);
254 }
255
256 @Test
257 public void disposeBeforeSwitchInOnNext() {
258 final TestSubscriber<Integer> ts = new TestSubscriber<>();
259
260 Flowable.just(1)
261 .switchMapSingle(new Function<Integer, SingleSource<Integer>>() {
262 @Override
263 public SingleSource<Integer> apply(Integer v)
264 throws Exception {
265 ts.cancel();
266 return Single.just(1);
267 }
268 }).subscribe(ts);
269
270 ts.assertEmpty();
271 }
272
273 @Test
274 public void disposeOnNextAfterFirst() {
275 final TestSubscriber<Integer> ts = new TestSubscriber<>();
276
277 Flowable.just(1, 2)
278 .switchMapSingle(new Function<Integer, SingleSource<Integer>>() {
279 @Override
280 public SingleSource<Integer> apply(Integer v)
281 throws Exception {
282 if (v == 2) {
283 ts.cancel();
284 }
285 return Single.just(1);
286 }
287 }).subscribe(ts);
288
289 ts.assertValue(1)
290 .assertNoErrors()
291 .assertNotComplete();
292 }
293
294 @Test
295 public void cancel() {
296 PublishProcessor<Integer> pp = PublishProcessor.create();
297
298 final SingleSubject<Integer> ms = SingleSubject.create();
299
300 TestSubscriber<Integer> ts = pp.switchMapSingleDelayError(new Function<Integer, SingleSource<Integer>>() {
301 @Override
302 public SingleSource<Integer> apply(Integer v)
303 throws Exception {
304 return ms;
305 }
306 }).test();
307
308 ts.assertEmpty();
309
310 pp.onNext(1);
311
312 ts.assertEmpty();
313
314 assertTrue(pp.hasSubscribers());
315 assertTrue(ms.hasObservers());
316
317 ts.cancel();
318
319 assertFalse(pp.hasSubscribers());
320 assertFalse(ms.hasObservers());
321 }
322
323 @Test
324 public void mainErrorAfterTermination() {
325 List<Throwable> errors = TestHelper.trackPluginErrors();
326 try {
327 new Flowable<Integer>() {
328 @Override
329 protected void subscribeActual(Subscriber<? super Integer> s) {
330 s.onSubscribe(new BooleanSubscription());
331 s.onNext(1);
332 s.onError(new TestException("outer"));
333 }
334 }
335 .switchMapSingle(new Function<Integer, SingleSource<Integer>>() {
336 @Override
337 public SingleSource<Integer> apply(Integer v)
338 throws Exception {
339 return Single.error(new TestException("inner"));
340 }
341 })
342 .to(TestHelper.<Integer>testConsumer())
343 .assertFailureAndMessage(TestException.class, "inner");
344
345 TestHelper.assertUndeliverable(errors, 0, TestException.class, "outer");
346 } finally {
347 RxJavaPlugins.reset();
348 }
349 }
350
351 @Test
352 public void innerErrorAfterTermination() {
353 List<Throwable> errors = TestHelper.trackPluginErrors();
354 try {
355 final AtomicReference<SingleObserver<? super Integer>> moRef = new AtomicReference<>();
356
357 TestSubscriberEx<Integer> ts = new Flowable<Integer>() {
358 @Override
359 protected void subscribeActual(Subscriber<? super Integer> s) {
360 s.onSubscribe(new BooleanSubscription());
361 s.onNext(1);
362 s.onError(new TestException("outer"));
363 }
364 }
365 .switchMapSingle(new Function<Integer, SingleSource<Integer>>() {
366 @Override
367 public SingleSource<Integer> apply(Integer v)
368 throws Exception {
369 return new Single<Integer>() {
370 @Override
371 protected void subscribeActual(
372 SingleObserver<? super Integer> observer) {
373 observer.onSubscribe(Disposable.empty());
374 moRef.set(observer);
375 }
376 };
377 }
378 })
379 .to(TestHelper.<Integer>testConsumer());
380
381 ts.assertFailureAndMessage(TestException.class, "outer");
382
383 moRef.get().onError(new TestException("inner"));
384
385 TestHelper.assertUndeliverable(errors, 0, TestException.class, "inner");
386 } finally {
387 RxJavaPlugins.reset();
388 }
389 }
390
391 @Test
392 public void nextCancelRace() {
393 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
394
395 final PublishProcessor<Integer> pp = PublishProcessor.create();
396
397 final SingleSubject<Integer> ms = SingleSubject.create();
398
399 final TestSubscriber<Integer> ts = pp.switchMapSingleDelayError(new Function<Integer, SingleSource<Integer>>() {
400 @Override
401 public SingleSource<Integer> apply(Integer v)
402 throws Exception {
403 return ms;
404 }
405 }).test();
406
407 Runnable r1 = new Runnable() {
408 @Override
409 public void run() {
410 pp.onNext(1);
411 }
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 .assertNotComplete();
425 }
426 }
427
428 @Test
429 public void nextInnerErrorRace() {
430 final TestException ex = new TestException();
431
432 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
433
434 List<Throwable> errors = TestHelper.trackPluginErrors();
435 try {
436 final PublishProcessor<Integer> pp = PublishProcessor.create();
437
438 final SingleSubject<Integer> ms = SingleSubject.create();
439
440 final TestSubscriberEx<Integer> ts = pp.switchMapSingleDelayError(new Function<Integer, SingleSource<Integer>>() {
441 @Override
442 public SingleSource<Integer> apply(Integer v)
443 throws Exception {
444 if (v == 1) {
445 return ms;
446 }
447 return Single.never();
448 }
449 }).to(TestHelper.<Integer>testConsumer());
450
451 pp.onNext(1);
452
453 Runnable r1 = new Runnable() {
454 @Override
455 public void run() {
456 pp.onNext(2);
457 }
458 };
459
460 Runnable r2 = new Runnable() {
461 @Override
462 public void run() {
463 ms.onError(ex);
464 }
465 };
466
467 TestHelper.race(r1, r2);
468
469 if (ts.errors().size() != 0) {
470 assertTrue(errors.isEmpty());
471 ts.assertFailure(TestException.class);
472 } else if (!errors.isEmpty()) {
473 TestHelper.assertUndeliverable(errors, 0, TestException.class);
474 }
475 } finally {
476 RxJavaPlugins.reset();
477 }
478 }
479 }
480
481 @Test
482 public void mainErrorInnerErrorRace() {
483 final TestException ex = new TestException();
484 final TestException ex2 = new TestException();
485
486 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
487
488 List<Throwable> errors = TestHelper.trackPluginErrors();
489 try {
490 final PublishProcessor<Integer> pp = PublishProcessor.create();
491
492 final SingleSubject<Integer> ms = SingleSubject.create();
493
494 final TestSubscriber<Integer> ts = pp.switchMapSingleDelayError(new Function<Integer, SingleSource<Integer>>() {
495 @Override
496 public SingleSource<Integer> apply(Integer v)
497 throws Exception {
498 if (v == 1) {
499 return ms;
500 }
501 return Single.never();
502 }
503 }).test();
504
505 pp.onNext(1);
506
507 Runnable r1 = new Runnable() {
508 @Override
509 public void run() {
510 pp.onError(ex);
511 }
512 };
513
514 Runnable r2 = new Runnable() {
515 @Override
516 public void run() {
517 ms.onError(ex2);
518 }
519 };
520
521 TestHelper.race(r1, r2);
522
523 ts.assertError(new Predicate<Throwable>() {
524 @Override
525 public boolean test(Throwable e) throws Exception {
526 return e instanceof TestException || e instanceof CompositeException;
527 }
528 });
529
530 if (!errors.isEmpty()) {
531 TestHelper.assertUndeliverable(errors, 0, TestException.class);
532 }
533 } finally {
534 RxJavaPlugins.reset();
535 }
536 }
537 }
538
539 @Test
540 public void nextInnerSuccessRace() {
541 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
542
543 final PublishProcessor<Integer> pp = PublishProcessor.create();
544
545 final SingleSubject<Integer> ms = SingleSubject.create();
546
547 final TestSubscriber<Integer> ts = pp.switchMapSingleDelayError(new Function<Integer, SingleSource<Integer>>() {
548 @Override
549 public SingleSource<Integer> apply(Integer v)
550 throws Exception {
551 if (v == 1) {
552 return ms;
553 }
554 return Single.never();
555 }
556 }).test();
557
558 pp.onNext(1);
559
560 Runnable r1 = new Runnable() {
561 @Override
562 public void run() {
563 pp.onNext(2);
564 }
565 };
566
567 Runnable r2 = new Runnable() {
568 @Override
569 public void run() {
570 ms.onSuccess(3);
571 }
572 };
573
574 TestHelper.race(r1, r2);
575
576 ts.assertNoErrors()
577 .assertNotComplete();
578 }
579 }
580
581 @Test
582 public void requestMoreOnNext() {
583 TestSubscriber<Integer> ts = new TestSubscriber<Integer>(1) {
584 @Override
585 public void onNext(Integer t) {
586 super.onNext(t);
587 requestMore(1);
588 }
589 };
590 Flowable.range(1, 5)
591 .switchMapSingle(Functions.justFunction(Single.just(1)))
592 .subscribe(ts);
593
594 ts.assertResult(1, 1, 1, 1, 1);
595 }
596
597 @Test
598 public void backpressured() {
599 Flowable.just(1)
600 .switchMapSingle(Functions.justFunction(Single.just(1)))
601 .test(0)
602 .assertEmpty()
603 .requestMore(1)
604 .assertResult(1);
605 }
606
607 @Test
608 public void undeliverableUponCancel() {
609 TestHelper.checkUndeliverableUponCancel(new FlowableConverter<Integer, Flowable<Integer>>() {
610 @Override
611 public Flowable<Integer> apply(Flowable<Integer> upstream) {
612 return upstream.switchMapSingle(new Function<Integer, Single<Integer>>() {
613 @Override
614 public Single<Integer> apply(Integer v) throws Throwable {
615 return Single.just(v).hide();
616 }
617 });
618 }
619 });
620 }
621
622 @Test
623 public void undeliverableUponCancelDelayError() {
624 TestHelper.checkUndeliverableUponCancel(new FlowableConverter<Integer, Flowable<Integer>>() {
625 @Override
626 public Flowable<Integer> apply(Flowable<Integer> upstream) {
627 return upstream.switchMapSingleDelayError(new Function<Integer, Single<Integer>>() {
628 @Override
629 public Single<Integer> apply(Integer v) throws Throwable {
630 return Single.just(v).hide();
631 }
632 });
633 }
634 });
635 }
636 }