Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableMergeTest.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 import java.util.concurrent.atomic.*;
23
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.core.Scheduler.Worker;
30 import io.reactivex.rxjava3.disposables.*;
31 import io.reactivex.rxjava3.exceptions.TestException;
32 import io.reactivex.rxjava3.functions.*;
33 import io.reactivex.rxjava3.observers.*;
34 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
35 import io.reactivex.rxjava3.schedulers.*;
36 import io.reactivex.rxjava3.testsupport.*;
37
38 public class ObservableMergeTest extends RxJavaTest {
39
40 Observer<String> stringObserver;
41
42 int count;
43
44 @Before
45 public void before() {
46 stringObserver = TestHelper.mockObserver();
47
48 for (Thread t : Thread.getAllStackTraces().keySet()) {
49 if (t.getName().startsWith("RxNewThread")) {
50 count++;
51 }
52 }
53 }
54
55 @After
56 public void after() {
57 try {
58 Thread.sleep(100);
59 } catch (InterruptedException e) {
60 // TODO Auto-generated catch block
61 e.printStackTrace();
62 }
63 for (Thread t : Thread.getAllStackTraces().keySet()) {
64 if (t.getName().startsWith("RxNewThread")) {
65 --count;
66 }
67 }
68 if (count != 0) {
69 throw new IllegalStateException("NewThread leak!");
70 }
71 }
72
73 @Test
74 public void mergeObservableOfObservables() {
75 final Observable<String> o1 = Observable.unsafeCreate(new TestSynchronousObservable());
76 final Observable<String> o2 = Observable.unsafeCreate(new TestSynchronousObservable());
77
78 Observable<Observable<String>> observableOfObservables = Observable.unsafeCreate(new ObservableSource<Observable<String>>() {
79
80 @Override
81 public void subscribe(Observer<? super Observable<String>> observer) {
82 observer.onSubscribe(Disposable.empty());
83 // simulate what would happen in an Observable
84 observer.onNext(o1);
85 observer.onNext(o2);
86 observer.onComplete();
87 }
88
89 });
90 Observable<String> m = Observable.merge(observableOfObservables);
91 m.subscribe(stringObserver);
92
93 verify(stringObserver, never()).onError(any(Throwable.class));
94 verify(stringObserver, times(1)).onComplete();
95 verify(stringObserver, times(2)).onNext("hello");
96 }
97
98 @Test
99 public void mergeArray() {
100 final Observable<String> o1 = Observable.unsafeCreate(new TestSynchronousObservable());
101 final Observable<String> o2 = Observable.unsafeCreate(new TestSynchronousObservable());
102
103 Observable<String> m = Observable.merge(o1, o2);
104 m.subscribe(stringObserver);
105
106 verify(stringObserver, never()).onError(any(Throwable.class));
107 verify(stringObserver, times(2)).onNext("hello");
108 verify(stringObserver, times(1)).onComplete();
109 }
110
111 @Test
112 public void mergeList() {
113 final Observable<String> o1 = Observable.unsafeCreate(new TestSynchronousObservable());
114 final Observable<String> o2 = Observable.unsafeCreate(new TestSynchronousObservable());
115 List<Observable<String>> listOfObservables = new ArrayList<>();
116 listOfObservables.add(o1);
117 listOfObservables.add(o2);
118
119 Observable<String> m = Observable.merge(listOfObservables);
120 m.subscribe(stringObserver);
121
122 verify(stringObserver, never()).onError(any(Throwable.class));
123 verify(stringObserver, times(1)).onComplete();
124 verify(stringObserver, times(2)).onNext("hello");
125 }
126
127 @Test
128 public void unSubscribeObservableOfObservables() throws InterruptedException {
129
130 final AtomicBoolean unsubscribed = new AtomicBoolean();
131 final CountDownLatch latch = new CountDownLatch(1);
132
133 Observable<Observable<Long>> source = Observable.unsafeCreate(new ObservableSource<Observable<Long>>() {
134
135 @Override
136 public void subscribe(final Observer<? super Observable<Long>> observer) {
137 // verbose on purpose so I can track the inside of it
138 final Disposable upstream = Disposable.fromRunnable(new Runnable() {
139 @Override
140 public void run() {
141 System.out.println("*** unsubscribed");
142 unsubscribed.set(true);
143 }
144 });
145 observer.onSubscribe(upstream);
146
147 new Thread(new Runnable() {
148
149 @Override
150 public void run() {
151
152 while (!unsubscribed.get()) {
153 observer.onNext(Observable.just(1L, 2L));
154 }
155 System.out.println("Done looping after unsubscribe: " + unsubscribed.get());
156 observer.onComplete();
157
158 // mark that the thread is finished
159 latch.countDown();
160 }
161 }).start();
162 }
163
164 });
165
166 final AtomicInteger count = new AtomicInteger();
167 Observable.merge(source).take(6).blockingForEach(new Consumer<Long>() {
168
169 @Override
170 public void accept(Long v) {
171 System.out.println("Value: " + v);
172 int c = count.incrementAndGet();
173 if (c > 6) {
174 fail("Should be only 6");
175 }
176
177 }
178 });
179
180 latch.await(1000, TimeUnit.MILLISECONDS);
181
182 System.out.println("unsubscribed: " + unsubscribed.get());
183
184 assertTrue(unsubscribed.get());
185
186 }
187
188 @Test
189 public void mergeArrayWithThreading() {
190 final TestASynchronousObservable o1 = new TestASynchronousObservable();
191 final TestASynchronousObservable o2 = new TestASynchronousObservable();
192
193 Observable<String> m = Observable.merge(Observable.unsafeCreate(o1), Observable.unsafeCreate(o2));
194 TestObserver<String> to = new TestObserver<>(stringObserver);
195 m.subscribe(to);
196
197 to.awaitDone(5, TimeUnit.SECONDS);
198 to.assertNoErrors();
199
200 verify(stringObserver, never()).onError(any(Throwable.class));
201 verify(stringObserver, times(2)).onNext("hello");
202 verify(stringObserver, times(1)).onComplete();
203 }
204
205 @Test
206 public void synchronizationOfMultipleSequencesLoop() throws Throwable {
207 for (int i = 0; i < 100; i++) {
208 System.out.println("testSynchronizationOfMultipleSequencesLoop > " + i);
209 synchronizationOfMultipleSequences();
210 }
211 }
212
213 @Test
214 public void synchronizationOfMultipleSequences() throws Throwable {
215 final TestASynchronousObservable o1 = new TestASynchronousObservable();
216 final TestASynchronousObservable o2 = new TestASynchronousObservable();
217
218 // use this latch to cause onNext to wait until we're ready to let it go
219 final CountDownLatch endLatch = new CountDownLatch(1);
220
221 final AtomicInteger concurrentCounter = new AtomicInteger();
222 final AtomicInteger totalCounter = new AtomicInteger();
223
224 Observable<String> m = Observable.merge(Observable.unsafeCreate(o1), Observable.unsafeCreate(o2));
225 m.subscribe(new DefaultObserver<String>() {
226
227 @Override
228 public void onComplete() {
229
230 }
231
232 @Override
233 public void onError(Throwable e) {
234 throw new RuntimeException("failed", e);
235 }
236
237 @Override
238 public void onNext(String v) {
239 totalCounter.incrementAndGet();
240 concurrentCounter.incrementAndGet();
241 try {
242 // avoid deadlocking the main thread
243 if (Thread.currentThread().getName().equals("TestASynchronousObservable")) {
244 // wait here until we're done asserting
245 endLatch.await();
246 }
247 } catch (InterruptedException e) {
248 e.printStackTrace();
249 throw new RuntimeException("failed", e);
250 } finally {
251 concurrentCounter.decrementAndGet();
252 }
253 }
254
255 });
256
257 // wait for both observables to send (one should be blocked)
258 o1.onNextBeingSent.await();
259 o2.onNextBeingSent.await();
260
261 // I can't think of a way to know for sure that both threads have or are trying to send onNext
262 // since I can't use a CountDownLatch for "after" onNext since I want to catch during it
263 // but I can't know for sure onNext is invoked
264 // so I'm unfortunately reverting to using a Thread.sleep to allow the process scheduler time
265 // to make sure after o1.onNextBeingSent and o2.onNextBeingSent are hit that the following
266 // onNext is invoked.
267
268 int timeout = 20;
269
270 while (timeout-- > 0 && concurrentCounter.get() != 1) {
271 Thread.sleep(100);
272 }
273
274 try { // in try/finally so threads are released via latch countDown even if assertion fails
275 assertEquals(1, concurrentCounter.get());
276 } finally {
277 // release so it can finish
278 endLatch.countDown();
279 }
280
281 try {
282 o1.t.join();
283 o2.t.join();
284 } catch (InterruptedException e) {
285 throw new RuntimeException(e);
286 }
287
288 assertEquals(2, totalCounter.get());
289 assertEquals(0, concurrentCounter.get());
290 }
291
292 /**
293 * Unit test from OperationMergeDelayError backported here to show how these use cases work with normal merge.
294 */
295 @Test
296 public void error1() {
297 // we are using synchronous execution to test this exactly rather than non-deterministic concurrent behavior
298 final Observable<String> o1 = Observable.unsafeCreate(new TestErrorObservable("four", null, "six")); // we expect to lose "six"
299 final Observable<String> o2 = Observable.unsafeCreate(new TestErrorObservable("one", "two", "three")); // we expect to lose all of these since o1 is done first and fails
300
301 Observable<String> m = Observable.merge(o1, o2);
302 m.subscribe(stringObserver);
303
304 verify(stringObserver, times(1)).onError(any(NullPointerException.class));
305 verify(stringObserver, never()).onComplete();
306 verify(stringObserver, times(0)).onNext("one");
307 verify(stringObserver, times(0)).onNext("two");
308 verify(stringObserver, times(0)).onNext("three");
309 verify(stringObserver, times(1)).onNext("four");
310 verify(stringObserver, times(0)).onNext("five");
311 verify(stringObserver, times(0)).onNext("six");
312 }
313
314 /**
315 * Unit test from OperationMergeDelayError backported here to show how these use cases work with normal merge.
316 */
317 @Test
318 public void error2() {
319 // we are using synchronous execution to test this exactly rather than non-deterministic concurrent behavior
320 final Observable<String> o1 = Observable.unsafeCreate(new TestErrorObservable("one", "two", "three"));
321 final Observable<String> o2 = Observable.unsafeCreate(new TestErrorObservable("four", null, "six")); // we expect to lose "six"
322 final Observable<String> o3 = Observable.unsafeCreate(new TestErrorObservable("seven", "eight", null)); // we expect to lose all of these since o2 is done first and fails
323 final Observable<String> o4 = Observable.unsafeCreate(new TestErrorObservable("nine")); // we expect to lose all of these since o2 is done first and fails
324
325 Observable<String> m = Observable.merge(o1, o2, o3, o4);
326 m.subscribe(stringObserver);
327
328 verify(stringObserver, times(1)).onError(any(NullPointerException.class));
329 verify(stringObserver, never()).onComplete();
330 verify(stringObserver, times(1)).onNext("one");
331 verify(stringObserver, times(1)).onNext("two");
332 verify(stringObserver, times(1)).onNext("three");
333 verify(stringObserver, times(1)).onNext("four");
334 verify(stringObserver, times(0)).onNext("five");
335 verify(stringObserver, times(0)).onNext("six");
336 verify(stringObserver, times(0)).onNext("seven");
337 verify(stringObserver, times(0)).onNext("eight");
338 verify(stringObserver, times(0)).onNext("nine");
339 }
340
341 private static class TestSynchronousObservable implements ObservableSource<String> {
342
343 @Override
344 public void subscribe(Observer<? super String> observer) {
345 observer.onSubscribe(Disposable.empty());
346 observer.onNext("hello");
347 observer.onComplete();
348 }
349 }
350
351 private static class TestASynchronousObservable implements ObservableSource<String> {
352 Thread t;
353 final CountDownLatch onNextBeingSent = new CountDownLatch(1);
354
355 @Override
356 public void subscribe(final Observer<? super String> observer) {
357 observer.onSubscribe(Disposable.empty());
358 t = new Thread(new Runnable() {
359
360 @Override
361 public void run() {
362 onNextBeingSent.countDown();
363 try {
364 observer.onNext("hello");
365 // I can't use a countDownLatch to prove we are actually sending 'onNext'
366 // since it will block if synchronized and I'll deadlock
367 observer.onComplete();
368 } catch (Exception e) {
369 observer.onError(e);
370 }
371 }
372
373 }, "TestASynchronousObservable");
374 t.start();
375 }
376 }
377
378 private static class TestErrorObservable implements ObservableSource<String> {
379
380 String[] valuesToReturn;
381
382 TestErrorObservable(String... values) {
383 valuesToReturn = values;
384 }
385
386 @Override
387 public void subscribe(Observer<? super String> observer) {
388 observer.onSubscribe(Disposable.empty());
389 for (String s : valuesToReturn) {
390 if (s == null) {
391 System.out.println("throwing exception");
392 observer.onError(new NullPointerException());
393 } else {
394 observer.onNext(s);
395 }
396 }
397 observer.onComplete();
398 }
399 }
400
401 @Test
402 public void unsubscribeAsObservablesComplete() {
403 TestScheduler scheduler1 = new TestScheduler();
404 AtomicBoolean os1 = new AtomicBoolean(false);
405 Observable<Long> o1 = createObservableOf5IntervalsOf1SecondIncrementsWithSubscriptionHook(scheduler1, os1);
406
407 TestScheduler scheduler2 = new TestScheduler();
408 AtomicBoolean os2 = new AtomicBoolean(false);
409 Observable<Long> o2 = createObservableOf5IntervalsOf1SecondIncrementsWithSubscriptionHook(scheduler2, os2);
410
411 TestObserverEx<Long> to = new TestObserverEx<>();
412 Observable.merge(o1, o2).subscribe(to);
413
414 // we haven't incremented time so nothing should be received yet
415 to.assertNoValues();
416
417 scheduler1.advanceTimeBy(3, TimeUnit.SECONDS);
418 scheduler2.advanceTimeBy(2, TimeUnit.SECONDS);
419
420 to.assertValues(0L, 1L, 2L, 0L, 1L);
421 // not unsubscribed yet
422 assertFalse(os1.get());
423 assertFalse(os2.get());
424
425 // advance to the end at which point it should complete
426 scheduler1.advanceTimeBy(3, TimeUnit.SECONDS);
427
428 to.assertValues(0L, 1L, 2L, 0L, 1L, 3L, 4L);
429 assertTrue(os1.get());
430 assertFalse(os2.get());
431
432 // both should be completed now
433 scheduler2.advanceTimeBy(3, TimeUnit.SECONDS);
434
435 to.assertValues(0L, 1L, 2L, 0L, 1L, 3L, 4L, 2L, 3L, 4L);
436 assertTrue(os1.get());
437 assertTrue(os2.get());
438
439 to.assertTerminated();
440 }
441
442 @Test
443 public void earlyUnsubscribe() {
444 for (int i = 0; i < 10; i++) {
445 TestScheduler scheduler1 = new TestScheduler();
446 AtomicBoolean os1 = new AtomicBoolean(false);
447 Observable<Long> o1 = createObservableOf5IntervalsOf1SecondIncrementsWithSubscriptionHook(scheduler1, os1);
448
449 TestScheduler scheduler2 = new TestScheduler();
450 AtomicBoolean os2 = new AtomicBoolean(false);
451 Observable<Long> o2 = createObservableOf5IntervalsOf1SecondIncrementsWithSubscriptionHook(scheduler2, os2);
452
453 TestObserver<Long> to = new TestObserver<>();
454 Observable.merge(o1, o2).subscribe(to);
455
456 // we haven't incremented time so nothing should be received yet
457 to.assertNoValues();
458
459 scheduler1.advanceTimeBy(3, TimeUnit.SECONDS);
460 scheduler2.advanceTimeBy(2, TimeUnit.SECONDS);
461
462 to.assertValues(0L, 1L, 2L, 0L, 1L);
463 // not unsubscribed yet
464 assertFalse(os1.get());
465 assertFalse(os2.get());
466
467 // early unsubscribe
468 to.dispose();
469
470 assertTrue(os1.get());
471 assertTrue(os2.get());
472
473 to.assertValues(0L, 1L, 2L, 0L, 1L);
474 // FIXME not happening anymore
475 // ts.assertUnsubscribed();
476 }
477 }
478
479 private Observable<Long> createObservableOf5IntervalsOf1SecondIncrementsWithSubscriptionHook(final Scheduler scheduler, final AtomicBoolean unsubscribed) {
480 return Observable.unsafeCreate(new ObservableSource<Long>() {
481
482 @Override
483 public void subscribe(final Observer<? super Long> child) {
484 Observable.interval(1, TimeUnit.SECONDS, scheduler)
485 .take(5)
486 .subscribe(new Observer<Long>() {
487 @Override
488 public void onSubscribe(final Disposable d) {
489 child.onSubscribe(Disposable.fromRunnable(new Runnable() {
490 @Override
491 public void run() {
492 unsubscribed.set(true);
493 d.dispose();
494 }
495 }));
496 }
497
498 @Override
499 public void onNext(Long t) {
500 child.onNext(t);
501 }
502
503 @Override
504 public void onError(Throwable t) {
505 unsubscribed.set(true);
506 child.onError(t);
507 }
508
509 @Override
510 public void onComplete() {
511 unsubscribed.set(true);
512 child.onComplete();
513 }
514
515 });
516 }
517 });
518 }
519
520 @Test
521 public void concurrency() {
522 Observable<Integer> o = Observable.range(1, 10000).subscribeOn(Schedulers.newThread());
523
524 for (int i = 0; i < 10; i++) {
525 Observable<Integer> merge = Observable.merge(o, o, o);
526 TestObserverEx<Integer> to = new TestObserverEx<>();
527 merge.subscribe(to);
528
529 to.awaitDone(3, TimeUnit.SECONDS);
530 to.assertTerminated();
531 to.assertNoErrors();
532 to.assertComplete();
533 List<Integer> onNextEvents = to.values();
534 assertEquals(30000, onNextEvents.size());
535 // System.out.println("onNext: " + onNextEvents.size() + " onComplete: " + ts.getOnCompletedEvents().size());
536 }
537 }
538
539 @Test
540 public void concurrencyWithSleeping() {
541
542 Observable<Integer> o = Observable.unsafeCreate(new ObservableSource<Integer>() {
543
544 @Override
545 public void subscribe(final Observer<? super Integer> observer) {
546 Worker inner = Schedulers.newThread().createWorker();
547 final CompositeDisposable as = new CompositeDisposable();
548 as.add(Disposable.empty());
549 as.add(inner);
550
551 observer.onSubscribe(as);
552
553 inner.schedule(new Runnable() {
554
555 @Override
556 public void run() {
557 try {
558 for (int i = 0; i < 100; i++) {
559 observer.onNext(1);
560 try {
561 Thread.sleep(1);
562 } catch (InterruptedException e) {
563 e.printStackTrace();
564 }
565 }
566 } catch (Exception e) {
567 observer.onError(e);
568 }
569 as.dispose();
570 observer.onComplete();
571 }
572
573 });
574 }
575 });
576
577 for (int i = 0; i < 10; i++) {
578 Observable<Integer> merge = Observable.merge(o, o, o);
579 TestObserver<Integer> to = new TestObserver<>();
580 merge.subscribe(to);
581
582 to.awaitDone(5, TimeUnit.SECONDS);
583 to.assertComplete();
584 List<Integer> onNextEvents = to.values();
585 assertEquals(300, onNextEvents.size());
586 // System.out.println("onNext: " + onNextEvents.size() + " onComplete: " + ts.getOnCompletedEvents().size());
587 }
588 }
589
590 @Test
591 public void concurrencyWithBrokenOnCompleteContract() {
592 Observable<Integer> o = Observable.unsafeCreate(new ObservableSource<Integer>() {
593
594 @Override
595 public void subscribe(final Observer<? super Integer> observer) {
596 Worker inner = Schedulers.newThread().createWorker();
597 final CompositeDisposable as = new CompositeDisposable();
598 as.add(Disposable.empty());
599 as.add(inner);
600
601 observer.onSubscribe(as);
602
603 inner.schedule(new Runnable() {
604
605 @Override
606 public void run() {
607 try {
608 for (int i = 0; i < 10000; i++) {
609 observer.onNext(i);
610 }
611 } catch (Exception e) {
612 observer.onError(e);
613 }
614 as.dispose();
615 observer.onComplete();
616 observer.onComplete();
617 observer.onComplete();
618 }
619
620 });
621 }
622 });
623
624 for (int i = 0; i < 10; i++) {
625 Observable<Integer> merge = Observable.merge(o, o, o);
626 TestObserver<Integer> to = new TestObserver<>();
627 merge.subscribe(to);
628
629 to.awaitDone(5, TimeUnit.SECONDS);
630 to.assertNoErrors();
631 to.assertComplete();
632 List<Integer> onNextEvents = to.values();
633 assertEquals(30000, onNextEvents.size());
634 // System.out.println("onNext: " + onNextEvents.size() + " onComplete: " + ts.getOnCompletedEvents().size());
635 }
636 }
637
638 @Test
639 public void backpressureUpstream() throws InterruptedException {
640 final AtomicInteger generated1 = new AtomicInteger();
641 Observable<Integer> o1 = createInfiniteObservable(generated1).subscribeOn(Schedulers.computation());
642 final AtomicInteger generated2 = new AtomicInteger();
643 Observable<Integer> o2 = createInfiniteObservable(generated2).subscribeOn(Schedulers.computation());
644
645 TestObserverEx<Integer> testObserver = new TestObserverEx<Integer>() {
646 @Override
647 public void onNext(Integer t) {
648 System.err.println("TestObserver received => " + t + " on thread " + Thread.currentThread());
649 super.onNext(t);
650 }
651 };
652
653 Observable.merge(o1.take(Flowable.bufferSize() * 2), o2.take(Flowable.bufferSize() * 2)).subscribe(testObserver);
654 testObserver.awaitDone(5, TimeUnit.SECONDS);
655 if (testObserver.errors().size() > 0) {
656 testObserver.errors().get(0).printStackTrace();
657 }
658 testObserver.assertNoErrors();
659 System.err.println(testObserver.values());
660 assertEquals(Flowable.bufferSize() * 4, testObserver.values().size());
661 // it should be between the take num and requested batch size across the async boundary
662 System.out.println("Generated 1: " + generated1.get());
663 System.out.println("Generated 2: " + generated2.get());
664 assertTrue(generated1.get() >= Flowable.bufferSize() * 2
665 && generated1.get() <= Flowable.bufferSize() * 4);
666 }
667
668 @Test
669 public void backpressureUpstream2InLoop() throws InterruptedException {
670 for (int i = 0; i < 1000; i++) {
671 System.err.flush();
672 System.out.println("---");
673 System.out.flush();
674 backpressureUpstream2();
675 }
676 }
677
678 @Test
679 public void backpressureUpstream2() throws InterruptedException {
680 final AtomicInteger generated1 = new AtomicInteger();
681 Observable<Integer> o1 = createInfiniteObservable(generated1).subscribeOn(Schedulers.computation());
682
683 TestObserverEx<Integer> testObserver = new TestObserverEx<Integer>() {
684 @Override
685 public void onNext(Integer t) {
686 super.onNext(t);
687 }
688 };
689
690 Observable.merge(o1.take(Flowable.bufferSize() * 2), Observable.just(-99)).subscribe(testObserver);
691 testObserver.awaitDone(5, TimeUnit.SECONDS);
692
693 List<Integer> onNextEvents = testObserver.values();
694
695 System.out.println("Generated 1: " + generated1.get() + " / received: " + onNextEvents.size());
696 System.out.println(onNextEvents);
697
698 if (testObserver.errors().size() > 0) {
699 testObserver.errors().get(0).printStackTrace();
700 }
701 testObserver.assertNoErrors();
702 assertEquals(Flowable.bufferSize() * 2 + 1, onNextEvents.size());
703 // it should be between the take num and requested batch size across the async boundary
704 assertTrue(generated1.get() >= Flowable.bufferSize() * 2 && generated1.get() <= Flowable.bufferSize() * 3);
705 }
706
707 /**
708 * This is the same as the upstreams ones, but now adds the downstream as well by using observeOn.
709 *
710 * This requires merge to also obey the Product.request values coming from it's child Observer.
711 * @throws InterruptedException if the test is interrupted
712 */
713 @Test
714 public void backpressureDownstreamWithConcurrentStreams() throws InterruptedException {
715 final AtomicInteger generated1 = new AtomicInteger();
716 Observable<Integer> o1 = createInfiniteObservable(generated1).subscribeOn(Schedulers.computation());
717 final AtomicInteger generated2 = new AtomicInteger();
718 Observable<Integer> o2 = createInfiniteObservable(generated2).subscribeOn(Schedulers.computation());
719
720 TestObserverEx<Integer> to = new TestObserverEx<Integer>() {
721 @Override
722 public void onNext(Integer t) {
723 if (t < 100) {
724 try {
725 // force a slow consumer
726 Thread.sleep(1);
727 } catch (InterruptedException e) {
728 e.printStackTrace();
729 }
730 }
731 // System.err.println("TestObserver received => " + t + " on thread " + Thread.currentThread());
732 super.onNext(t);
733 }
734 };
735
736 Observable.merge(o1.take(Flowable.bufferSize() * 2), o2.take(Flowable.bufferSize() * 2)).observeOn(Schedulers.computation()).subscribe(to);
737 to.awaitDone(5, TimeUnit.SECONDS);
738 if (to.errors().size() > 0) {
739 to.errors().get(0).printStackTrace();
740 }
741 to.assertNoErrors();
742 System.err.println(to.values());
743 assertEquals(Flowable.bufferSize() * 4, to.values().size());
744 // it should be between the take num and requested batch size across the async boundary
745 System.out.println("Generated 1: " + generated1.get());
746 System.out.println("Generated 2: " + generated2.get());
747 assertTrue(generated1.get() >= Flowable.bufferSize() * 2 && generated1.get() <= Flowable.bufferSize() * 4);
748 }
749
750 /**
751 * Currently there is no solution to this ... we can't exert backpressure on the outer Observable if we
752 * can't know if the ones we've received so far are going to emit or not, otherwise we could starve the system.
753 *
754 * For example, 10,000 Observables are being merged (bad use case to begin with, but ...) and it's only one of them
755 * that will ever emit. If backpressure only allowed the first 1,000 to be sent, we would hang and never receive an event.
756 *
757 * Thus, we must allow all Observables to be sent. The ScalarSynchronousObservable use case is an exception to this since
758 * we can grab the value synchronously.
759 *
760 * @throws InterruptedException if the await is interrupted
761 */
762 @Test
763 public void backpressureBothUpstreamAndDownstreamWithRegularObservables() throws InterruptedException {
764 final AtomicInteger generated1 = new AtomicInteger();
765 Observable<Observable<Integer>> o1 = createInfiniteObservable(generated1).map(new Function<Integer, Observable<Integer>>() {
766
767 @Override
768 public Observable<Integer> apply(Integer t1) {
769 return Observable.just(1, 2, 3);
770 }
771
772 });
773
774 TestObserverEx<Integer> to = new TestObserverEx<Integer>() {
775 int i;
776
777 @Override
778 public void onNext(Integer t) {
779 if (i++ < 400) {
780 try {
781 // force a slow consumer
782 Thread.sleep(1);
783 } catch (InterruptedException e) {
784 e.printStackTrace();
785 }
786 }
787 // System.err.println("TestObserver received => " + t + " on thread " + Thread.currentThread());
788 super.onNext(t);
789 }
790 };
791
792 Observable.merge(o1).observeOn(Schedulers.computation()).take(Flowable.bufferSize() * 2).subscribe(to);
793 to.awaitDone(5, TimeUnit.SECONDS);
794 if (to.errors().size() > 0) {
795 to.errors().get(0).printStackTrace();
796 }
797 to.assertNoErrors();
798 System.out.println("Generated 1: " + generated1.get());
799 System.err.println(to.values());
800 System.out.println("done1 testBackpressureBothUpstreamAndDownstreamWithRegularObservables ");
801 assertEquals(Flowable.bufferSize() * 2, to.values().size());
802 System.out.println("done2 testBackpressureBothUpstreamAndDownstreamWithRegularObservables ");
803 // we can't restrict this ... see comment above
804 // assertTrue(generated1.get() >= Observable.bufferSize() && generated1.get() <= Observable.bufferSize() * 4);
805 }
806
807 @Test
808 public void merge1AsyncStreamOf1() {
809 TestObserver<Integer> to = new TestObserver<>();
810 mergeNAsyncStreamsOfN(1, 1).subscribe(to);
811 to.awaitDone(5, TimeUnit.SECONDS);
812 to.assertNoErrors();
813 assertEquals(1, to.values().size());
814 }
815
816 @Test
817 public void merge1AsyncStreamOf1000() {
818 TestObserver<Integer> to = new TestObserver<>();
819 mergeNAsyncStreamsOfN(1, 1000).subscribe(to);
820 to.awaitDone(5, TimeUnit.SECONDS);
821 to.assertNoErrors();
822 assertEquals(1000, to.values().size());
823 }
824
825 @Test
826 public void merge10AsyncStreamOf1000() {
827 TestObserver<Integer> to = new TestObserver<>();
828 mergeNAsyncStreamsOfN(10, 1000).subscribe(to);
829 to.awaitDone(5, TimeUnit.SECONDS);
830 to.assertNoErrors();
831 assertEquals(10000, to.values().size());
832 }
833
834 @Test
835 public void merge1000AsyncStreamOf1000() {
836 TestObserver<Integer> to = new TestObserver<>();
837 mergeNAsyncStreamsOfN(1000, 1000).subscribe(to);
838 to.awaitDone(5, TimeUnit.SECONDS);
839 to.assertNoErrors();
840 assertEquals(1000000, to.values().size());
841 }
842
843 @Test
844 public void merge2000AsyncStreamOf100() {
845 TestObserver<Integer> to = new TestObserver<>();
846 mergeNAsyncStreamsOfN(2000, 100).subscribe(to);
847 to.awaitDone(5, TimeUnit.SECONDS);
848 to.assertNoErrors();
849 assertEquals(200000, to.values().size());
850 }
851
852 @Test
853 public void merge100AsyncStreamOf1() {
854 TestObserver<Integer> to = new TestObserver<>();
855 mergeNAsyncStreamsOfN(100, 1).subscribe(to);
856 to.awaitDone(5, TimeUnit.SECONDS);
857 to.assertNoErrors();
858 assertEquals(100, to.values().size());
859 }
860
861 private Observable<Integer> mergeNAsyncStreamsOfN(final int outerSize, final int innerSize) {
862 Observable<Observable<Integer>> os = Observable.range(1, outerSize)
863 .map(new Function<Integer, Observable<Integer>>() {
864
865 @Override
866 public Observable<Integer> apply(Integer i) {
867 return Observable.range(1, innerSize).subscribeOn(Schedulers.computation());
868 }
869
870 });
871 return Observable.merge(os);
872 }
873
874 @Test
875 public void merge1SyncStreamOf1() {
876 TestObserver<Integer> to = new TestObserver<>();
877 mergeNSyncStreamsOfN(1, 1).subscribe(to);
878 to.awaitDone(5, TimeUnit.SECONDS);
879 to.assertNoErrors();
880 assertEquals(1, to.values().size());
881 }
882
883 @Test
884 public void merge1SyncStreamOf1000000() {
885 TestObserver<Integer> to = new TestObserver<>();
886 mergeNSyncStreamsOfN(1, 1000000).subscribe(to);
887 to.awaitDone(5, TimeUnit.SECONDS);
888 to.assertNoErrors();
889 assertEquals(1000000, to.values().size());
890 }
891
892 @Test
893 public void merge1000SyncStreamOf1000() {
894 TestObserver<Integer> to = new TestObserver<>();
895 mergeNSyncStreamsOfN(1000, 1000).subscribe(to);
896 to.awaitDone(5, TimeUnit.SECONDS);
897 to.assertNoErrors();
898 assertEquals(1000000, to.values().size());
899 }
900
901 @Test
902 public void merge10000SyncStreamOf10() {
903 TestObserver<Integer> to = new TestObserver<>();
904 mergeNSyncStreamsOfN(10000, 10).subscribe(to);
905 to.awaitDone(5, TimeUnit.SECONDS);
906 to.assertNoErrors();
907 assertEquals(100000, to.values().size());
908 }
909
910 @Test
911 public void merge1000000SyncStreamOf1() {
912 TestObserver<Integer> to = new TestObserver<>();
913 mergeNSyncStreamsOfN(1000000, 1).subscribe(to);
914 to.awaitDone(5, TimeUnit.SECONDS);
915 to.assertNoErrors();
916 assertEquals(1000000, to.values().size());
917 }
918
919 private Observable<Integer> mergeNSyncStreamsOfN(final int outerSize, final int innerSize) {
920 Observable<Observable<Integer>> os = Observable.range(1, outerSize)
921 .map(new Function<Integer, Observable<Integer>>() {
922
923 @Override
924 public Observable<Integer> apply(Integer i) {
925 return Observable.range(1, innerSize);
926 }
927
928 });
929 return Observable.merge(os);
930 }
931
932 private Observable<Integer> createInfiniteObservable(final AtomicInteger generated) {
933 Observable<Integer> o = Observable.fromIterable(new Iterable<Integer>() {
934 @Override
935 public Iterator<Integer> iterator() {
936 return new Iterator<Integer>() {
937
938 @Override
939 public void remove() {
940 }
941
942 @Override
943 public Integer next() {
944 return generated.getAndIncrement();
945 }
946
947 @Override
948 public boolean hasNext() {
949 return true;
950 }
951 };
952 }
953 });
954 return o;
955 }
956
957 @Test
958 public void mergeManyAsyncSingle() {
959 TestObserver<Integer> to = new TestObserver<>();
960 Observable<Observable<Integer>> os = Observable.range(1, 10000)
961 .map(new Function<Integer, Observable<Integer>>() {
962
963 @Override
964 public Observable<Integer> apply(final Integer i) {
965 return Observable.unsafeCreate(new ObservableSource<Integer>() {
966
967 @Override
968 public void subscribe(Observer<? super Integer> observer) {
969 observer.onSubscribe(Disposable.empty());
970 if (i < 500) {
971 try {
972 Thread.sleep(1);
973 } catch (InterruptedException e) {
974 e.printStackTrace();
975 }
976 }
977 observer.onNext(i);
978 observer.onComplete();
979 }
980
981 }).subscribeOn(Schedulers.computation()).cache();
982 }
983
984 });
985 Observable.merge(os).subscribe(to);
986 to.awaitDone(5, TimeUnit.SECONDS);
987 to.assertNoErrors();
988 assertEquals(10000, to.values().size());
989 }
990
991 Function<Integer, Observable<Integer>> toScalar = new Function<Integer, Observable<Integer>>() {
992 @Override
993 public Observable<Integer> apply(Integer v) {
994 return Observable.just(v);
995 }
996 };
997
998 Function<Integer, Observable<Integer>> toHiddenScalar = new Function<Integer, Observable<Integer>>() {
999 @Override
1000 public Observable<Integer> apply(Integer t) {
1001 return Observable.just(t).hide();
1002 }
1003 };
1004 ;
1005
1006 void runMerge(Function<Integer, Observable<Integer>> func, TestObserverEx<Integer> to) {
1007 List<Integer> list = new ArrayList<>();
1008 for (int i = 0; i < 1000; i++) {
1009 list.add(i);
1010 }
1011 Observable<Integer> source = Observable.fromIterable(list);
1012 source.flatMap(func).subscribe(to);
1013
1014 if (to.values().size() != 1000) {
1015 System.out.println(to.values());
1016 }
1017
1018 to.assertTerminated();
1019 to.assertNoErrors();
1020 to.assertValueSequence(list);
1021 }
1022
1023 @Test
1024 public void fastMergeFullScalar() {
1025 runMerge(toScalar, new TestObserverEx<>());
1026 }
1027
1028 @Test
1029 public void fastMergeHiddenScalar() {
1030 runMerge(toHiddenScalar, new TestObserverEx<>());
1031 }
1032
1033 @Test
1034 public void slowMergeFullScalar() {
1035 for (final int req : new int[] { 16, 32, 64, 128, 256 }) {
1036 TestObserverEx<Integer> to = new TestObserverEx<Integer>() {
1037 int remaining = req;
1038
1039 @Override
1040 public void onNext(Integer t) {
1041 super.onNext(t);
1042 if (--remaining == 0) {
1043 remaining = req;
1044 }
1045 }
1046 };
1047 runMerge(toScalar, to);
1048 }
1049 }
1050
1051 @Test
1052 public void slowMergeHiddenScalar() {
1053 for (final int req : new int[] { 16, 32, 64, 128, 256 }) {
1054 TestObserverEx<Integer> to = new TestObserverEx<Integer>() {
1055 int remaining = req;
1056 @Override
1057 public void onNext(Integer t) {
1058 super.onNext(t);
1059 if (--remaining == 0) {
1060 remaining = req;
1061 }
1062 }
1063 };
1064 runMerge(toHiddenScalar, to);
1065 }
1066 }
1067
1068 @Test
1069 public void mergeArray2() {
1070 Observable.mergeArray(Observable.just(1), Observable.just(2))
1071 .test()
1072 .assertResult(1, 2);
1073 }
1074
1075 @Test
1076 public void mergeErrors() {
1077 List<Throwable> errors = TestHelper.trackPluginErrors();
1078 try {
1079 Observable<Integer> source1 = Observable.error(new TestException("First"));
1080 Observable<Integer> source2 = Observable.error(new TestException("Second"));
1081
1082 Observable.merge(source1, source2)
1083 .to(TestHelper.<Integer>testConsumer())
1084 .assertFailureAndMessage(TestException.class, "First");
1085
1086 assertTrue(errors.toString(), errors.isEmpty());
1087 } finally {
1088 RxJavaPlugins.reset();
1089 }
1090 }
1091 }