Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableMergeDelayErrorTest.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.any;
18 import static org.mockito.Mockito.*;
19
20 import java.util.*;
21 import java.util.concurrent.*;
22
23 import io.reactivex.rxjava3.disposables.Disposable;
24 import org.junit.*;
25
26 import io.reactivex.rxjava3.core.*;
27 import io.reactivex.rxjava3.core.Observable;
28 import io.reactivex.rxjava3.core.Observer;
29 import io.reactivex.rxjava3.exceptions.*;
30 import io.reactivex.rxjava3.observers.DefaultObserver;
31 import io.reactivex.rxjava3.testsupport.*;
32
33 public class ObservableMergeDelayErrorTest extends RxJavaTest {
34
35 Observer<String> stringObserver;
36
37 @Before
38 public void before() {
39 stringObserver = TestHelper.mockObserver();
40 }
41
42 @Test
43 public void errorDelayed1() {
44 final Observable<String> o1 = Observable.unsafeCreate(new TestErrorObservable("four", null, "six")); // we expect to lose "six" from the source (and it should never be sent by the source since onError was called
45 final Observable<String> o2 = Observable.unsafeCreate(new TestErrorObservable("one", "two", "three"));
46
47 Observable<String> m = Observable.mergeDelayError(o1, o2);
48 m.subscribe(stringObserver);
49
50 verify(stringObserver, times(1)).onError(any(NullPointerException.class));
51 verify(stringObserver, never()).onComplete();
52 verify(stringObserver, times(1)).onNext("one");
53 verify(stringObserver, times(1)).onNext("two");
54 verify(stringObserver, times(1)).onNext("three");
55 verify(stringObserver, times(1)).onNext("four");
56 verify(stringObserver, times(0)).onNext("five");
57 // despite not expecting it ... we don't do anything to prevent it if the source Observable keeps sending after onError
58 // inner Observable errors are considered terminal for that source
59 // verify(stringObserver, times(1)).onNext("six");
60 // inner Observable errors are considered terminal for that source
61 }
62
63 @Test
64 public void errorDelayed2() {
65 final Observable<String> o1 = Observable.unsafeCreate(new TestErrorObservable("one", "two", "three"));
66 final Observable<String> o2 = Observable.unsafeCreate(new TestErrorObservable("four", null, "six")); // we expect to lose "six" from the source (and it should never be sent by the source since onError was called
67 final Observable<String> o3 = Observable.unsafeCreate(new TestErrorObservable("seven", "eight", null));
68 final Observable<String> o4 = Observable.unsafeCreate(new TestErrorObservable("nine"));
69
70 Observable<String> m = Observable.mergeDelayError(o1, o2, o3, o4);
71 m.subscribe(stringObserver);
72
73 verify(stringObserver, times(1)).onError(any(CompositeException.class));
74 verify(stringObserver, never()).onComplete();
75 verify(stringObserver, times(1)).onNext("one");
76 verify(stringObserver, times(1)).onNext("two");
77 verify(stringObserver, times(1)).onNext("three");
78 verify(stringObserver, times(1)).onNext("four");
79 verify(stringObserver, times(0)).onNext("five");
80 // despite not expecting it ... we don't do anything to prevent it if the source Observable keeps sending after onError
81 // inner Observable errors are considered terminal for that source
82 // verify(stringObserver, times(1)).onNext("six");
83 verify(stringObserver, times(1)).onNext("seven");
84 verify(stringObserver, times(1)).onNext("eight");
85 verify(stringObserver, times(1)).onNext("nine");
86 }
87
88 @Test
89 public void errorDelayed3() {
90 final Observable<String> o1 = Observable.unsafeCreate(new TestErrorObservable("one", "two", "three"));
91 final Observable<String> o2 = Observable.unsafeCreate(new TestErrorObservable("four", "five", "six"));
92 final Observable<String> o3 = Observable.unsafeCreate(new TestErrorObservable("seven", "eight", null));
93 final Observable<String> o4 = Observable.unsafeCreate(new TestErrorObservable("nine"));
94
95 Observable<String> m = Observable.mergeDelayError(o1, o2, o3, o4);
96 m.subscribe(stringObserver);
97
98 verify(stringObserver, times(1)).onError(any(NullPointerException.class));
99 verify(stringObserver, never()).onComplete();
100 verify(stringObserver, times(1)).onNext("one");
101 verify(stringObserver, times(1)).onNext("two");
102 verify(stringObserver, times(1)).onNext("three");
103 verify(stringObserver, times(1)).onNext("four");
104 verify(stringObserver, times(1)).onNext("five");
105 verify(stringObserver, times(1)).onNext("six");
106 verify(stringObserver, times(1)).onNext("seven");
107 verify(stringObserver, times(1)).onNext("eight");
108 verify(stringObserver, times(1)).onNext("nine");
109 }
110
111 @Test
112 public void errorDelayed4() {
113 final Observable<String> o1 = Observable.unsafeCreate(new TestErrorObservable("one", "two", "three"));
114 final Observable<String> o2 = Observable.unsafeCreate(new TestErrorObservable("four", "five", "six"));
115 final Observable<String> o3 = Observable.unsafeCreate(new TestErrorObservable("seven", "eight"));
116 final Observable<String> o4 = Observable.unsafeCreate(new TestErrorObservable("nine", null));
117
118 Observable<String> m = Observable.mergeDelayError(o1, o2, o3, o4);
119 m.subscribe(stringObserver);
120
121 verify(stringObserver, times(1)).onError(any(NullPointerException.class));
122 verify(stringObserver, never()).onComplete();
123 verify(stringObserver, times(1)).onNext("one");
124 verify(stringObserver, times(1)).onNext("two");
125 verify(stringObserver, times(1)).onNext("three");
126 verify(stringObserver, times(1)).onNext("four");
127 verify(stringObserver, times(1)).onNext("five");
128 verify(stringObserver, times(1)).onNext("six");
129 verify(stringObserver, times(1)).onNext("seven");
130 verify(stringObserver, times(1)).onNext("eight");
131 verify(stringObserver, times(1)).onNext("nine");
132 }
133
134 @Test
135 public void errorDelayed4WithThreading() {
136 final TestAsyncErrorObservable o1 = new TestAsyncErrorObservable("one", "two", "three");
137 final TestAsyncErrorObservable o2 = new TestAsyncErrorObservable("four", "five", "six");
138 final TestAsyncErrorObservable o3 = new TestAsyncErrorObservable("seven", "eight");
139 // throw the error at the very end so no onComplete will be called after it
140 final TestAsyncErrorObservable o4 = new TestAsyncErrorObservable("nine", null);
141
142 Observable<String> m = Observable.mergeDelayError(Observable.unsafeCreate(o1), Observable.unsafeCreate(o2), Observable.unsafeCreate(o3), Observable.unsafeCreate(o4));
143 m.subscribe(stringObserver);
144
145 try {
146 o1.t.join();
147 o2.t.join();
148 o3.t.join();
149 o4.t.join();
150 } catch (InterruptedException e) {
151 throw new RuntimeException(e);
152 }
153
154 verify(stringObserver, times(1)).onNext("one");
155 verify(stringObserver, times(1)).onNext("two");
156 verify(stringObserver, times(1)).onNext("three");
157 verify(stringObserver, times(1)).onNext("four");
158 verify(stringObserver, times(1)).onNext("five");
159 verify(stringObserver, times(1)).onNext("six");
160 verify(stringObserver, times(1)).onNext("seven");
161 verify(stringObserver, times(1)).onNext("eight");
162 verify(stringObserver, times(1)).onNext("nine");
163 verify(stringObserver, times(1)).onError(any(NullPointerException.class));
164 verify(stringObserver, never()).onComplete();
165 }
166
167 @Test
168 public void compositeErrorDelayed1() {
169 final Observable<String> o1 = Observable.unsafeCreate(new TestErrorObservable("four", null, "six")); // we expect to lose "six" from the source (and it should never be sent by the source since onError was called
170 final Observable<String> o2 = Observable.unsafeCreate(new TestErrorObservable("one", "two", null));
171
172 Observable<String> m = Observable.mergeDelayError(o1, o2);
173 m.subscribe(stringObserver);
174
175 verify(stringObserver, times(1)).onError(any(Throwable.class));
176 verify(stringObserver, never()).onComplete();
177 verify(stringObserver, times(1)).onNext("one");
178 verify(stringObserver, times(1)).onNext("two");
179 verify(stringObserver, times(0)).onNext("three");
180 verify(stringObserver, times(1)).onNext("four");
181 verify(stringObserver, times(0)).onNext("five");
182 // despite not expecting it ... we don't do anything to prevent it if the source Observable keeps sending after onError
183 // inner Observable errors are considered terminal for that source
184 // verify(stringObserver, times(1)).onNext("six");
185 }
186
187 @Test
188 public void compositeErrorDelayed2() {
189 final Observable<String> o1 = Observable.unsafeCreate(new TestErrorObservable("four", null, "six")); // we expect to lose "six" from the source (and it should never be sent by the source since onError was called
190 final Observable<String> o2 = Observable.unsafeCreate(new TestErrorObservable("one", "two", null));
191
192 Observable<String> m = Observable.mergeDelayError(o1, o2);
193 CaptureObserver w = new CaptureObserver();
194 m.subscribe(w);
195
196 assertNotNull(w.e);
197
198 assertEquals(2, ((CompositeException)w.e).size());
199
200 // if (w.e instanceof CompositeException) {
201 // assertEquals(2, ((CompositeException) w.e).getExceptions().size());
202 // w.e.printStackTrace();
203 // } else {
204 // fail("Expecting CompositeException");
205 // }
206
207 }
208
209 /**
210 * The unit tests below are from OperationMerge and should ensure the normal merge functionality is correct.
211 */
212
213 @Test
214 public void mergeObservableOfObservables() {
215 final Observable<String> o1 = Observable.unsafeCreate(new TestSynchronousObservable());
216 final Observable<String> o2 = Observable.unsafeCreate(new TestSynchronousObservable());
217
218 Observable<Observable<String>> observableOfObservables = Observable.unsafeCreate(new ObservableSource<Observable<String>>() {
219
220 @Override
221 public void subscribe(Observer<? super Observable<String>> observer) {
222 observer.onSubscribe(Disposable.empty());
223 // simulate what would happen in an Observable
224 observer.onNext(o1);
225 observer.onNext(o2);
226 observer.onComplete();
227 }
228
229 });
230 Observable<String> m = Observable.mergeDelayError(observableOfObservables);
231 m.subscribe(stringObserver);
232
233 verify(stringObserver, never()).onError(any(Throwable.class));
234 verify(stringObserver, times(1)).onComplete();
235 verify(stringObserver, times(2)).onNext("hello");
236 }
237
238 @Test
239 public void mergeArray() {
240 final Observable<String> o1 = Observable.unsafeCreate(new TestSynchronousObservable());
241 final Observable<String> o2 = Observable.unsafeCreate(new TestSynchronousObservable());
242
243 Observable<String> m = Observable.mergeDelayError(o1, o2);
244 m.subscribe(stringObserver);
245
246 verify(stringObserver, never()).onError(any(Throwable.class));
247 verify(stringObserver, times(2)).onNext("hello");
248 verify(stringObserver, times(1)).onComplete();
249 }
250
251 @Test
252 public void mergeList() {
253 final Observable<String> o1 = Observable.unsafeCreate(new TestSynchronousObservable());
254 final Observable<String> o2 = Observable.unsafeCreate(new TestSynchronousObservable());
255 List<Observable<String>> listOfObservables = new ArrayList<>();
256 listOfObservables.add(o1);
257 listOfObservables.add(o2);
258
259 Observable<String> m = Observable.mergeDelayError(Observable.fromIterable(listOfObservables));
260 m.subscribe(stringObserver);
261
262 verify(stringObserver, never()).onError(any(Throwable.class));
263 verify(stringObserver, times(1)).onComplete();
264 verify(stringObserver, times(2)).onNext("hello");
265 }
266
267 @Test
268 public void mergeArrayWithThreading() {
269 final TestASynchronousObservable o1 = new TestASynchronousObservable();
270 final TestASynchronousObservable o2 = new TestASynchronousObservable();
271
272 Observable<String> m = Observable.mergeDelayError(Observable.unsafeCreate(o1), Observable.unsafeCreate(o2));
273 m.subscribe(stringObserver);
274
275 try {
276 o1.t.join();
277 o2.t.join();
278 } catch (InterruptedException e) {
279 throw new RuntimeException(e);
280 }
281
282 verify(stringObserver, never()).onError(any(Throwable.class));
283 verify(stringObserver, times(2)).onNext("hello");
284 verify(stringObserver, times(1)).onComplete();
285 }
286
287 @Test
288 public void synchronousError() {
289 final Observable<Observable<String>> o1 = Observable.error(new RuntimeException("unit test"));
290
291 final CountDownLatch latch = new CountDownLatch(1);
292 Observable.mergeDelayError(o1).subscribe(new DefaultObserver<String>() {
293 @Override
294 public void onComplete() {
295 fail("Expected onError path");
296 }
297
298 @Override
299 public void onError(Throwable e) {
300 latch.countDown();
301 }
302
303 @Override
304 public void onNext(String s) {
305 fail("Expected onError path");
306 }
307 });
308
309 try {
310 latch.await();
311 } catch (InterruptedException ex) {
312 fail("interrupted");
313 }
314 }
315
316 private static class TestSynchronousObservable implements ObservableSource<String> {
317
318 @Override
319 public void subscribe(Observer<? super String> observer) {
320 observer.onSubscribe(Disposable.empty());
321 observer.onNext("hello");
322 observer.onComplete();
323 }
324 }
325
326 private static class TestASynchronousObservable implements ObservableSource<String> {
327 Thread t;
328
329 @Override
330 public void subscribe(final Observer<? super String> observer) {
331 observer.onSubscribe(Disposable.empty());
332 t = new Thread(new Runnable() {
333
334 @Override
335 public void run() {
336 observer.onNext("hello");
337 observer.onComplete();
338 }
339
340 });
341 t.start();
342 }
343 }
344
345 private static class TestErrorObservable implements ObservableSource<String> {
346
347 String[] valuesToReturn;
348
349 TestErrorObservable(String... values) {
350 valuesToReturn = values;
351 }
352
353 @Override
354 public void subscribe(Observer<? super String> observer) {
355 observer.onSubscribe(Disposable.empty());
356 boolean errorThrown = false;
357 for (String s : valuesToReturn) {
358 if (s == null) {
359 System.out.println("throwing exception");
360 observer.onError(new NullPointerException());
361 errorThrown = true;
362 // purposefully not returning here so it will continue calling onNext
363 // so that we also test that we handle bad sequences like this
364 } else {
365 observer.onNext(s);
366 }
367 }
368 if (!errorThrown) {
369 observer.onComplete();
370 }
371 }
372 }
373
374 private static class TestAsyncErrorObservable implements ObservableSource<String> {
375
376 String[] valuesToReturn;
377
378 TestAsyncErrorObservable(String... values) {
379 valuesToReturn = values;
380 }
381
382 Thread t;
383
384 @Override
385 public void subscribe(final Observer<? super String> observer) {
386 observer.onSubscribe(Disposable.empty());
387 t = new Thread(new Runnable() {
388
389 @Override
390 public void run() {
391 for (String s : valuesToReturn) {
392 if (s == null) {
393 System.out.println("throwing exception");
394 try {
395 Thread.sleep(100);
396 } catch (Throwable e) {
397
398 }
399 observer.onError(new NullPointerException());
400 return;
401 } else {
402 observer.onNext(s);
403 }
404 }
405 System.out.println("subscription complete");
406 observer.onComplete();
407 }
408
409 });
410 t.start();
411 }
412 }
413
414 private static class CaptureObserver extends DefaultObserver<String> {
415 volatile Throwable e;
416
417 @Override
418 public void onComplete() {
419
420 }
421
422 @Override
423 public void onError(Throwable e) {
424 this.e = e;
425 }
426
427 @Override
428 public void onNext(String args) {
429
430 }
431
432 }
433
434 @Test
435 public void errorInParentObservable() {
436 TestObserverEx<Integer> to = new TestObserverEx<>();
437 Observable.mergeDelayError(
438 Observable.just(Observable.just(1), Observable.just(2))
439 .startWithItem(Observable.<Integer> error(new RuntimeException()))
440 ).subscribe(to);
441 to.awaitDone(5, TimeUnit.SECONDS);
442 to.assertTerminated();
443 to.assertValues(1, 2);
444 assertEquals(1, to.errors().size());
445
446 }
447
448 @Test
449 public void errorInParentObservableDelayed() throws Exception {
450 for (int i = 0; i < 50; i++) {
451 final TestASynchronous1sDelayedObservable o1 = new TestASynchronous1sDelayedObservable();
452 final TestASynchronous1sDelayedObservable o2 = new TestASynchronous1sDelayedObservable();
453 Observable<Observable<String>> parentObservable = Observable.unsafeCreate(new ObservableSource<Observable<String>>() {
454 @Override
455 public void subscribe(Observer<? super Observable<String>> op) {
456 op.onSubscribe(Disposable.empty());
457 op.onNext(Observable.unsafeCreate(o1));
458 op.onNext(Observable.unsafeCreate(o2));
459 op.onError(new NullPointerException("throwing exception in parent"));
460 }
461 });
462
463 Observer<String> stringObserver = TestHelper.mockObserver();
464
465 TestObserverEx<String> to = new TestObserverEx<>(stringObserver);
466 Observable<String> m = Observable.mergeDelayError(parentObservable);
467 m.subscribe(to);
468 System.out.println("testErrorInParentObservableDelayed | " + i);
469 to.awaitDone(2000, TimeUnit.MILLISECONDS);
470 to.assertTerminated();
471
472 verify(stringObserver, times(2)).onNext("hello");
473 verify(stringObserver, times(1)).onError(any(NullPointerException.class));
474 verify(stringObserver, never()).onComplete();
475 }
476 }
477
478 private static class TestASynchronous1sDelayedObservable implements ObservableSource<String> {
479 Thread t;
480
481 @Override
482 public void subscribe(final Observer<? super String> observer) {
483 observer.onSubscribe(Disposable.empty());
484 t = new Thread(new Runnable() {
485
486 @Override
487 public void run() {
488 try {
489 Thread.sleep(100);
490 } catch (InterruptedException e) {
491 observer.onError(e);
492 }
493 observer.onNext("hello");
494 observer.onComplete();
495 }
496
497 });
498 t.start();
499 }
500 }
501
502 @Test
503 public void mergeIterableDelayError() {
504 Observable.mergeDelayError(Arrays.asList(Observable.just(1), Observable.just(2)))
505 .test()
506 .assertResult(1, 2);
507 }
508
509 @Test
510 public void mergeArrayDelayError() {
511 Observable.mergeArrayDelayError(Observable.just(1), Observable.just(2))
512 .test()
513 .assertResult(1, 2);
514 }
515
516 @Test
517 public void mergeIterableDelayErrorWithError() {
518 Observable.mergeDelayError(
519 Arrays.asList(Observable.just(1).concatWith(Observable.<Integer>error(new TestException())),
520 Observable.just(2)))
521 .test()
522 .assertFailure(TestException.class, 1, 2);
523 }
524
525 @Test
526 public void mergeDelayError() {
527 Observable.mergeDelayError(
528 Observable.just(Observable.just(1),
529 Observable.just(2)))
530 .test()
531 .assertResult(1, 2);
532 }
533
534 @Test
535 public void mergeDelayErrorWithError() {
536 Observable.mergeDelayError(
537 Observable.just(Observable.just(1).concatWith(Observable.<Integer>error(new TestException())),
538 Observable.just(2)))
539 .test()
540 .assertFailure(TestException.class, 1, 2);
541 }
542
543 @Test
544 public void mergeDelayErrorMaxConcurrency() {
545 Observable.mergeDelayError(
546 Observable.just(Observable.just(1),
547 Observable.just(2)), 1)
548 .test()
549 .assertResult(1, 2);
550 }
551
552 @Test
553 public void mergeDelayErrorWithErrorMaxConcurrency() {
554 Observable.mergeDelayError(
555 Observable.just(Observable.just(1).concatWith(Observable.<Integer>error(new TestException())),
556 Observable.just(2)), 1)
557 .test()
558 .assertFailure(TestException.class, 1, 2);
559 }
560
561 @Test
562 public void mergeIterableDelayErrorMaxConcurrency() {
563 Observable.mergeDelayError(
564 Arrays.asList(Observable.just(1),
565 Observable.just(2)), 1)
566 .test()
567 .assertResult(1, 2);
568 }
569
570 @Test
571 public void mergeIterableDelayErrorWithErrorMaxConcurrency() {
572 Observable.mergeDelayError(
573 Arrays.asList(Observable.just(1).concatWith(Observable.<Integer>error(new TestException())),
574 Observable.just(2)), 1)
575 .test()
576 .assertFailure(TestException.class, 1, 2);
577 }
578
579 @Test
580 public void mergeDelayError3() {
581 Observable.mergeDelayError(
582 Observable.just(1),
583 Observable.just(2),
584 Observable.just(3)
585 )
586 .test()
587 .assertResult(1, 2, 3);
588 }
589
590 @Test
591 public void mergeDelayError3WithError() {
592 Observable.mergeDelayError(
593 Observable.just(1),
594 Observable.just(2).concatWith(Observable.<Integer>error(new TestException())),
595 Observable.just(3)
596 )
597 .test()
598 .assertFailure(TestException.class, 1, 2, 3);
599 }
600
601 }