Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableSwitchTest.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.observable;
15
16 import static org.junit.Assert.*;
17 import static org.mockito.ArgumentMatchers.*;
18 import static org.mockito.Mockito.*;
19
20 import java.util.*;
21 import java.util.concurrent.TimeUnit;
22 import java.util.concurrent.atomic.*;
23
24 import org.junit.*;
25 import org.mockito.InOrder;
26
27 import io.reactivex.rxjava3.annotations.NonNull;
28 import io.reactivex.rxjava3.core.*;
29 import io.reactivex.rxjava3.core.Observable;
30 import io.reactivex.rxjava3.core.Observer;
31 import io.reactivex.rxjava3.disposables.Disposable;
32 import io.reactivex.rxjava3.exceptions.*;
33 import io.reactivex.rxjava3.functions.*;
34 import io.reactivex.rxjava3.internal.functions.Functions;
35 import io.reactivex.rxjava3.internal.schedulers.ImmediateThinScheduler;
36 import io.reactivex.rxjava3.internal.util.ExceptionHelper;
37 import io.reactivex.rxjava3.observers.*;
38 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
39 import io.reactivex.rxjava3.schedulers.*;
40 import io.reactivex.rxjava3.subjects.PublishSubject;
41 import io.reactivex.rxjava3.testsupport.*;
42
43 public class ObservableSwitchTest extends RxJavaTest {
44
45 private TestScheduler scheduler;
46 private Scheduler.Worker innerScheduler;
47 private Observer<String> observer;
48
49 @Before
50 public void before() {
51 scheduler = new TestScheduler();
52 innerScheduler = scheduler.createWorker();
53 observer = TestHelper.mockObserver();
54 }
55
56 @Test
57 public void switchWhenOuterCompleteBeforeInner() {
58 Observable<Observable<String>> source = Observable.unsafeCreate(new ObservableSource<Observable<String>>() {
59 @Override
60 public void subscribe(Observer<? super Observable<String>> outerObserver) {
61 outerObserver.onSubscribe(Disposable.empty());
62 publishNext(outerObserver, 50, Observable.unsafeCreate(new ObservableSource<String>() {
63 @Override
64 public void subscribe(Observer<? super String> innerObserver) {
65 innerObserver.onSubscribe(Disposable.empty());
66 publishNext(innerObserver, 70, "one");
67 publishNext(innerObserver, 100, "two");
68 publishCompleted(innerObserver, 200);
69 }
70 }));
71 publishCompleted(outerObserver, 60);
72 }
73 });
74
75 Observable<String> sampled = Observable.switchOnNext(source);
76 sampled.subscribe(observer);
77
78 InOrder inOrder = inOrder(observer);
79
80 scheduler.advanceTimeTo(350, TimeUnit.MILLISECONDS);
81 inOrder.verify(observer, times(2)).onNext(anyString());
82 inOrder.verify(observer, times(1)).onComplete();
83 }
84
85 @Test
86 public void switchWhenInnerCompleteBeforeOuter() {
87 Observable<Observable<String>> source = Observable.unsafeCreate(new ObservableSource<Observable<String>>() {
88 @Override
89 public void subscribe(Observer<? super Observable<String>> outerObserver) {
90 outerObserver.onSubscribe(Disposable.empty());
91 publishNext(outerObserver, 10, Observable.unsafeCreate(new ObservableSource<String>() {
92 @Override
93 public void subscribe(Observer<? super String> innerObserver) {
94 innerObserver.onSubscribe(Disposable.empty());
95 publishNext(innerObserver, 0, "one");
96 publishNext(innerObserver, 10, "two");
97 publishCompleted(innerObserver, 20);
98 }
99 }));
100
101 publishNext(outerObserver, 100, Observable.unsafeCreate(new ObservableSource<String>() {
102 @Override
103 public void subscribe(Observer<? super String> innerObserver) {
104 innerObserver.onSubscribe(Disposable.empty());
105 publishNext(innerObserver, 0, "three");
106 publishNext(innerObserver, 10, "four");
107 publishCompleted(innerObserver, 20);
108 }
109 }));
110 publishCompleted(outerObserver, 200);
111 }
112 });
113
114 Observable<String> sampled = Observable.switchOnNext(source);
115 sampled.subscribe(observer);
116
117 InOrder inOrder = inOrder(observer);
118
119 scheduler.advanceTimeTo(150, TimeUnit.MILLISECONDS);
120 inOrder.verify(observer, never()).onComplete();
121 inOrder.verify(observer, times(1)).onNext("one");
122 inOrder.verify(observer, times(1)).onNext("two");
123 inOrder.verify(observer, times(1)).onNext("three");
124 inOrder.verify(observer, times(1)).onNext("four");
125
126 scheduler.advanceTimeTo(250, TimeUnit.MILLISECONDS);
127 inOrder.verify(observer, never()).onNext(anyString());
128 inOrder.verify(observer, times(1)).onComplete();
129 }
130
131 @Test
132 public void switchWithComplete() {
133 Observable<Observable<String>> source = Observable.unsafeCreate(new ObservableSource<Observable<String>>() {
134 @Override
135 public void subscribe(Observer<? super Observable<String>> outerObserver) {
136 outerObserver.onSubscribe(Disposable.empty());
137 publishNext(outerObserver, 50, Observable.unsafeCreate(new ObservableSource<String>() {
138 @Override
139 public void subscribe(final Observer<? super String> innerObserver) {
140 innerObserver.onSubscribe(Disposable.empty());
141 publishNext(innerObserver, 60, "one");
142 publishNext(innerObserver, 100, "two");
143 }
144 }));
145
146 publishNext(outerObserver, 200, Observable.unsafeCreate(new ObservableSource<String>() {
147 @Override
148 public void subscribe(final Observer<? super String> innerObserver) {
149 innerObserver.onSubscribe(Disposable.empty());
150 publishNext(innerObserver, 0, "three");
151 publishNext(innerObserver, 100, "four");
152 }
153 }));
154
155 publishCompleted(outerObserver, 250);
156 }
157 });
158
159 Observable<String> sampled = Observable.switchOnNext(source);
160 sampled.subscribe(observer);
161
162 InOrder inOrder = inOrder(observer);
163
164 scheduler.advanceTimeTo(90, TimeUnit.MILLISECONDS);
165 inOrder.verify(observer, never()).onNext(anyString());
166 verify(observer, never()).onComplete();
167 verify(observer, never()).onError(any(Throwable.class));
168
169 scheduler.advanceTimeTo(125, TimeUnit.MILLISECONDS);
170 inOrder.verify(observer, times(1)).onNext("one");
171 verify(observer, never()).onComplete();
172 verify(observer, never()).onError(any(Throwable.class));
173
174 scheduler.advanceTimeTo(175, TimeUnit.MILLISECONDS);
175 inOrder.verify(observer, times(1)).onNext("two");
176 verify(observer, never()).onComplete();
177 verify(observer, never()).onError(any(Throwable.class));
178
179 scheduler.advanceTimeTo(225, TimeUnit.MILLISECONDS);
180 inOrder.verify(observer, times(1)).onNext("three");
181 verify(observer, never()).onComplete();
182 verify(observer, never()).onError(any(Throwable.class));
183
184 scheduler.advanceTimeTo(350, TimeUnit.MILLISECONDS);
185 inOrder.verify(observer, times(1)).onNext("four");
186 verify(observer, never()).onComplete();
187 verify(observer, never()).onError(any(Throwable.class));
188 }
189
190 @Test
191 public void switchWithError() {
192 Observable<Observable<String>> source = Observable.unsafeCreate(new ObservableSource<Observable<String>>() {
193 @Override
194 public void subscribe(Observer<? super Observable<String>> outerObserver) {
195 outerObserver.onSubscribe(Disposable.empty());
196 publishNext(outerObserver, 50, Observable.unsafeCreate(new ObservableSource<String>() {
197 @Override
198 public void subscribe(final Observer<? super String> innerObserver) {
199 innerObserver.onSubscribe(Disposable.empty());
200 publishNext(innerObserver, 50, "one");
201 publishNext(innerObserver, 100, "two");
202 }
203 }));
204
205 publishNext(outerObserver, 200, Observable.unsafeCreate(new ObservableSource<String>() {
206 @Override
207 public void subscribe(Observer<? super String> innerObserver) {
208 innerObserver.onSubscribe(Disposable.empty());
209 publishNext(innerObserver, 0, "three");
210 publishNext(innerObserver, 100, "four");
211 }
212 }));
213
214 publishError(outerObserver, 250, new TestException());
215 }
216 });
217
218 Observable<String> sampled = Observable.switchOnNext(source);
219 sampled.subscribe(observer);
220
221 InOrder inOrder = inOrder(observer);
222
223 scheduler.advanceTimeTo(90, TimeUnit.MILLISECONDS);
224 inOrder.verify(observer, never()).onNext(anyString());
225 verify(observer, never()).onComplete();
226 verify(observer, never()).onError(any(Throwable.class));
227
228 scheduler.advanceTimeTo(125, TimeUnit.MILLISECONDS);
229 inOrder.verify(observer, times(1)).onNext("one");
230 verify(observer, never()).onComplete();
231 verify(observer, never()).onError(any(Throwable.class));
232
233 scheduler.advanceTimeTo(175, TimeUnit.MILLISECONDS);
234 inOrder.verify(observer, times(1)).onNext("two");
235 verify(observer, never()).onComplete();
236 verify(observer, never()).onError(any(Throwable.class));
237
238 scheduler.advanceTimeTo(225, TimeUnit.MILLISECONDS);
239 inOrder.verify(observer, times(1)).onNext("three");
240 verify(observer, never()).onComplete();
241 verify(observer, never()).onError(any(Throwable.class));
242
243 scheduler.advanceTimeTo(350, TimeUnit.MILLISECONDS);
244 inOrder.verify(observer, never()).onNext(anyString());
245 verify(observer, never()).onComplete();
246 verify(observer, times(1)).onError(any(TestException.class));
247 }
248
249 @Test
250 public void switchWithSubsequenceComplete() {
251 Observable<Observable<String>> source = Observable.unsafeCreate(new ObservableSource<Observable<String>>() {
252 @Override
253 public void subscribe(Observer<? super Observable<String>> outerObserver) {
254 outerObserver.onSubscribe(Disposable.empty());
255 publishNext(outerObserver, 50, Observable.unsafeCreate(new ObservableSource<String>() {
256 @Override
257 public void subscribe(Observer<? super String> innerObserver) {
258 innerObserver.onSubscribe(Disposable.empty());
259 publishNext(innerObserver, 50, "one");
260 publishNext(innerObserver, 100, "two");
261 }
262 }));
263
264 publishNext(outerObserver, 130, Observable.unsafeCreate(new ObservableSource<String>() {
265 @Override
266 public void subscribe(Observer<? super String> innerObserver) {
267 innerObserver.onSubscribe(Disposable.empty());
268 publishCompleted(innerObserver, 0);
269 }
270 }));
271
272 publishNext(outerObserver, 150, Observable.unsafeCreate(new ObservableSource<String>() {
273 @Override
274 public void subscribe(Observer<? super String> innerObserver) {
275 innerObserver.onSubscribe(Disposable.empty());
276 publishNext(innerObserver, 50, "three");
277 }
278 }));
279 }
280 });
281
282 Observable<String> sampled = Observable.switchOnNext(source);
283 sampled.subscribe(observer);
284
285 InOrder inOrder = inOrder(observer);
286
287 scheduler.advanceTimeTo(90, TimeUnit.MILLISECONDS);
288 inOrder.verify(observer, never()).onNext(anyString());
289 verify(observer, never()).onComplete();
290 verify(observer, never()).onError(any(Throwable.class));
291
292 scheduler.advanceTimeTo(125, TimeUnit.MILLISECONDS);
293 inOrder.verify(observer, times(1)).onNext("one");
294 verify(observer, never()).onComplete();
295 verify(observer, never()).onError(any(Throwable.class));
296
297 scheduler.advanceTimeTo(250, TimeUnit.MILLISECONDS);
298 inOrder.verify(observer, times(1)).onNext("three");
299 verify(observer, never()).onComplete();
300 verify(observer, never()).onError(any(Throwable.class));
301 }
302
303 @Test
304 public void switchWithSubsequenceError() {
305 Observable<Observable<String>> source = Observable.unsafeCreate(new ObservableSource<Observable<String>>() {
306 @Override
307 public void subscribe(Observer<? super Observable<String>> observer) {
308 observer.onSubscribe(Disposable.empty());
309 publishNext(observer, 50, Observable.unsafeCreate(new ObservableSource<String>() {
310 @Override
311 public void subscribe(Observer<? super String> observer) {
312 observer.onSubscribe(Disposable.empty());
313 publishNext(observer, 50, "one");
314 publishNext(observer, 100, "two");
315 }
316 }));
317
318 publishNext(observer, 130, Observable.unsafeCreate(new ObservableSource<String>() {
319 @Override
320 public void subscribe(Observer<? super String> observer) {
321 observer.onSubscribe(Disposable.empty());
322 publishError(observer, 0, new TestException());
323 }
324 }));
325
326 publishNext(observer, 150, Observable.unsafeCreate(new ObservableSource<String>() {
327 @Override
328 public void subscribe(Observer<? super String> observer) {
329 observer.onSubscribe(Disposable.empty());
330 publishNext(observer, 50, "three");
331 }
332 }));
333
334 }
335 });
336
337 Observable<String> sampled = Observable.switchOnNext(source);
338 sampled.subscribe(observer);
339
340 InOrder inOrder = inOrder(observer);
341
342 scheduler.advanceTimeTo(90, TimeUnit.MILLISECONDS);
343 inOrder.verify(observer, never()).onNext(anyString());
344 verify(observer, never()).onComplete();
345 verify(observer, never()).onError(any(Throwable.class));
346
347 scheduler.advanceTimeTo(125, TimeUnit.MILLISECONDS);
348 inOrder.verify(observer, times(1)).onNext("one");
349 verify(observer, never()).onComplete();
350 verify(observer, never()).onError(any(Throwable.class));
351
352 scheduler.advanceTimeTo(250, TimeUnit.MILLISECONDS);
353 inOrder.verify(observer, never()).onNext("three");
354 verify(observer, never()).onComplete();
355 verify(observer, times(1)).onError(any(TestException.class));
356 }
357
358 private <T> void publishCompleted(final Observer<T> observer, long delay) {
359 innerScheduler.schedule(new Runnable() {
360 @Override
361 public void run() {
362 observer.onComplete();
363 }
364 }, delay, TimeUnit.MILLISECONDS);
365 }
366
367 private <T> void publishError(final Observer<T> observer, long delay, final Throwable error) {
368 innerScheduler.schedule(new Runnable() {
369 @Override
370 public void run() {
371 observer.onError(error);
372 }
373 }, delay, TimeUnit.MILLISECONDS);
374 }
375
376 private <T> void publishNext(final Observer<T> observer, long delay, final T value) {
377 innerScheduler.schedule(new Runnable() {
378 @Override
379 public void run() {
380 observer.onNext(value);
381 }
382 }, delay, TimeUnit.MILLISECONDS);
383 }
384
385 @Test
386 public void switchIssue737() {
387 // https://github.com/ReactiveX/RxJava/issues/737
388 Observable<Observable<String>> source = Observable.unsafeCreate(new ObservableSource<Observable<String>>() {
389 @Override
390 public void subscribe(Observer<? super Observable<String>> outerObserver) {
391 outerObserver.onSubscribe(Disposable.empty());
392 publishNext(outerObserver, 0, Observable.unsafeCreate(new ObservableSource<String>() {
393 @Override
394 public void subscribe(Observer<? super String> innerObserver) {
395 innerObserver.onSubscribe(Disposable.empty());
396 publishNext(innerObserver, 10, "1-one");
397 publishNext(innerObserver, 20, "1-two");
398 // The following events will be ignored
399 publishNext(innerObserver, 30, "1-three");
400 publishCompleted(innerObserver, 40);
401 }
402 }));
403 publishNext(outerObserver, 25, Observable.unsafeCreate(new ObservableSource<String>() {
404 @Override
405 public void subscribe(Observer<? super String> innerObserver) {
406 innerObserver.onSubscribe(Disposable.empty());
407 publishNext(innerObserver, 10, "2-one");
408 publishNext(innerObserver, 20, "2-two");
409 publishNext(innerObserver, 30, "2-three");
410 publishCompleted(innerObserver, 40);
411 }
412 }));
413 publishCompleted(outerObserver, 30);
414 }
415 });
416
417 Observable<String> sampled = Observable.switchOnNext(source);
418 sampled.subscribe(observer);
419
420 scheduler.advanceTimeTo(1000, TimeUnit.MILLISECONDS);
421
422 InOrder inOrder = inOrder(observer);
423 inOrder.verify(observer, times(1)).onNext("1-one");
424 inOrder.verify(observer, times(1)).onNext("1-two");
425 inOrder.verify(observer, times(1)).onNext("2-one");
426 inOrder.verify(observer, times(1)).onNext("2-two");
427 inOrder.verify(observer, times(1)).onNext("2-three");
428 inOrder.verify(observer, times(1)).onComplete();
429 inOrder.verifyNoMoreInteractions();
430 }
431
432 @Test
433 public void unsubscribe() {
434 final AtomicBoolean isUnsubscribed = new AtomicBoolean();
435 Observable.switchOnNext(
436 Observable.unsafeCreate(new ObservableSource<Observable<Integer>>() {
437 @Override
438 public void subscribe(final Observer<? super Observable<Integer>> observer) {
439 Disposable bs = Disposable.empty();
440 observer.onSubscribe(bs);
441 observer.onNext(Observable.just(1));
442 isUnsubscribed.set(bs.isDisposed());
443 }
444 })
445 ).take(1).subscribe();
446 assertTrue("Switch doesn't propagate 'unsubscribe'", isUnsubscribed.get());
447 }
448 /** The upstream producer hijacked the switch producer stopping the requests aimed at the inner observables. */
449 @Test
450 public void issue2654() {
451 Observable<String> oneItem = Observable.just("Hello").mergeWith(Observable.<String>never());
452
453 Observable<String> src = oneItem.switchMap(new Function<String, Observable<String>>() {
454 @Override
455 public Observable<String> apply(final String s) {
456 return Observable.just(s)
457 .mergeWith(Observable.interval(10, TimeUnit.MILLISECONDS)
458 .map(new Function<Long, String>() {
459 @Override
460 public String apply(Long i) {
461 return s + " " + i;
462 }
463 })).take(250);
464 }
465 })
466 .share()
467 ;
468
469 TestObserverEx<String> to = new TestObserverEx<String>() {
470 @Override
471 public void onNext(String t) {
472 super.onNext(t);
473 if (values().size() == 250) {
474 onComplete();
475 dispose();
476 }
477 }
478 };
479 src.subscribe(to);
480
481 to.awaitDone(10, TimeUnit.SECONDS);
482
483 System.out.println("> testIssue2654: " + to.values().size());
484
485 to.assertTerminated();
486 to.assertNoErrors();
487
488 Assert.assertEquals(250, to.values().size());
489 }
490
491 @Test
492 public void delayErrors() {
493 PublishSubject<ObservableSource<Integer>> source = PublishSubject.create();
494
495 TestObserverEx<Integer> to = source.switchMapDelayError(Functions.<ObservableSource<Integer>>identity())
496 .to(TestHelper.<Integer>testConsumer());
497
498 to.assertNoValues()
499 .assertNoErrors()
500 .assertNotComplete();
501
502 source.onNext(Observable.just(1));
503
504 source.onNext(Observable.<Integer>error(new TestException("Forced failure 1")));
505
506 source.onNext(Observable.just(2, 3, 4));
507
508 source.onNext(Observable.<Integer>error(new TestException("Forced failure 2")));
509
510 source.onNext(Observable.just(5));
511
512 source.onError(new TestException("Forced failure 3"));
513
514 to.assertValues(1, 2, 3, 4, 5)
515 .assertNotComplete()
516 .assertError(CompositeException.class);
517
518 List<Throwable> errors = ExceptionHelper.flatten(to.errors().get(0));
519
520 TestHelper.assertError(errors, 0, TestException.class, "Forced failure 1");
521 TestHelper.assertError(errors, 1, TestException.class, "Forced failure 2");
522 TestHelper.assertError(errors, 2, TestException.class, "Forced failure 3");
523 }
524
525 @Test
526 public void switchOnNextDelayError() {
527 PublishSubject<Observable<Integer>> ps = PublishSubject.create();
528
529 TestObserver<Integer> to = Observable.switchOnNextDelayError(ps).test();
530
531 ps.onNext(Observable.just(1));
532 ps.onNext(Observable.range(2, 4));
533 ps.onComplete();
534
535 to.assertResult(1, 2, 3, 4, 5);
536 }
537
538 @Test
539 public void switchOnNextDelayErrorWithError() {
540 PublishSubject<Observable<Integer>> ps = PublishSubject.create();
541
542 TestObserver<Integer> to = Observable.switchOnNextDelayError(ps).test();
543
544 ps.onNext(Observable.just(1));
545 ps.onNext(Observable.<Integer>error(new TestException()));
546 ps.onNext(Observable.range(2, 4));
547 ps.onComplete();
548
549 to.assertFailure(TestException.class, 1, 2, 3, 4, 5);
550 }
551
552 @Test
553 public void switchOnNextDelayErrorBufferSize() {
554 PublishSubject<Observable<Integer>> ps = PublishSubject.create();
555
556 TestObserver<Integer> to = Observable.switchOnNextDelayError(ps, 2).test();
557
558 ps.onNext(Observable.just(1));
559 ps.onNext(Observable.range(2, 4));
560 ps.onComplete();
561
562 to.assertResult(1, 2, 3, 4, 5);
563 }
564
565 @Test
566 public void switchMapDelayErrorEmptySource() {
567 assertSame(Observable.empty(), Observable.<Object>empty()
568 .switchMapDelayError(new Function<Object, ObservableSource<Integer>>() {
569 @Override
570 public ObservableSource<Integer> apply(Object v) throws Exception {
571 return Observable.just(1);
572 }
573 }, 16));
574 }
575
576 @Test
577 public void switchMapDelayErrorJustSource() {
578 Observable.just(0)
579 .switchMapDelayError(new Function<Object, ObservableSource<Integer>>() {
580 @Override
581 public ObservableSource<Integer> apply(Object v) throws Exception {
582 return Observable.just(1);
583 }
584 }, 16)
585 .test()
586 .assertResult(1);
587 }
588
589 @Test
590 public void switchMapErrorEmptySource() {
591 assertSame(Observable.empty(), Observable.<Object>empty()
592 .switchMap(new Function<Object, ObservableSource<Integer>>() {
593 @Override
594 public ObservableSource<Integer> apply(Object v) throws Exception {
595 return Observable.just(1);
596 }
597 }, 16));
598 }
599
600 @Test
601 public void switchMapJustSource() {
602 Observable.just(0)
603 .switchMap(new Function<Object, ObservableSource<Integer>>() {
604 @Override
605 public ObservableSource<Integer> apply(Object v) throws Exception {
606 return Observable.just(1);
607 }
608 }, 16)
609 .test()
610 .assertResult(1);
611
612 }
613
614 @Test
615 public void switchMapInnerCancelled() {
616 PublishSubject<Integer> ps = PublishSubject.create();
617
618 TestObserver<Integer> to = Observable.just(1)
619 .switchMap(Functions.justFunction(ps))
620 .test();
621
622 assertTrue(ps.hasObservers());
623
624 to.dispose();
625
626 assertFalse(ps.hasObservers());
627 }
628
629 @Test
630 public void switchMapSingleJustSource() {
631 Observable.just(0)
632 .switchMapSingle(new Function<Object, SingleSource<Integer>>() {
633 @Override
634 public SingleSource<Integer> apply(Object v) throws Exception {
635 return Single.just(1);
636 }
637 })
638 .test()
639 .assertResult(1);
640 }
641
642 @Test
643 public void switchMapSingleMapperReturnsNull() {
644 Observable.just(0)
645 .switchMapSingle(new Function<Object, SingleSource<Integer>>() {
646 @Override
647 public SingleSource<Integer> apply(Object v) throws Exception {
648 return null;
649 }
650 })
651 .test()
652 .assertError(NullPointerException.class);
653 }
654
655 @Test
656 public void switchMapSingleFunctionDoesntReturnSingle() {
657 Observable.just(0)
658 .switchMapSingle(new Function<Object, SingleSource<Integer>>() {
659 @Override
660 public SingleSource<Integer> apply(Object v) throws Exception {
661 return new SingleSource<Integer>() {
662 @Override
663 public void subscribe(SingleObserver<? super Integer> observer) {
664 observer.onSubscribe(Disposable.empty());
665 observer.onSuccess(1);
666 }
667 };
668 }
669 })
670 .test()
671 .assertResult(1);
672 }
673
674 @Test
675 public void switchMapSingleDelayErrorJustSource() {
676 final AtomicBoolean completed = new AtomicBoolean();
677 Observable.just(0, 1)
678 .switchMapSingleDelayError(new Function<Integer, SingleSource<Integer>>() {
679 @Override
680 public SingleSource<Integer> apply(Integer v) throws Exception {
681 if (v == 0) {
682 return Single.error(new RuntimeException());
683 } else {
684 return Single.just(1).doOnSuccess(new Consumer<Integer>() {
685
686 @Override
687 public void accept(Integer n) throws Exception {
688 completed.set(true);
689 }});
690 }
691 }
692 })
693 .test()
694 .assertValue(1)
695 .assertError(RuntimeException.class);
696 assertTrue(completed.get());
697 }
698
699 @Test
700 public void scalarMap() {
701 Observable.switchOnNext(Observable.just(Observable.just(1)))
702 .test()
703 .assertResult(1);
704 }
705
706 @Test
707 public void scalarMapDelayError() {
708 Observable.switchOnNextDelayError(Observable.just(Observable.just(1)))
709 .test()
710 .assertResult(1);
711 }
712
713 @Test
714 public void dispose() {
715 TestHelper.checkDisposed(Observable.switchOnNext(
716 Observable.just(Observable.just(1)).hide()));
717 }
718
719 @Test
720 public void nextSourceErrorRace() {
721 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
722 List<Throwable> errors = TestHelper.trackPluginErrors();
723 try {
724
725 final PublishSubject<Integer> ps1 = PublishSubject.create();
726 final PublishSubject<Integer> ps2 = PublishSubject.create();
727
728 ps1.switchMap(new Function<Integer, ObservableSource<Integer>>() {
729 @Override
730 public ObservableSource<Integer> apply(Integer v) throws Exception {
731 if (v == 1) {
732 return ps2;
733 }
734 return Observable.never();
735 }
736 })
737 .test();
738
739 Runnable r1 = new Runnable() {
740 @Override
741 public void run() {
742 ps1.onNext(2);
743 }
744 };
745
746 final TestException ex = new TestException();
747
748 Runnable r2 = new Runnable() {
749 @Override
750 public void run() {
751 ps2.onError(ex);
752 }
753 };
754
755 TestHelper.race(r1, r2);
756
757 for (Throwable e : errors) {
758 assertTrue(e.toString(), e instanceof TestException);
759 }
760 } finally {
761 RxJavaPlugins.reset();
762 }
763 }
764 }
765
766 @Test
767 public void outerInnerErrorRace() {
768 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
769 List<Throwable> errors = TestHelper.trackPluginErrors();
770 try {
771
772 final PublishSubject<Integer> ps1 = PublishSubject.create();
773 final PublishSubject<Integer> ps2 = PublishSubject.create();
774
775 ps1.switchMap(new Function<Integer, ObservableSource<Integer>>() {
776 @Override
777 public ObservableSource<Integer> apply(Integer v) throws Exception {
778 if (v == 1) {
779 return ps2;
780 }
781 return Observable.never();
782 }
783 })
784 .test();
785
786 ps1.onNext(1);
787
788 final TestException ex1 = new TestException();
789
790 Runnable r1 = new Runnable() {
791 @Override
792 public void run() {
793 ps1.onError(ex1);
794 }
795 };
796
797 final TestException ex2 = new TestException();
798
799 Runnable r2 = new Runnable() {
800 @Override
801 public void run() {
802 ps2.onError(ex2);
803 }
804 };
805
806 TestHelper.race(r1, r2);
807
808 for (Throwable e : errors) {
809 assertTrue(e.getCause().toString(), e.getCause() instanceof TestException);
810 }
811 } finally {
812 RxJavaPlugins.reset();
813 }
814 }
815 }
816
817 @Test
818 public void nextCancelRace() {
819 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
820 final PublishSubject<Integer> ps1 = PublishSubject.create();
821
822 final TestObserver<Integer> to = ps1.switchMap(new Function<Integer, ObservableSource<Integer>>() {
823 @Override
824 public ObservableSource<Integer> apply(Integer v) throws Exception {
825 return Observable.never();
826 }
827 })
828 .test();
829
830 Runnable r1 = new Runnable() {
831 @Override
832 public void run() {
833 ps1.onNext(2);
834 }
835 };
836
837 Runnable r2 = new Runnable() {
838 @Override
839 public void run() {
840 to.dispose();
841 }
842 };
843
844 TestHelper.race(r1, r2);
845 }
846 }
847
848 @Test
849 public void mapperThrows() {
850 Observable.just(1).hide()
851 .switchMap(new Function<Integer, ObservableSource<Object>>() {
852 @Override
853 public ObservableSource<Object> apply(Integer v) throws Exception {
854 throw new TestException();
855 }
856 })
857 .test()
858 .assertFailure(TestException.class);
859 }
860
861 @Test
862 public void badMainSource() {
863 List<Throwable> errors = TestHelper.trackPluginErrors();
864 try {
865 new Observable<Integer>() {
866 @Override
867 protected void subscribeActual(Observer<? super Integer> observer) {
868 observer.onSubscribe(Disposable.empty());
869 observer.onComplete();
870 observer.onError(new TestException());
871 observer.onComplete();
872 }
873 }
874 .switchMap(Functions.justFunction(Observable.never()))
875 .test()
876 .assertResult();
877
878 TestHelper.assertUndeliverable(errors, 0, TestException.class);
879 } finally {
880 RxJavaPlugins.reset();
881 }
882 }
883
884 @Test
885 public void emptyInner() {
886 Observable.range(1, 5)
887 .switchMap(Functions.justFunction(Observable.empty()))
888 .test()
889 .assertResult();
890 }
891
892 @Test
893 public void justInner() {
894 Observable.range(1, 5)
895 .switchMap(Functions.justFunction(Observable.just(1)))
896 .test()
897 .assertResult(1, 1, 1, 1, 1);
898 }
899
900 @Test
901 public void badInnerSource() {
902 List<Throwable> errors = TestHelper.trackPluginErrors();
903 try {
904 Observable.just(1).hide()
905 .switchMap(Functions.justFunction(new Observable<Integer>() {
906 @Override
907 protected void subscribeActual(Observer<? super Integer> observer) {
908 observer.onSubscribe(Disposable.empty());
909 observer.onError(new TestException());
910 observer.onComplete();
911 observer.onError(new TestException());
912 observer.onComplete();
913 }
914 }))
915 .test()
916 .assertFailure(TestException.class);
917
918 TestHelper.assertUndeliverable(errors, 0, TestException.class);
919 } finally {
920 RxJavaPlugins.reset();
921 }
922 }
923
924 @Test
925 public void innerCompletesReentrant() {
926 final PublishSubject<Integer> ps = PublishSubject.create();
927
928 TestObserver<Integer> to = new TestObserver<Integer>() {
929 @Override
930 public void onNext(Integer t) {
931 super.onNext(t);
932 ps.onComplete();
933 }
934 };
935
936 Observable.just(1).hide()
937 .switchMap(Functions.justFunction(ps))
938 .subscribe(to);
939
940 ps.onNext(1);
941
942 to.assertResult(1);
943 }
944
945 @Test
946 public void innerErrorsReentrant() {
947 final PublishSubject<Integer> ps = PublishSubject.create();
948
949 TestObserver<Integer> to = new TestObserver<Integer>() {
950 @Override
951 public void onNext(Integer t) {
952 super.onNext(t);
953 ps.onError(new TestException());
954 }
955 };
956
957 Observable.just(1).hide()
958 .switchMap(Functions.justFunction(ps))
959 .subscribe(to);
960
961 ps.onNext(1);
962
963 to.assertFailure(TestException.class, 1);
964 }
965
966 @Test
967 public void innerDisposedOnMainError() {
968 final PublishSubject<Integer> main = PublishSubject.create();
969 final PublishSubject<Integer> inner = PublishSubject.create();
970
971 TestObserver<Integer> to = main.switchMap(Functions.justFunction(inner))
972 .test();
973
974 assertTrue(main.hasObservers());
975
976 main.onNext(1);
977
978 assertTrue(inner.hasObservers());
979
980 main.onError(new TestException());
981
982 assertFalse(inner.hasObservers());
983
984 to.assertFailure(TestException.class);
985 }
986
987 @Test
988 public void outerInnerErrorRaceIgnoreDispose() {
989 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
990 List<Throwable> errors = TestHelper.trackPluginErrors();
991 try {
992
993 final AtomicReference<Observer<? super Integer>> obs1 = new AtomicReference<>();
994 final Observable<Integer> ps1 = new Observable<Integer>() {
995 @Override
996 protected void subscribeActual(
997 Observer<? super Integer> observer) {
998 obs1.set(observer);
999 }
1000 };
1001 final AtomicReference<Observer<? super Integer>> obs2 = new AtomicReference<>();
1002 final Observable<Integer> ps2 = new Observable<Integer>() {
1003 @Override
1004 protected void subscribeActual(
1005 Observer<? super Integer> observer) {
1006 obs2.set(observer);
1007 }
1008 };
1009
1010 ps1.switchMap(new Function<Integer, ObservableSource<Integer>>() {
1011 @Override
1012 public ObservableSource<Integer> apply(Integer v) throws Exception {
1013 if (v == 1) {
1014 return ps2;
1015 }
1016 return Observable.never();
1017 }
1018 })
1019 .test();
1020
1021 obs1.get().onSubscribe(Disposable.empty());
1022 obs1.get().onNext(1);
1023
1024 obs2.get().onSubscribe(Disposable.empty());
1025
1026 final TestException ex1 = new TestException();
1027
1028 Runnable r1 = new Runnable() {
1029 @Override
1030 public void run() {
1031 obs1.get().onError(ex1);
1032 }
1033 };
1034
1035 final TestException ex2 = new TestException();
1036
1037 Runnable r2 = new Runnable() {
1038 @Override
1039 public void run() {
1040 obs2.get().onError(ex2);
1041 }
1042 };
1043
1044 TestHelper.race(r1, r2);
1045
1046 for (Throwable e : errors) {
1047 assertTrue(e.toString(), e.getCause() instanceof TestException);
1048 }
1049 } finally {
1050 RxJavaPlugins.reset();
1051 }
1052 }
1053 }
1054
1055 @Test
1056 public void asyncFused() {
1057 Observable.just(1).hide()
1058 .switchMap(Functions.justFunction(
1059 Observable.range(1, 5)
1060 .observeOn(ImmediateThinScheduler.INSTANCE)
1061 ))
1062 .test()
1063 .assertResult(1, 2, 3, 4, 5);
1064 }
1065
1066 @Test
1067 public void syncFusedMaybe() {
1068 Observable.range(1, 5).hide()
1069 .switchMap(Functions.justFunction(
1070 Maybe.just(1).toObservable()
1071 ))
1072 .test()
1073 .assertResult(1, 1, 1, 1, 1);
1074 }
1075
1076 @Test
1077 public void syncFusedSingle() {
1078 Observable.range(1, 5).hide()
1079 .switchMap(Functions.justFunction(
1080 Single.just(1).toObservable()
1081 ))
1082 .test()
1083 .assertResult(1, 1, 1, 1, 1);
1084 }
1085
1086 @Test
1087 public void syncFusedCompletable() {
1088 Observable.range(1, 5).hide()
1089 .switchMap(Functions.justFunction(
1090 Completable.complete().toObservable()
1091 ))
1092 .test()
1093 .assertResult();
1094 }
1095
1096 @Test
1097 public void asyncFusedRejecting() {
1098 Observable.just(1).hide()
1099 .switchMap(Functions.justFunction(
1100 TestHelper.rejectObservableFusion()
1101 ))
1102 .test()
1103 .assertEmpty();
1104 }
1105
1106 @Test
1107 public void asyncFusedPollCrash() {
1108 PublishSubject<Integer> ps = PublishSubject.create();
1109
1110 TestObserver<Integer> to = ps
1111 .switchMap(Functions.justFunction(
1112 Observable.range(1, 5)
1113 .observeOn(ImmediateThinScheduler.INSTANCE)
1114 .map(new Function<Integer, Integer>() {
1115 @Override
1116 public Integer apply(Integer v) throws Exception {
1117 throw new TestException();
1118 }
1119 })
1120 .compose(TestHelper.<Integer>observableStripBoundary())
1121 ))
1122 .test();
1123
1124 to.assertEmpty();
1125
1126 ps.onNext(1);
1127
1128 to
1129 .assertFailure(TestException.class);
1130
1131 assertFalse(ps.hasObservers());
1132 }
1133
1134 @Test
1135 public void asyncFusedPollCrashDelayError() {
1136 PublishSubject<Integer> ps = PublishSubject.create();
1137
1138 TestObserver<Integer> to = ps
1139 .switchMapDelayError(Functions.justFunction(
1140 Observable.range(1, 5)
1141 .observeOn(ImmediateThinScheduler.INSTANCE)
1142 .map(new Function<Integer, Integer>() {
1143 @Override
1144 public Integer apply(Integer v) throws Exception {
1145 throw new TestException();
1146 }
1147 })
1148 .compose(TestHelper.<Integer>observableStripBoundary())
1149 ))
1150 .test();
1151
1152 to.assertEmpty();
1153
1154 ps.onNext(1);
1155
1156 assertTrue(ps.hasObservers());
1157
1158 to.assertEmpty();
1159
1160 ps.onComplete();
1161
1162 to
1163 .assertFailure(TestException.class);
1164
1165 assertFalse(ps.hasObservers());
1166 }
1167
1168 @Test
1169 public void fusedBoundary() {
1170 String thread = Thread.currentThread().getName();
1171
1172 TestObserver<Object> to = Observable.range(1, 10000)
1173 .switchMap(new Function<Integer, ObservableSource<? extends Object>>() {
1174 @Override
1175 public ObservableSource<? extends Object> apply(Integer v)
1176 throws Exception {
1177 return Observable.just(2).hide()
1178 .observeOn(Schedulers.single())
1179 .map(new Function<Integer, Object>() {
1180 @Override
1181 public Object apply(Integer w) throws Exception {
1182 return Thread.currentThread().getName();
1183 }
1184 });
1185 }
1186 })
1187 .test()
1188 .awaitDone(5, TimeUnit.SECONDS)
1189 .assertNoErrors()
1190 .assertComplete();
1191
1192 for (Object o : to.values()) {
1193 assertNotEquals(thread, o);
1194 }
1195 }
1196
1197 @Test
1198 public void undeliverableUponCancel() {
1199 List<Throwable> errors = TestHelper.trackPluginErrors();
1200 try {
1201 final TestObserverEx<Integer> to = new TestObserverEx<>();
1202
1203 Observable.just(1)
1204 .map(new Function<Integer, Integer>() {
1205 @Override
1206 public Integer apply(Integer v) throws Throwable {
1207 to.dispose();
1208 throw new TestException();
1209 }
1210 })
1211 .switchMap(new Function<Integer, Observable<Integer>>() {
1212 @Override
1213 public Observable<Integer> apply(Integer v) throws Throwable {
1214 return Observable.just(v).hide();
1215 }
1216 })
1217 .subscribe(to);
1218
1219 to.assertEmpty();
1220
1221 TestHelper.assertUndeliverable(errors, 0, TestException.class);
1222 } finally {
1223 RxJavaPlugins.reset();
1224 }
1225 }
1226
1227 @Test
1228 public void switchMapFusedIterable() {
1229 Observable.range(1, 2)
1230 .switchMap(new Function<Integer, Observable<Integer>>() {
1231 @Override
1232 public Observable<Integer> apply(Integer v)
1233 throws Throwable {
1234 return Observable.fromIterable(Arrays.asList(v * 10));
1235 }
1236 })
1237 .test()
1238 .assertResult(10, 20);
1239 }
1240
1241 @Test
1242 public void switchMapHiddenIterable() {
1243 Observable.range(1, 2)
1244 .switchMap(new Function<Integer, Observable<Integer>>() {
1245 @Override
1246 public Observable<Integer> apply(Integer v)
1247 throws Throwable {
1248 return Observable.fromIterable(Arrays.asList(v * 10)).hide();
1249 }
1250 })
1251 .test()
1252 .assertResult(10, 20);
1253 }
1254
1255 @Test
1256 public void doubleOnSubscribe() {
1257 TestHelper.checkDoubleOnSubscribeObservable(f -> f.switchMap(v -> Observable.never()));
1258 }
1259
1260 @Test
1261 public void mainCompleteCancelRace() {
1262 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
1263 AtomicReference<Observer<? super Integer>> ref = new AtomicReference<>();
1264 Observable<Integer> o = new Observable<Integer>() {
1265 @Override
1266 protected void subscribeActual(@NonNull Observer<? super @NonNull Integer> observer) {
1267 ref.set(observer);
1268 }
1269 };
1270
1271 TestObserver<Object> to = o.switchMap(v -> Observable.never())
1272 .test();
1273
1274 ref.get().onSubscribe(Disposable.empty());
1275
1276 TestHelper.race(
1277 () -> ref.get().onComplete(),
1278 () -> to.dispose()
1279 );
1280 }
1281 }
1282
1283 @Test
1284 public void mainCompleteInnerErrorRace() {
1285 TestException ex = new TestException();
1286
1287 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
1288 AtomicReference<Observer<? super Integer>> ref1 = new AtomicReference<>();
1289 Observable<Integer> o1 = new Observable<Integer>() {
1290 @Override
1291 protected void subscribeActual(@NonNull Observer<? super @NonNull Integer> observer) {
1292 ref1.set(observer);
1293 }
1294 };
1295 AtomicReference<Observer<? super Integer>> ref2 = new AtomicReference<>();
1296 Observable<Integer> o2 = new Observable<Integer>() {
1297 @Override
1298 protected void subscribeActual(@NonNull Observer<? super @NonNull Integer> observer) {
1299 ref2.set(observer);
1300 }
1301 };
1302
1303 o1.switchMap(v -> o2)
1304 .test();
1305
1306 ref1.get().onSubscribe(Disposable.empty());
1307 ref1.get().onNext(1);
1308 ref2.get().onSubscribe(Disposable.empty());
1309
1310 TestHelper.race(
1311 () -> ref1.get().onComplete(),
1312 () -> ref2.get().onError(ex)
1313 );
1314 }
1315 }
1316
1317 @Test
1318 public void innerNoSubscriptionYet() {
1319 AtomicReference<Observer<? super Integer>> ref1 = new AtomicReference<>();
1320 Observable<Integer> o1 = new Observable<Integer>() {
1321 @Override
1322 protected void subscribeActual(@NonNull Observer<? super @NonNull Integer> observer) {
1323 ref1.set(observer);
1324 }
1325 };
1326 AtomicReference<Observer<? super Integer>> ref2 = new AtomicReference<>();
1327 Observable<Integer> o2 = new Observable<Integer>() {
1328 @Override
1329 protected void subscribeActual(@NonNull Observer<? super @NonNull Integer> observer) {
1330 ref2.set(observer);
1331 }
1332 };
1333
1334 o1.switchMap(v -> o2)
1335 .test();
1336
1337 ref1.get().onSubscribe(Disposable.empty());
1338 ref1.get().onNext(1);
1339 ref1.get().onComplete();
1340 }
1341
1342 @Test
1343 public void switchDuringOnNext() {
1344 PublishSubject<Integer> ps = PublishSubject.create();
1345
1346 TestObserver<Integer> to = ps.switchMap(v -> Observable.range(v, 5))
1347 .doOnNext(v -> {
1348 if (v == 1) {
1349 ps.onNext(2);
1350 }
1351 })
1352 .test();
1353
1354 ps.onNext(1);
1355
1356 to
1357 .assertValuesOnly(1, 2, 3, 4, 5, 6);
1358 }
1359
1360 @Test
1361 public void mainCompleteWhileInnerActive() {
1362 PublishSubject<Integer> ps1 = PublishSubject.create();
1363 PublishSubject<Integer> ps2 = PublishSubject.create();
1364
1365 TestObserver<Integer> to = ps1.switchMapDelayError(v -> ps2)
1366 .test();
1367
1368 ps1.onNext(1);
1369 ps1.onComplete();
1370
1371 ps2.onComplete();
1372
1373 to.assertResult();
1374 }
1375
1376 @Test
1377 public void innerIgnoresCancelAndErrors() throws Throwable {
1378 TestHelper.withErrorTracking(errors -> {
1379 PublishSubject<Integer> ps = PublishSubject.create();
1380
1381 TestObserver<Object> to = ps
1382 .switchMap(v -> {
1383 if (v == 1) {
1384 return Observable.unsafeCreate(s -> {
1385 s.onSubscribe(Disposable.empty());
1386 ps.onNext(2);
1387 s.onError(new TestException());
1388 });
1389 }
1390 return Observable.never();
1391 })
1392 .test();
1393
1394 ps.onNext(1);
1395
1396 to.assertEmpty();
1397
1398 TestHelper.assertUndeliverable(errors, 0, TestException.class);
1399 });
1400 }
1401
1402 @Test
1403 public void cancellationShouldTriggerInnerCancellationRace() throws Throwable {
1404 AtomicInteger outer = new AtomicInteger();
1405 AtomicInteger inner = new AtomicInteger();
1406
1407 int n = 10_000;
1408 for (int i = 0; i < n; i++) {
1409 Observable.<Integer>create(it -> {
1410 it.onNext(0);
1411 })
1412 .switchMap(v -> createObservable(inner))
1413 .observeOn(Schedulers.computation())
1414 .doFinally(() -> {
1415 outer.incrementAndGet();
1416 })
1417 .take(1)
1418 .blockingSubscribe(v -> { }, Throwable::printStackTrace);
1419 }
1420
1421 Thread.sleep(100);
1422 assertEquals(inner.get(), outer.get());
1423 assertEquals(n, inner.get());
1424 }
1425
1426 Observable<Integer> createObservable(AtomicInteger inner) {
1427 return Observable.<Integer>unsafeCreate(s -> {
1428 SerializedObserver<Integer> it = new SerializedObserver<>(s);
1429 it.onSubscribe(Disposable.empty());
1430 Schedulers.io().scheduleDirect(() -> {
1431 it.onNext(1);
1432 }, 0, TimeUnit.MILLISECONDS);
1433 Schedulers.io().scheduleDirect(() -> {
1434 it.onNext(2);
1435 }, 0, TimeUnit.MILLISECONDS);
1436 })
1437 .doFinally(() -> {
1438 inner.incrementAndGet();
1439 });
1440 }
1441 }