Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableConcatTest.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.*;
22 import java.util.concurrent.atomic.*;
23
24 import org.junit.Test;
25 import org.mockito.InOrder;
26
27 import io.reactivex.rxjava3.core.*;
28 import io.reactivex.rxjava3.core.Observable;
29 import io.reactivex.rxjava3.core.Observer;
30 import io.reactivex.rxjava3.disposables.*;
31 import io.reactivex.rxjava3.exceptions.TestException;
32 import io.reactivex.rxjava3.functions.*;
33 import io.reactivex.rxjava3.internal.functions.Functions;
34 import io.reactivex.rxjava3.observers.*;
35 import io.reactivex.rxjava3.schedulers.*;
36 import io.reactivex.rxjava3.subjects.*;
37 import io.reactivex.rxjava3.testsupport.*;
38
39 public class ObservableConcatTest extends RxJavaTest {
40
41 @Test
42 public void concat() {
43 Observer<String> observer = TestHelper.mockObserver();
44
45 final String[] o = { "1", "3", "5", "7" };
46 final String[] e = { "2", "4", "6" };
47
48 final Observable<String> odds = Observable.fromArray(o);
49 final Observable<String> even = Observable.fromArray(e);
50
51 Observable<String> concat = Observable.concat(odds, even);
52 concat.subscribe(observer);
53
54 verify(observer, times(7)).onNext(anyString());
55 }
56
57 @Test
58 public void concatWithList() {
59 Observer<String> observer = TestHelper.mockObserver();
60
61 final String[] o = { "1", "3", "5", "7" };
62 final String[] e = { "2", "4", "6" };
63
64 final Observable<String> odds = Observable.fromArray(o);
65 final Observable<String> even = Observable.fromArray(e);
66 final List<Observable<String>> list = new ArrayList<>();
67 list.add(odds);
68 list.add(even);
69 Observable<String> concat = Observable.concat(Observable.fromIterable(list));
70 concat.subscribe(observer);
71
72 verify(observer, times(7)).onNext(anyString());
73 }
74
75 @Test
76 public void concatObservableOfObservables() {
77 Observer<String> observer = TestHelper.mockObserver();
78
79 final String[] o = { "1", "3", "5", "7" };
80 final String[] e = { "2", "4", "6" };
81
82 final Observable<String> odds = Observable.fromArray(o);
83 final Observable<String> even = Observable.fromArray(e);
84
85 Observable<Observable<String>> observableOfObservables = Observable.unsafeCreate(new ObservableSource<Observable<String>>() {
86
87 @Override
88 public void subscribe(Observer<? super Observable<String>> observer) {
89 observer.onSubscribe(Disposable.empty());
90 // simulate what would happen in an Observable
91 observer.onNext(odds);
92 observer.onNext(even);
93 observer.onComplete();
94 }
95
96 });
97 Observable<String> concat = Observable.concat(observableOfObservables);
98
99 concat.subscribe(observer);
100
101 verify(observer, times(7)).onNext(anyString());
102 }
103
104 /**
105 * Simple concat of 2 asynchronous observables ensuring it emits in correct order.
106 */
107 @Test
108 public void simpleAsyncConcat() {
109 Observer<String> observer = TestHelper.mockObserver();
110
111 TestObservable<String> o1 = new TestObservable<>("one", "two", "three");
112 TestObservable<String> o2 = new TestObservable<>("four", "five", "six");
113
114 Observable.concat(Observable.unsafeCreate(o1), Observable.unsafeCreate(o2)).subscribe(observer);
115
116 try {
117 // wait for async observables to complete
118 o1.t.join();
119 o2.t.join();
120 } catch (Throwable e) {
121 throw new RuntimeException("failed waiting on threads");
122 }
123
124 InOrder inOrder = inOrder(observer);
125 inOrder.verify(observer, times(1)).onNext("one");
126 inOrder.verify(observer, times(1)).onNext("two");
127 inOrder.verify(observer, times(1)).onNext("three");
128 inOrder.verify(observer, times(1)).onNext("four");
129 inOrder.verify(observer, times(1)).onNext("five");
130 inOrder.verify(observer, times(1)).onNext("six");
131 }
132
133 @Test
134 public void nestedAsyncConcatLoop() throws Throwable {
135 for (int i = 0; i < 500; i++) {
136 if (i % 10 == 0) {
137 System.out.println("testNestedAsyncConcat >> " + i);
138 }
139 nestedAsyncConcat();
140 }
141 }
142
143 /**
144 * Test an async Observable that emits more async Observables.
145 * @throws InterruptedException if the test is interrupted
146 */
147 @Test
148 public void nestedAsyncConcat() throws InterruptedException {
149 Observer<String> observer = TestHelper.mockObserver();
150
151 final TestObservable<String> o1 = new TestObservable<>("one", "two", "three");
152 final TestObservable<String> o2 = new TestObservable<>("four", "five", "six");
153 final TestObservable<String> o3 = new TestObservable<>("seven", "eight", "nine");
154 final CountDownLatch allowThird = new CountDownLatch(1);
155
156 final AtomicReference<Thread> parent = new AtomicReference<>();
157 final CountDownLatch parentHasStarted = new CountDownLatch(1);
158 final CountDownLatch parentHasFinished = new CountDownLatch(1);
159
160 Observable<Observable<String>> observableOfObservables = Observable.unsafeCreate(new ObservableSource<Observable<String>>() {
161
162 @Override
163 public void subscribe(final Observer<? super Observable<String>> observer) {
164 final Disposable d = Disposable.empty();
165 observer.onSubscribe(d);
166 parent.set(new Thread(new Runnable() {
167
168 @Override
169 public void run() {
170 try {
171 // emit first
172 if (!d.isDisposed()) {
173 System.out.println("Emit o1");
174 observer.onNext(Observable.unsafeCreate(o1));
175 }
176 // emit second
177 if (!d.isDisposed()) {
178 System.out.println("Emit o2");
179 observer.onNext(Observable.unsafeCreate(o2));
180 }
181
182 // wait until sometime later and emit third
183 try {
184 allowThird.await();
185 } catch (InterruptedException e) {
186 observer.onError(e);
187 }
188 if (!d.isDisposed()) {
189 System.out.println("Emit o3");
190 observer.onNext(Observable.unsafeCreate(o3));
191 }
192
193 } catch (Throwable e) {
194 observer.onError(e);
195 } finally {
196 System.out.println("Done parent Observable");
197 observer.onComplete();
198 parentHasFinished.countDown();
199 }
200 }
201 }));
202 parent.get().start();
203 parentHasStarted.countDown();
204 }
205 });
206
207 Observable.concat(observableOfObservables).subscribe(observer);
208
209 // wait for parent to start
210 parentHasStarted.await();
211
212 try {
213 // wait for first 2 async observables to complete
214 System.out.println("Thread1 is starting ... waiting for it to complete ...");
215 o1.waitForThreadDone();
216 System.out.println("Thread2 is starting ... waiting for it to complete ...");
217 o2.waitForThreadDone();
218 } catch (Throwable e) {
219 throw new RuntimeException("failed waiting on threads", e);
220 }
221
222 InOrder inOrder = inOrder(observer);
223 inOrder.verify(observer, times(1)).onNext("one");
224 inOrder.verify(observer, times(1)).onNext("two");
225 inOrder.verify(observer, times(1)).onNext("three");
226 inOrder.verify(observer, times(1)).onNext("four");
227 inOrder.verify(observer, times(1)).onNext("five");
228 inOrder.verify(observer, times(1)).onNext("six");
229 // we shouldn't have the following 3 yet
230 inOrder.verify(observer, never()).onNext("seven");
231 inOrder.verify(observer, never()).onNext("eight");
232 inOrder.verify(observer, never()).onNext("nine");
233 // we should not be completed yet
234 verify(observer, never()).onComplete();
235 verify(observer, never()).onError(any(Throwable.class));
236
237 // now allow the third
238 allowThird.countDown();
239
240 try {
241 // wait for 3rd to complete
242 o3.waitForThreadDone();
243 } catch (Throwable e) {
244 throw new RuntimeException("failed waiting on threads", e);
245 }
246
247 try {
248 // wait for the parent to complete
249 if (!parentHasFinished.await(5, TimeUnit.SECONDS)) {
250 fail("Parent didn't finish within the time limit");
251 }
252 } catch (Throwable e) {
253 throw new RuntimeException("failed waiting on threads", e);
254 }
255
256 inOrder.verify(observer, times(1)).onNext("seven");
257 inOrder.verify(observer, times(1)).onNext("eight");
258 inOrder.verify(observer, times(1)).onNext("nine");
259
260 verify(observer, never()).onError(any(Throwable.class));
261 inOrder.verify(observer, times(1)).onComplete();
262 }
263
264 @Test
265 public void blockedObservableOfObservables() {
266 Observer<String> observer = TestHelper.mockObserver();
267
268 final String[] o = { "1", "3", "5", "7" };
269 final String[] e = { "2", "4", "6" };
270 final Observable<String> odds = Observable.fromArray(o);
271 final Observable<String> even = Observable.fromArray(e);
272 final CountDownLatch callOnce = new CountDownLatch(1);
273 final CountDownLatch okToContinue = new CountDownLatch(1);
274
275 TestObservable<Observable<String>> observableOfObservables = new TestObservable<>(callOnce, okToContinue, odds, even);
276 Observable<String> concatF = Observable.concat(Observable.unsafeCreate(observableOfObservables));
277 concatF.subscribe(observer);
278 try {
279 //Block main thread to allow observables to serve up o1.
280 callOnce.await();
281 } catch (Throwable ex) {
282 ex.printStackTrace();
283 fail(ex.getMessage());
284 }
285 // The concated Observable should have served up all of the odds.
286 verify(observer, times(1)).onNext("1");
287 verify(observer, times(1)).onNext("3");
288 verify(observer, times(1)).onNext("5");
289 verify(observer, times(1)).onNext("7");
290
291 try {
292 // unblock observables so it can serve up o2 and complete
293 okToContinue.countDown();
294 observableOfObservables.t.join();
295 } catch (Throwable ex) {
296 ex.printStackTrace();
297 fail(ex.getMessage());
298 }
299 // The concatenated Observable should now have served up all the evens.
300 verify(observer, times(1)).onNext("2");
301 verify(observer, times(1)).onNext("4");
302 verify(observer, times(1)).onNext("6");
303 }
304
305 @Test
306 public void concatConcurrentWithInfinity() {
307 final TestObservable<String> w1 = new TestObservable<>("one", "two", "three");
308 //This Observable will send "hello" MAX_VALUE time.
309 final TestObservable<String> w2 = new TestObservable<>("hello", Integer.MAX_VALUE);
310
311 Observer<String> observer = TestHelper.mockObserver();
312
313 TestObservable<Observable<String>> observableOfObservables = new TestObservable<>(Observable.unsafeCreate(w1), Observable.unsafeCreate(w2));
314 Observable<String> concatF = Observable.concat(Observable.unsafeCreate(observableOfObservables));
315
316 concatF.take(50).subscribe(observer);
317
318 //Wait for the thread to start up.
319 try {
320 w1.waitForThreadDone();
321 w2.waitForThreadDone();
322 } catch (InterruptedException e) {
323 e.printStackTrace();
324 }
325
326 InOrder inOrder = inOrder(observer);
327 inOrder.verify(observer, times(1)).onNext("one");
328 inOrder.verify(observer, times(1)).onNext("two");
329 inOrder.verify(observer, times(1)).onNext("three");
330 inOrder.verify(observer, times(47)).onNext("hello");
331 verify(observer, times(1)).onComplete();
332 verify(observer, never()).onError(any(Throwable.class));
333 }
334
335 @Test
336 public void concatNonBlockingObservables() {
337
338 final CountDownLatch okToContinueW1 = new CountDownLatch(1);
339 final CountDownLatch okToContinueW2 = new CountDownLatch(1);
340
341 final TestObservable<String> w1 = new TestObservable<>(null, okToContinueW1, "one", "two", "three");
342 final TestObservable<String> w2 = new TestObservable<>(null, okToContinueW2, "four", "five", "six");
343
344 Observer<String> observer = TestHelper.mockObserver();
345
346 Observable<Observable<String>> observableOfObservables = Observable.unsafeCreate(new ObservableSource<Observable<String>>() {
347
348 @Override
349 public void subscribe(Observer<? super Observable<String>> observer) {
350 observer.onSubscribe(Disposable.empty());
351 // simulate what would happen in an Observable
352 observer.onNext(Observable.unsafeCreate(w1));
353 observer.onNext(Observable.unsafeCreate(w2));
354 observer.onComplete();
355 }
356
357 });
358 Observable<String> concat = Observable.concat(observableOfObservables);
359 concat.subscribe(observer);
360
361 verify(observer, times(0)).onComplete();
362
363 try {
364 // release both threads
365 okToContinueW1.countDown();
366 okToContinueW2.countDown();
367 // wait for both to finish
368 w1.t.join();
369 w2.t.join();
370 } catch (InterruptedException e) {
371 e.printStackTrace();
372 }
373
374 InOrder inOrder = inOrder(observer);
375 inOrder.verify(observer, times(1)).onNext("one");
376 inOrder.verify(observer, times(1)).onNext("two");
377 inOrder.verify(observer, times(1)).onNext("three");
378 inOrder.verify(observer, times(1)).onNext("four");
379 inOrder.verify(observer, times(1)).onNext("five");
380 inOrder.verify(observer, times(1)).onNext("six");
381 verify(observer, times(1)).onComplete();
382
383 }
384
385 /**
386 * Test unsubscribing the concatenated Observable in a single thread.
387 */
388 @Test
389 public void concatUnsubscribe() {
390 final CountDownLatch callOnce = new CountDownLatch(1);
391 final CountDownLatch okToContinue = new CountDownLatch(1);
392 final TestObservable<String> w1 = new TestObservable<>("one", "two", "three");
393 final TestObservable<String> w2 = new TestObservable<>(callOnce, okToContinue, "four", "five", "six");
394
395 Observer<String> observer = TestHelper.mockObserver();
396 TestObserver<String> to = new TestObserver<>(observer);
397
398 final Observable<String> concat = Observable.concat(Observable.unsafeCreate(w1), Observable.unsafeCreate(w2));
399
400 try {
401 // Subscribe
402 concat.subscribe(to);
403 //Block main thread to allow Observable "w1" to complete and Observable "w2" to call onNext once.
404 callOnce.await();
405 // Unsubcribe
406 to.dispose();
407 //Unblock the Observable to continue.
408 okToContinue.countDown();
409 w1.t.join();
410 w2.t.join();
411 } catch (Throwable e) {
412 e.printStackTrace();
413 fail(e.getMessage());
414 }
415
416 InOrder inOrder = inOrder(observer);
417 inOrder.verify(observer, times(1)).onNext("one");
418 inOrder.verify(observer, times(1)).onNext("two");
419 inOrder.verify(observer, times(1)).onNext("three");
420 inOrder.verify(observer, times(1)).onNext("four");
421 inOrder.verify(observer, never()).onNext("five");
422 inOrder.verify(observer, never()).onNext("six");
423 inOrder.verify(observer, never()).onComplete();
424
425 }
426
427 /**
428 * All observables will be running in different threads so subscribe() is unblocked. CountDownLatch is only used in order to call unsubscribe() in a predictable manner.
429 */
430 @Test
431 public void concatUnsubscribeConcurrent() {
432 final CountDownLatch callOnce = new CountDownLatch(1);
433 final CountDownLatch okToContinue = new CountDownLatch(1);
434 final TestObservable<String> w1 = new TestObservable<>("one", "two", "three");
435 final TestObservable<String> w2 = new TestObservable<>(callOnce, okToContinue, "four", "five", "six");
436
437 Observer<String> observer = TestHelper.mockObserver();
438 TestObserver<String> to = new TestObserver<>(observer);
439
440 TestObservable<Observable<String>> observableOfObservables = new TestObservable<>(Observable.unsafeCreate(w1), Observable.unsafeCreate(w2));
441 Observable<String> concatF = Observable.concat(Observable.unsafeCreate(observableOfObservables));
442
443 concatF.subscribe(to);
444
445 try {
446 //Block main thread to allow Observable "w1" to complete and Observable "w2" to call onNext exactly once.
447 callOnce.await();
448 //"four" from w2 has been processed by onNext()
449 to.dispose();
450 //"five" and "six" will NOT be processed by onNext()
451 //Unblock the Observable to continue.
452 okToContinue.countDown();
453 w1.t.join();
454 w2.t.join();
455 } catch (Throwable e) {
456 e.printStackTrace();
457 fail(e.getMessage());
458 }
459
460 InOrder inOrder = inOrder(observer);
461 inOrder.verify(observer, times(1)).onNext("one");
462 inOrder.verify(observer, times(1)).onNext("two");
463 inOrder.verify(observer, times(1)).onNext("three");
464 inOrder.verify(observer, times(1)).onNext("four");
465 inOrder.verify(observer, never()).onNext("five");
466 inOrder.verify(observer, never()).onNext("six");
467 verify(observer, never()).onComplete();
468 verify(observer, never()).onError(any(Throwable.class));
469 }
470
471 static class TestObservable<T> implements ObservableSource<T> {
472
473 private final Disposable upstream = new Disposable() {
474 @Override
475 public void dispose() {
476 subscribed = false;
477 }
478
479 @Override
480 public boolean isDisposed() {
481 return subscribed;
482 }
483 };
484 private final List<T> values;
485 private Thread t;
486 private int count;
487 private volatile boolean subscribed = true;
488 private final CountDownLatch once;
489 private final CountDownLatch okToContinue;
490 private final CountDownLatch threadHasStarted = new CountDownLatch(1);
491 private final T seed;
492 private final int size;
493
494 @SafeVarargs
495 TestObservable(T... values) {
496 this(null, null, values);
497 }
498
499 @SafeVarargs
500 TestObservable(CountDownLatch once, CountDownLatch okToContinue, T... values) {
501 this.values = Arrays.asList(values);
502 this.size = this.values.size();
503 this.once = once;
504 this.okToContinue = okToContinue;
505 this.seed = null;
506 }
507
508 TestObservable(T seed, int size) {
509 values = null;
510 once = null;
511 okToContinue = null;
512 this.seed = seed;
513 this.size = size;
514 }
515
516 @Override
517 public void subscribe(final Observer<? super T> observer) {
518 observer.onSubscribe(upstream);
519 t = new Thread(new Runnable() {
520
521 @Override
522 public void run() {
523 try {
524 while (count < size && subscribed) {
525 if (null != values) {
526 observer.onNext(values.get(count));
527 } else {
528 observer.onNext(seed);
529 }
530 count++;
531 //Unblock the main thread to call unsubscribe.
532 if (null != once) {
533 once.countDown();
534 }
535 //Block until the main thread has called unsubscribe.
536 if (null != okToContinue) {
537 okToContinue.await(5, TimeUnit.SECONDS);
538 }
539 }
540 if (subscribed) {
541 observer.onComplete();
542 }
543 } catch (InterruptedException e) {
544 e.printStackTrace();
545 fail(e.getMessage());
546 }
547 }
548
549 });
550 t.start();
551 threadHasStarted.countDown();
552 }
553
554 void waitForThreadDone() throws InterruptedException {
555 threadHasStarted.await();
556 t.join();
557 }
558 }
559
560 @Test
561 public void multipleObservers() {
562 Observer<Object> o1 = TestHelper.mockObserver();
563 Observer<Object> o2 = TestHelper.mockObserver();
564
565 TestScheduler s = new TestScheduler();
566
567 Observable<Long> timer = Observable.interval(500, TimeUnit.MILLISECONDS, s).take(2);
568 Observable<Long> o = Observable.concat(timer, timer);
569
570 o.subscribe(o1);
571 o.subscribe(o2);
572
573 InOrder inOrder1 = inOrder(o1);
574 InOrder inOrder2 = inOrder(o2);
575
576 s.advanceTimeBy(500, TimeUnit.MILLISECONDS);
577
578 inOrder1.verify(o1, times(1)).onNext(0L);
579 inOrder2.verify(o2, times(1)).onNext(0L);
580
581 s.advanceTimeBy(500, TimeUnit.MILLISECONDS);
582
583 inOrder1.verify(o1, times(1)).onNext(1L);
584 inOrder2.verify(o2, times(1)).onNext(1L);
585
586 s.advanceTimeBy(500, TimeUnit.MILLISECONDS);
587
588 inOrder1.verify(o1, times(1)).onNext(0L);
589 inOrder2.verify(o2, times(1)).onNext(0L);
590
591 s.advanceTimeBy(500, TimeUnit.MILLISECONDS);
592
593 inOrder1.verify(o1, times(1)).onNext(1L);
594 inOrder2.verify(o2, times(1)).onNext(1L);
595
596 inOrder1.verify(o1, times(1)).onComplete();
597 inOrder2.verify(o2, times(1)).onComplete();
598
599 verify(o1, never()).onError(any(Throwable.class));
600 verify(o2, never()).onError(any(Throwable.class));
601 }
602
603 @Test
604 public void concatVeryLongObservableOfObservables() {
605 final int n = 10000;
606 Observable<Observable<Integer>> source = Observable.range(0, n).map(new Function<Integer, Observable<Integer>>() {
607 @Override
608 public Observable<Integer> apply(Integer v) {
609 return Observable.just(v);
610 }
611 });
612
613 Single<List<Integer>> result = Observable.concat(source).toList();
614
615 SingleObserver<List<Integer>> o = TestHelper.mockSingleObserver();
616 InOrder inOrder = inOrder(o);
617
618 result.subscribe(o);
619
620 List<Integer> list = new ArrayList<>(n);
621 for (int i = 0; i < n; i++) {
622 list.add(i);
623 }
624 inOrder.verify(o).onSuccess(list);
625 verify(o, never()).onError(any(Throwable.class));
626 }
627
628 @Test
629 public void concatVeryLongObservableOfObservablesTakeHalf() {
630 final int n = 10000;
631 Observable<Observable<Integer>> source = Observable.range(0, n).map(new Function<Integer, Observable<Integer>>() {
632 @Override
633 public Observable<Integer> apply(Integer v) {
634 return Observable.just(v);
635 }
636 });
637
638 Single<List<Integer>> result = Observable.concat(source).take(n / 2).toList();
639
640 SingleObserver<List<Integer>> o = TestHelper.mockSingleObserver();
641 InOrder inOrder = inOrder(o);
642
643 result.subscribe(o);
644
645 List<Integer> list = new ArrayList<>(n);
646 for (int i = 0; i < n / 2; i++) {
647 list.add(i);
648 }
649 inOrder.verify(o).onSuccess(list);
650 verify(o, never()).onError(any(Throwable.class));
651 }
652
653 @Test
654 public void concatOuterBackpressure() {
655 assertEquals(1,
656 (int) Observable.<Integer> empty()
657 .concatWith(Observable.just(1))
658 .take(1)
659 .blockingSingle());
660 }
661
662 // https://github.com/ReactiveX/RxJava/issues/1818
663 @Test
664 public void concatWithNonCompliantSourceDoubleOnComplete() {
665 Observable<String> o = Observable.unsafeCreate(new ObservableSource<String>() {
666
667 @Override
668 public void subscribe(Observer<? super String> observer) {
669 observer.onSubscribe(Disposable.empty());
670 observer.onNext("hello");
671 observer.onComplete();
672 observer.onComplete();
673 }
674
675 });
676
677 TestObserverEx<String> to = new TestObserverEx<>();
678 Observable.concat(o, o).subscribe(to);
679 to.awaitDone(500, TimeUnit.MILLISECONDS);
680 to.assertTerminated();
681 to.assertNoErrors();
682 to.assertValues("hello", "hello");
683 }
684
685 @Test
686 public void issue2890NoStackoverflow() throws InterruptedException, TimeoutException {
687 final ExecutorService executor = Executors.newFixedThreadPool(2);
688 final Scheduler sch = Schedulers.from(executor);
689
690 Function<Integer, Observable<Integer>> func = new Function<Integer, Observable<Integer>>() {
691 @Override
692 public Observable<Integer> apply(Integer t) {
693 Observable<Integer> o = Observable.just(t)
694 .subscribeOn(sch)
695 ;
696 Subject<Integer> subject = UnicastSubject.create();
697 o.subscribe(subject);
698 return subject;
699 }
700 };
701
702 int n = 5000;
703 final AtomicInteger counter = new AtomicInteger();
704
705 Observable.range(1, n)
706 .concatMap(func).subscribe(new DefaultObserver<Integer>() {
707 @Override
708 public void onNext(Integer t) {
709 // Consume after sleep for 1 ms
710 try {
711 Thread.sleep(1);
712 } catch (InterruptedException e) {
713 // ignored
714 }
715 if (counter.getAndIncrement() % 100 == 0) {
716 System.out.println("testIssue2890NoStackoverflow -> " + counter.get());
717 };
718 }
719
720 @Override
721 public void onComplete() {
722 executor.shutdown();
723 }
724
725 @Override
726 public void onError(Throwable e) {
727 executor.shutdown();
728 }
729 });
730
731 long awaitTerminationTimeout = 100_000;
732 if (!executor.awaitTermination(awaitTerminationTimeout, TimeUnit.MILLISECONDS)) {
733 throw new TimeoutException("Completed " + counter.get() + "/" + n + " before timed out after "
734 + awaitTerminationTimeout + " milliseconds.");
735 }
736
737 assertEquals(n, counter.get());
738 }
739
740 @Test
741 public void concatMapRangeAsyncLoopIssue2876() {
742 final long durationSeconds = 2;
743 final long startTime = System.currentTimeMillis();
744 for (int i = 0;; i++) {
745 //only run this for a max of ten seconds
746 if (System.currentTimeMillis() - startTime > TimeUnit.SECONDS.toMillis(durationSeconds)) {
747 return;
748 }
749 if (i % 1000 == 0) {
750 System.out.println("concatMapRangeAsyncLoop > " + i);
751 }
752 TestObserverEx<Integer> to = new TestObserverEx<>();
753
754 Observable.range(0, 1000)
755 .concatMap(new Function<Integer, Observable<Integer>>() {
756 @Override
757 public Observable<Integer> apply(Integer t) {
758 return Observable.fromIterable(Arrays.asList(t));
759 }
760 })
761 .observeOn(Schedulers.computation())
762 .subscribe(to);
763
764 to.awaitDone(2500, TimeUnit.MILLISECONDS);
765 to.assertTerminated();
766 to.assertNoErrors();
767 assertEquals(1000, to.values().size());
768 assertEquals((Integer)999, to.values().get(999));
769 }
770 }
771
772 @Test
773 public void concat3() {
774 Observable.concat(Observable.just(1), Observable.just(2), Observable.just(3))
775 .test()
776 .assertResult(1, 2, 3);
777 }
778
779 @Test
780 public void concat4() {
781 Observable.concat(Observable.just(1), Observable.just(2),
782 Observable.just(3), Observable.just(4))
783 .test()
784 .assertResult(1, 2, 3, 4);
785 }
786
787 @Test
788 public void concatArrayDelayError() {
789 Observable.concatArrayDelayError(Observable.just(1), Observable.just(2),
790 Observable.just(3), Observable.just(4))
791 .test()
792 .assertResult(1, 2, 3, 4);
793 }
794
795 @Test
796 public void concatArrayDelayErrorWithError() {
797 Observable.concatArrayDelayError(Observable.just(1), Observable.just(2),
798 Observable.just(3).concatWith(Observable.<Integer>error(new TestException())),
799 Observable.just(4))
800 .test()
801 .assertFailure(TestException.class, 1, 2, 3, 4);
802 }
803
804 @Test
805 public void concatIterableDelayError() {
806 Observable.concatDelayError(
807 Arrays.asList(Observable.just(1), Observable.just(2),
808 Observable.just(3), Observable.just(4)))
809 .test()
810 .assertResult(1, 2, 3, 4);
811 }
812
813 @Test
814 public void concatIterableDelayErrorWithError() {
815 Observable.concatDelayError(
816 Arrays.asList(Observable.just(1), Observable.just(2),
817 Observable.just(3).concatWith(Observable.<Integer>error(new TestException())),
818 Observable.just(4)))
819 .test()
820 .assertFailure(TestException.class, 1, 2, 3, 4);
821 }
822
823 @Test
824 public void concatObservableDelayError() {
825 Observable.concatDelayError(
826 Observable.just(Observable.just(1), Observable.just(2),
827 Observable.just(3), Observable.just(4)))
828 .test()
829 .assertResult(1, 2, 3, 4);
830 }
831
832 @Test
833 public void concatObservableDelayErrorWithError() {
834 Observable.concatDelayError(
835 Observable.just(Observable.just(1), Observable.just(2),
836 Observable.just(3).concatWith(Observable.<Integer>error(new TestException())),
837 Observable.just(4)))
838 .test()
839 .assertFailure(TestException.class, 1, 2, 3, 4);
840 }
841
842 @Test
843 public void concatObservableDelayErrorBoundary() {
844 Observable.concatDelayError(
845 Observable.just(Observable.just(1), Observable.just(2),
846 Observable.just(3).concatWith(Observable.<Integer>error(new TestException())),
847 Observable.just(4)), 2, false)
848 .test()
849 .assertFailure(TestException.class, 1, 2, 3);
850 }
851
852 @Test
853 public void concatObservableDelayErrorTillEnd() {
854 Observable.concatDelayError(
855 Observable.just(Observable.just(1), Observable.just(2),
856 Observable.just(3).concatWith(Observable.<Integer>error(new TestException())),
857 Observable.just(4)), 2, true)
858 .test()
859 .assertFailure(TestException.class, 1, 2, 3, 4);
860 }
861
862 @Test
863 public void concatMapDelayError() {
864 Observable.just(Observable.just(1), Observable.just(2))
865 .concatMapDelayError(Functions.<Observable<Integer>>identity())
866 .test()
867 .assertResult(1, 2);
868 }
869
870 @Test
871 public void concatMapDelayErrorWithError() {
872 Observable.just(Observable.just(1).concatWith(Observable.<Integer>error(new TestException())), Observable.just(2))
873 .concatMapDelayError(Functions.<Observable<Integer>>identity())
874 .test()
875 .assertFailure(TestException.class, 1, 2);
876 }
877
878 @Test
879 public void concatMapIterableBufferSize() {
880
881 Observable.just(1, 2).concatMapIterable(new Function<Integer, Iterable<Integer>>() {
882 @Override
883 public Iterable<Integer> apply(Integer v) throws Exception {
884 return Arrays.asList(1, 2, 3, 4, 5);
885 }
886 })
887 .test()
888 .assertResult(1, 2, 3, 4, 5, 1, 2, 3, 4, 5);
889 }
890
891 @Test
892 public void emptyArray() {
893 assertSame(Observable.empty(), Observable.concatArrayDelayError());
894 }
895
896 @Test
897 public void singleElementArray() {
898 assertSame(Observable.never(), Observable.concatArrayDelayError(Observable.never()));
899 }
900
901 @Test
902 public void concatMapDelayErrorEmptySource() {
903 assertSame(Observable.empty(), Observable.<Object>empty()
904 .concatMapDelayError(new Function<Object, ObservableSource<Integer>>() {
905 @Override
906 public ObservableSource<Integer> apply(Object v) throws Exception {
907 return Observable.just(1);
908 }
909 }, true, 16));
910 }
911
912 @Test
913 public void concatMapDelayErrorJustSource() {
914 Observable.just(0)
915 .concatMapDelayError(new Function<Object, ObservableSource<Integer>>() {
916 @Override
917 public ObservableSource<Integer> apply(Object v) throws Exception {
918 return Observable.just(1);
919 }
920 }, true, 16)
921 .test()
922 .assertResult(1);
923
924 }
925
926 @Test
927 public void concatArrayEmpty() {
928 assertSame(Observable.empty(), Observable.concatArray());
929 }
930
931 @Test
932 public void concatArraySingleElement() {
933 assertSame(Observable.never(), Observable.concatArray(Observable.never()));
934 }
935
936 @Test
937 public void concatMapErrorEmptySource() {
938 assertSame(Observable.empty(), Observable.<Object>empty()
939 .concatMap(new Function<Object, ObservableSource<Integer>>() {
940 @Override
941 public ObservableSource<Integer> apply(Object v) throws Exception {
942 return Observable.just(1);
943 }
944 }, 16));
945 }
946
947 @Test
948 public void concatMapJustSource() {
949 Observable.just(0)
950 .concatMap(new Function<Object, ObservableSource<Integer>>() {
951 @Override
952 public ObservableSource<Integer> apply(Object v) throws Exception {
953 return Observable.just(1);
954 }
955 }, 16)
956 .test()
957 .assertResult(1);
958
959 }
960
961 @Test
962 public void noSubsequentSubscription() {
963 final int[] calls = { 0 };
964
965 Observable<Integer> source = Observable.create(new ObservableOnSubscribe<Integer>() {
966 @Override
967 public void subscribe(ObservableEmitter<Integer> s) throws Exception {
968 calls[0]++;
969 s.onNext(1);
970 s.onComplete();
971 }
972 });
973
974 Observable.concatArray(source, source).firstElement()
975 .test()
976 .assertResult(1);
977
978 assertEquals(1, calls[0]);
979 }
980
981 @Test
982 public void noSubsequentSubscriptionDelayError() {
983 final int[] calls = { 0 };
984
985 Observable<Integer> source = Observable.create(new ObservableOnSubscribe<Integer>() {
986 @Override
987 public void subscribe(ObservableEmitter<Integer> s) throws Exception {
988 calls[0]++;
989 s.onNext(1);
990 s.onComplete();
991 }
992 });
993
994 Observable.concatArrayDelayError(source, source).firstElement()
995 .test()
996 .assertResult(1);
997
998 assertEquals(1, calls[0]);
999 }
1000
1001 @Test
1002 public void noSubsequentSubscriptionIterable() {
1003 final int[] calls = { 0 };
1004
1005 Observable<Integer> source = Observable.create(new ObservableOnSubscribe<Integer>() {
1006 @Override
1007 public void subscribe(ObservableEmitter<Integer> s) throws Exception {
1008 calls[0]++;
1009 s.onNext(1);
1010 s.onComplete();
1011 }
1012 });
1013
1014 Observable.concat(Arrays.asList(source, source)).firstElement()
1015 .test()
1016 .assertResult(1);
1017
1018 assertEquals(1, calls[0]);
1019 }
1020
1021 @Test
1022 public void noSubsequentSubscriptionDelayErrorIterable() {
1023 final int[] calls = { 0 };
1024
1025 Observable<Integer> source = Observable.create(new ObservableOnSubscribe<Integer>() {
1026 @Override
1027 public void subscribe(ObservableEmitter<Integer> s) throws Exception {
1028 calls[0]++;
1029 s.onNext(1);
1030 s.onComplete();
1031 }
1032 });
1033
1034 Observable.concatDelayError(Arrays.asList(source, source)).firstElement()
1035 .test()
1036 .assertResult(1);
1037
1038 assertEquals(1, calls[0]);
1039 }
1040
1041 @Test
1042 public void concatReportsDisposedOnComplete() {
1043 final Disposable[] disposable = { null };
1044
1045 Observable.concat(Observable.just(1), Observable.just(2))
1046 .subscribe(new Observer<Integer>() {
1047
1048 @Override
1049 public void onSubscribe(Disposable d) {
1050 disposable[0] = d;
1051 }
1052
1053 @Override
1054 public void onNext(Integer t) {
1055 }
1056
1057 @Override
1058 public void onError(Throwable e) {
1059 }
1060
1061 @Override
1062 public void onComplete() {
1063 }
1064 });
1065
1066 assertTrue(disposable[0].isDisposed());
1067 }
1068
1069 @Test
1070 public void concatReportsDisposedOnCompleteDelayError() {
1071 final Disposable[] disposable = { null };
1072
1073 Observable.concatArrayDelayError(Observable.just(1), Observable.just(2))
1074 .subscribe(new Observer<Integer>() {
1075
1076 @Override
1077 public void onSubscribe(Disposable d) {
1078 disposable[0] = d;
1079 }
1080
1081 @Override
1082 public void onNext(Integer t) {
1083 }
1084
1085 @Override
1086 public void onError(Throwable e) {
1087 }
1088
1089 @Override
1090 public void onComplete() {
1091 }
1092 });
1093
1094 assertTrue(disposable[0].isDisposed());
1095 }
1096
1097 @Test
1098 public void concatReportsDisposedOnError() {
1099 final Disposable[] disposable = { null };
1100
1101 Observable.concat(Observable.just(1), Observable.<Integer>error(new TestException()))
1102 .subscribe(new Observer<Integer>() {
1103
1104 @Override
1105 public void onSubscribe(Disposable d) {
1106 disposable[0] = d;
1107 }
1108
1109 @Override
1110 public void onNext(Integer t) {
1111 }
1112
1113 @Override
1114 public void onError(Throwable e) {
1115 }
1116
1117 @Override
1118 public void onComplete() {
1119 }
1120 });
1121
1122 assertTrue(disposable[0].isDisposed());
1123 }
1124
1125 @Test
1126 public void concatReportsDisposedOnErrorDelayError() {
1127 final Disposable[] disposable = { null };
1128
1129 Observable.concatArrayDelayError(Observable.just(1), Observable.<Integer>error(new TestException()))
1130 .subscribe(new Observer<Integer>() {
1131
1132 @Override
1133 public void onSubscribe(Disposable d) {
1134 disposable[0] = d;
1135 }
1136
1137 @Override
1138 public void onNext(Integer t) {
1139 }
1140
1141 @Override
1142 public void onError(Throwable e) {
1143 }
1144
1145 @Override
1146 public void onComplete() {
1147 }
1148 });
1149
1150 assertTrue(disposable[0].isDisposed());
1151 }
1152
1153 @Test
1154 public void noCancelPreviousArray() {
1155 final AtomicInteger counter = new AtomicInteger();
1156
1157 Observable<Integer> source = Observable.just(1).doOnDispose(new Action() {
1158 @Override
1159 public void run() throws Exception {
1160 counter.getAndIncrement();
1161 }
1162 });
1163
1164 Observable.concatArray(source, source, source, source, source)
1165 .test()
1166 .assertResult(1, 1, 1, 1, 1);
1167
1168 assertEquals(0, counter.get());
1169 }
1170
1171 @Test
1172 public void noCancelPreviousIterable() {
1173 final AtomicInteger counter = new AtomicInteger();
1174
1175 Observable<Integer> source = Observable.just(1).doOnDispose(new Action() {
1176 @Override
1177 public void run() throws Exception {
1178 counter.getAndIncrement();
1179 }
1180 });
1181
1182 Observable.concat(Arrays.asList(source, source, source, source, source))
1183 .test()
1184 .assertResult(1, 1, 1, 1, 1);
1185
1186 assertEquals(0, counter.get());
1187 }
1188 }