Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableZipTest.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.AtomicInteger;
23
24 import org.junit.*;
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.Schedulers;
36 import io.reactivex.rxjava3.subjects.PublishSubject;
37 import io.reactivex.rxjava3.testsupport.TestHelper;
38
39 public class ObservableZipTest extends RxJavaTest {
40 BiFunction<String, String, String> concat2Strings;
41 PublishSubject<String> s1;
42 PublishSubject<String> s2;
43 Observable<String> zipped;
44
45 Observer<String> observer;
46 InOrder inOrder;
47
48 @Before
49 public void setUp() {
50 concat2Strings = new BiFunction<String, String, String>() {
51 @Override
52 public String apply(String t1, String t2) {
53 return t1 + "-" + t2;
54 }
55 };
56
57 s1 = PublishSubject.create();
58 s2 = PublishSubject.create();
59 zipped = Observable.zip(s1, s2, concat2Strings);
60
61 observer = TestHelper.mockObserver();
62 inOrder = inOrder(observer);
63
64 zipped.subscribe(observer);
65 }
66
67 @SuppressWarnings("unchecked")
68 @Test
69 public void collectionSizeDifferentThanFunction() {
70 Function<Object[], String> zipr = Functions.toFunction(getConcatStringIntegerIntArrayZipr());
71 //Function3<String, Integer, int[], String>
72
73 /* define an Observer to receive aggregated events */
74 Observer<String> observer = TestHelper.mockObserver();
75
76 @SuppressWarnings("rawtypes")
77 Collection ws = java.util.Collections.singleton(Observable.just("one", "two"));
78 Observable<String> w = Observable.zip(ws, zipr);
79 w.subscribe(observer);
80
81 verify(observer, times(1)).onError(any(Throwable.class));
82 verify(observer, never()).onComplete();
83 verify(observer, never()).onNext(any(String.class));
84 }
85
86 @Test
87 public void startpingDifferentLengthObservableSequences1() {
88 Observer<String> w = TestHelper.mockObserver();
89
90 TestObservable w1 = new TestObservable();
91 TestObservable w2 = new TestObservable();
92 TestObservable w3 = new TestObservable();
93
94 Observable<String> zipW = Observable.zip(
95 Observable.unsafeCreate(w1), Observable.unsafeCreate(w2),
96 Observable.unsafeCreate(w3), getConcat3StringsZipr());
97 zipW.subscribe(w);
98
99 /* simulate sending data */
100 // once for w1
101 w1.observer.onNext("1a");
102 w1.observer.onComplete();
103 // twice for w2
104 w2.observer.onNext("2a");
105 w2.observer.onNext("2b");
106 w2.observer.onComplete();
107 // 4 times for w3
108 w3.observer.onNext("3a");
109 w3.observer.onNext("3b");
110 w3.observer.onNext("3c");
111 w3.observer.onNext("3d");
112 w3.observer.onComplete();
113
114 /* we should have been called 1 time on the Observer */
115 InOrder io = inOrder(w);
116 io.verify(w).onNext("1a2a3a");
117
118 io.verify(w, times(1)).onComplete();
119 }
120
121 @Test
122 public void startpingDifferentLengthObservableSequences2() {
123 Observer<String> w = TestHelper.mockObserver();
124
125 TestObservable w1 = new TestObservable();
126 TestObservable w2 = new TestObservable();
127 TestObservable w3 = new TestObservable();
128
129 Observable<String> zipW = Observable.zip(Observable.unsafeCreate(w1), Observable.unsafeCreate(w2), Observable.unsafeCreate(w3), getConcat3StringsZipr());
130 zipW.subscribe(w);
131
132 /* simulate sending data */
133 // 4 times for w1
134 w1.observer.onNext("1a");
135 w1.observer.onNext("1b");
136 w1.observer.onNext("1c");
137 w1.observer.onNext("1d");
138 w1.observer.onComplete();
139 // twice for w2
140 w2.observer.onNext("2a");
141 w2.observer.onNext("2b");
142 w2.observer.onComplete();
143 // 1 times for w3
144 w3.observer.onNext("3a");
145 w3.observer.onComplete();
146
147 /* we should have been called 1 time on the Observer */
148 InOrder io = inOrder(w);
149 io.verify(w).onNext("1a2a3a");
150
151 io.verify(w, times(1)).onComplete();
152
153 }
154
155 BiFunction<Object, Object, String> zipr2 = new BiFunction<Object, Object, String>() {
156
157 @Override
158 public String apply(Object t1, Object t2) {
159 return "" + t1 + t2;
160 }
161
162 };
163 Function3<Object, Object, Object, String> zipr3 = new Function3<Object, Object, Object, String>() {
164
165 @Override
166 public String apply(Object t1, Object t2, Object t3) {
167 return "" + t1 + t2 + t3;
168 }
169
170 };
171
172 /**
173 * Testing internal private logic due to the complexity so I want to use TDD to test as a I build it rather than relying purely on the overall functionality expected by the public methods.
174 */
175 @Test
176 public void aggregatorSimple() {
177 PublishSubject<String> r1 = PublishSubject.create();
178 PublishSubject<String> r2 = PublishSubject.create();
179 /* define an Observer to receive aggregated events */
180 Observer<String> observer = TestHelper.mockObserver();
181
182 Observable.zip(r1, r2, zipr2).subscribe(observer);
183
184 /* simulate the Observables pushing data into the aggregator */
185 r1.onNext("hello");
186 r2.onNext("world");
187
188 InOrder inOrder = inOrder(observer);
189
190 verify(observer, never()).onError(any(Throwable.class));
191 verify(observer, never()).onComplete();
192 inOrder.verify(observer, times(1)).onNext("helloworld");
193
194 r1.onNext("hello ");
195 r2.onNext("again");
196
197 verify(observer, never()).onError(any(Throwable.class));
198 verify(observer, never()).onComplete();
199 inOrder.verify(observer, times(1)).onNext("hello again");
200
201 r1.onComplete();
202 r2.onComplete();
203
204 inOrder.verify(observer, never()).onNext(anyString());
205 verify(observer, times(1)).onComplete();
206 }
207
208 @Test
209 public void aggregatorDifferentSizedResultsWithOnComplete() {
210 /* create the aggregator which will execute the zip function when all Observables provide values */
211 /* define an Observer to receive aggregated events */
212 PublishSubject<String> r1 = PublishSubject.create();
213 PublishSubject<String> r2 = PublishSubject.create();
214 /* define an Observer to receive aggregated events */
215 Observer<String> observer = TestHelper.mockObserver();
216 Observable.zip(r1, r2, zipr2).subscribe(observer);
217
218 /* simulate the Observables pushing data into the aggregator */
219 r1.onNext("hello");
220 r2.onNext("world");
221 r2.onComplete();
222
223 InOrder inOrder = inOrder(observer);
224
225 inOrder.verify(observer, never()).onError(any(Throwable.class));
226 inOrder.verify(observer, times(1)).onNext("helloworld");
227 inOrder.verify(observer, times(1)).onComplete();
228
229 r1.onNext("hi");
230 r1.onComplete();
231
232 inOrder.verify(observer, never()).onError(any(Throwable.class));
233 inOrder.verify(observer, never()).onComplete();
234 inOrder.verify(observer, never()).onNext(anyString());
235 }
236
237 @Test
238 public void aggregateMultipleTypes() {
239 PublishSubject<String> r1 = PublishSubject.create();
240 PublishSubject<Integer> r2 = PublishSubject.create();
241 /* define an Observer to receive aggregated events */
242 Observer<String> observer = TestHelper.mockObserver();
243
244 Observable.zip(r1, r2, zipr2).subscribe(observer);
245
246 /* simulate the Observables pushing data into the aggregator */
247 r1.onNext("hello");
248 r2.onNext(1);
249 r2.onComplete();
250
251 InOrder inOrder = inOrder(observer);
252
253 inOrder.verify(observer, never()).onError(any(Throwable.class));
254 inOrder.verify(observer, times(1)).onNext("hello1");
255 inOrder.verify(observer, times(1)).onComplete();
256
257 r1.onNext("hi");
258 r1.onComplete();
259
260 inOrder.verify(observer, never()).onError(any(Throwable.class));
261 inOrder.verify(observer, never()).onComplete();
262 inOrder.verify(observer, never()).onNext(anyString());
263 }
264
265 @Test
266 public void aggregate3Types() {
267 PublishSubject<String> r1 = PublishSubject.create();
268 PublishSubject<Integer> r2 = PublishSubject.create();
269 PublishSubject<List<Integer>> r3 = PublishSubject.create();
270 /* define an Observer to receive aggregated events */
271 Observer<String> observer = TestHelper.mockObserver();
272
273 Observable.zip(r1, r2, r3, zipr3).subscribe(observer);
274
275 /* simulate the Observables pushing data into the aggregator */
276 r1.onNext("hello");
277 r2.onNext(2);
278 r3.onNext(Arrays.asList(5, 6, 7));
279
280 verify(observer, never()).onError(any(Throwable.class));
281 verify(observer, never()).onComplete();
282 verify(observer, times(1)).onNext("hello2[5, 6, 7]");
283 }
284
285 @Test
286 public void aggregatorsWithDifferentSizesAndTiming() {
287 PublishSubject<String> r1 = PublishSubject.create();
288 PublishSubject<String> r2 = PublishSubject.create();
289 /* define an Observer to receive aggregated events */
290 Observer<String> observer = TestHelper.mockObserver();
291
292 Observable.zip(r1, r2, zipr2).subscribe(observer);
293
294 /* simulate the Observables pushing data into the aggregator */
295 r1.onNext("one");
296 r1.onNext("two");
297 r1.onNext("three");
298 r2.onNext("A");
299
300 verify(observer, never()).onError(any(Throwable.class));
301 verify(observer, never()).onComplete();
302 verify(observer, times(1)).onNext("oneA");
303
304 r1.onNext("four");
305 r1.onComplete();
306 r2.onNext("B");
307 verify(observer, times(1)).onNext("twoB");
308 r2.onNext("C");
309 verify(observer, times(1)).onNext("threeC");
310 r2.onNext("D");
311 verify(observer, times(1)).onNext("fourD");
312 r2.onNext("E");
313 verify(observer, never()).onNext("E");
314 r2.onComplete();
315
316 verify(observer, never()).onError(any(Throwable.class));
317 verify(observer, times(1)).onComplete();
318 }
319
320 @Test
321 public void aggregatorError() {
322 PublishSubject<String> r1 = PublishSubject.create();
323 PublishSubject<String> r2 = PublishSubject.create();
324 /* define an Observer to receive aggregated events */
325 Observer<String> observer = TestHelper.mockObserver();
326
327 Observable.zip(r1, r2, zipr2).subscribe(observer);
328
329 /* simulate the Observables pushing data into the aggregator */
330 r1.onNext("hello");
331 r2.onNext("world");
332
333 verify(observer, never()).onError(any(Throwable.class));
334 verify(observer, never()).onComplete();
335 verify(observer, times(1)).onNext("helloworld");
336
337 r1.onError(new RuntimeException(""));
338 r1.onNext("hello");
339 r2.onNext("again");
340
341 verify(observer, times(1)).onError(any(Throwable.class));
342 verify(observer, never()).onComplete();
343 // we don't want to be called again after an error
344 verify(observer, times(0)).onNext("helloagain");
345 }
346
347 @Test
348 public void aggregatorUnsubscribe() {
349 PublishSubject<String> r1 = PublishSubject.create();
350 PublishSubject<String> r2 = PublishSubject.create();
351 /* define an Observer to receive aggregated events */
352 Observer<String> observer = TestHelper.mockObserver();
353 TestObserver<String> to = new TestObserver<>(observer);
354
355 Observable.zip(r1, r2, zipr2).subscribe(to);
356
357 /* simulate the Observables pushing data into the aggregator */
358 r1.onNext("hello");
359 r2.onNext("world");
360
361 verify(observer, never()).onError(any(Throwable.class));
362 verify(observer, never()).onComplete();
363 verify(observer, times(1)).onNext("helloworld");
364
365 to.dispose();
366 r1.onNext("hello");
367 r2.onNext("again");
368
369 verify(observer, times(0)).onError(any(Throwable.class));
370 verify(observer, never()).onComplete();
371 // we don't want to be called again after an error
372 verify(observer, times(0)).onNext("helloagain");
373 }
374
375 @Test
376 public void aggregatorEarlyCompletion() {
377 PublishSubject<String> r1 = PublishSubject.create();
378 PublishSubject<String> r2 = PublishSubject.create();
379 /* define an Observer to receive aggregated events */
380 Observer<String> observer = TestHelper.mockObserver();
381
382 Observable.zip(r1, r2, zipr2).subscribe(observer);
383
384 /* simulate the Observables pushing data into the aggregator */
385 r1.onNext("one");
386 r1.onNext("two");
387 r1.onComplete();
388 r2.onNext("A");
389
390 InOrder inOrder = inOrder(observer);
391
392 inOrder.verify(observer, never()).onError(any(Throwable.class));
393 inOrder.verify(observer, never()).onComplete();
394 inOrder.verify(observer, times(1)).onNext("oneA");
395
396 r2.onComplete();
397
398 inOrder.verify(observer, never()).onError(any(Throwable.class));
399 inOrder.verify(observer, times(1)).onComplete();
400 inOrder.verify(observer, never()).onNext(anyString());
401 }
402
403 @Test
404 public void start2Types() {
405 BiFunction<String, Integer, String> zipr = getConcatStringIntegerZipr();
406
407 /* define an Observer to receive aggregated events */
408 Observer<String> observer = TestHelper.mockObserver();
409
410 Observable<String> w = Observable.zip(Observable.just("one", "two"), Observable.just(2, 3, 4), zipr);
411 w.subscribe(observer);
412
413 verify(observer, never()).onError(any(Throwable.class));
414 verify(observer, times(1)).onComplete();
415 verify(observer, times(1)).onNext("one2");
416 verify(observer, times(1)).onNext("two3");
417 verify(observer, never()).onNext("4");
418 }
419
420 @Test
421 public void start3Types() {
422 Function3<String, Integer, int[], String> zipr = getConcatStringIntegerIntArrayZipr();
423
424 /* define an Observer to receive aggregated events */
425 Observer<String> observer = TestHelper.mockObserver();
426
427 Observable<String> w = Observable.zip(Observable.just("one", "two"), Observable.just(2), Observable.just(new int[] { 4, 5, 6 }), zipr);
428 w.subscribe(observer);
429
430 verify(observer, never()).onError(any(Throwable.class));
431 verify(observer, times(1)).onComplete();
432 verify(observer, times(1)).onNext("one2[4, 5, 6]");
433 verify(observer, never()).onNext("two");
434 }
435
436 @Test
437 public void onNextExceptionInvokesOnError() {
438 BiFunction<Integer, Integer, Integer> zipr = getDivideZipr();
439
440 Observer<Integer> observer = TestHelper.mockObserver();
441
442 Observable<Integer> w = Observable.zip(Observable.just(10, 20, 30), Observable.just(0, 1, 2), zipr);
443 w.subscribe(observer);
444
445 verify(observer, times(1)).onError(any(Throwable.class));
446 }
447
448 @Test
449 public void onFirstCompletion() {
450 PublishSubject<String> oA = PublishSubject.create();
451 PublishSubject<String> oB = PublishSubject.create();
452
453 Observer<String> obs = TestHelper.mockObserver();
454
455 Observable<String> o = Observable.zip(oA, oB, getConcat2Strings());
456 o.subscribe(obs);
457
458 InOrder io = inOrder(obs);
459
460 oA.onNext("a1");
461 io.verify(obs, never()).onNext(anyString());
462 oB.onNext("b1");
463 io.verify(obs, times(1)).onNext("a1-b1");
464 oB.onNext("b2");
465 io.verify(obs, never()).onNext(anyString());
466 oA.onNext("a2");
467 io.verify(obs, times(1)).onNext("a2-b2");
468
469 oA.onNext("a3");
470 oA.onNext("a4");
471 oA.onNext("a5");
472 oA.onComplete();
473
474 // SHOULD ONCOMPLETE BE EMITTED HERE INSTEAD OF WAITING
475 // FOR B3, B4, B5 TO BE EMITTED?
476
477 oB.onNext("b3");
478 oB.onNext("b4");
479 oB.onNext("b5");
480
481 io.verify(obs, times(1)).onNext("a3-b3");
482 io.verify(obs, times(1)).onNext("a4-b4");
483 io.verify(obs, times(1)).onNext("a5-b5");
484
485 // WE RECEIVE THE ONCOMPLETE HERE
486 io.verify(obs, times(1)).onComplete();
487
488 oB.onNext("b6");
489 oB.onNext("b7");
490 oB.onNext("b8");
491 oB.onNext("b9");
492 // never completes (infinite stream for example)
493
494 // we should receive nothing else despite oB continuing after oA completed
495 io.verifyNoMoreInteractions();
496 }
497
498 @Test
499 public void onErrorTermination() {
500 PublishSubject<String> oA = PublishSubject.create();
501 PublishSubject<String> oB = PublishSubject.create();
502
503 Observer<String> obs = TestHelper.mockObserver();
504
505 Observable<String> o = Observable.zip(oA, oB, getConcat2Strings());
506 o.subscribe(obs);
507
508 InOrder io = inOrder(obs);
509
510 oA.onNext("a1");
511 io.verify(obs, never()).onNext(anyString());
512 oB.onNext("b1");
513 io.verify(obs, times(1)).onNext("a1-b1");
514 oB.onNext("b2");
515 io.verify(obs, never()).onNext(anyString());
516 oA.onNext("a2");
517 io.verify(obs, times(1)).onNext("a2-b2");
518
519 oA.onNext("a3");
520 oA.onNext("a4");
521 oA.onNext("a5");
522 oA.onError(new RuntimeException("forced failure"));
523
524 // it should emit failure immediately
525 io.verify(obs, times(1)).onError(any(RuntimeException.class));
526
527 oB.onNext("b3");
528 oB.onNext("b4");
529 oB.onNext("b5");
530 oB.onNext("b6");
531 oB.onNext("b7");
532 oB.onNext("b8");
533 oB.onNext("b9");
534 // never completes (infinite stream for example)
535
536 // we should receive nothing else despite oB continuing after oA completed
537 io.verifyNoMoreInteractions();
538 }
539
540 private BiFunction<String, String, String> getConcat2Strings() {
541 return new BiFunction<String, String, String>() {
542
543 @Override
544 public String apply(String t1, String t2) {
545 return t1 + "-" + t2;
546 }
547 };
548 }
549
550 private BiFunction<Integer, Integer, Integer> getDivideZipr() {
551 BiFunction<Integer, Integer, Integer> zipr = new BiFunction<Integer, Integer, Integer>() {
552
553 @Override
554 public Integer apply(Integer i1, Integer i2) {
555 return i1 / i2;
556 }
557
558 };
559 return zipr;
560 }
561
562 private Function3<String, String, String, String> getConcat3StringsZipr() {
563 Function3<String, String, String, String> zipr = new Function3<String, String, String, String>() {
564
565 @Override
566 public String apply(String a1, String a2, String a3) {
567 if (a1 == null) {
568 a1 = "";
569 }
570 if (a2 == null) {
571 a2 = "";
572 }
573 if (a3 == null) {
574 a3 = "";
575 }
576 return a1 + a2 + a3;
577 }
578
579 };
580 return zipr;
581 }
582
583 private BiFunction<String, Integer, String> getConcatStringIntegerZipr() {
584 BiFunction<String, Integer, String> zipr = new BiFunction<String, Integer, String>() {
585
586 @Override
587 public String apply(String s, Integer i) {
588 return getStringValue(s) + getStringValue(i);
589 }
590
591 };
592 return zipr;
593 }
594
595 private Function3<String, Integer, int[], String> getConcatStringIntegerIntArrayZipr() {
596 Function3<String, Integer, int[], String> zipr = new Function3<String, Integer, int[], String>() {
597
598 @Override
599 public String apply(String s, Integer i, int[] iArray) {
600 return getStringValue(s) + getStringValue(i) + getStringValue(iArray);
601 }
602
603 };
604 return zipr;
605 }
606
607 private static String getStringValue(Object o) {
608 if (o == null) {
609 return "";
610 } else {
611 if (o instanceof int[]) {
612 return Arrays.toString((int[]) o);
613 } else {
614 return String.valueOf(o);
615 }
616 }
617 }
618
619 private static class TestObservable implements ObservableSource<String> {
620
621 Observer<? super String> observer;
622
623 @Override
624 public void subscribe(Observer<? super String> observer) {
625 // just store the variable where it can be accessed so we can manually trigger it
626 this.observer = observer;
627 observer.onSubscribe(Disposable.empty());
628 }
629
630 }
631
632 @Test
633 public void firstCompletesThenSecondInfinite() {
634 s1.onNext("a");
635 s1.onNext("b");
636 s1.onComplete();
637 s2.onNext("1");
638 inOrder.verify(observer, times(1)).onNext("a-1");
639 s2.onNext("2");
640 inOrder.verify(observer, times(1)).onNext("b-2");
641 inOrder.verify(observer, times(1)).onComplete();
642 inOrder.verifyNoMoreInteractions();
643 }
644
645 @Test
646 public void secondInfiniteThenFirstCompletes() {
647 s2.onNext("1");
648 s2.onNext("2");
649 s1.onNext("a");
650 inOrder.verify(observer, times(1)).onNext("a-1");
651 s1.onNext("b");
652 inOrder.verify(observer, times(1)).onNext("b-2");
653 s1.onComplete();
654 inOrder.verify(observer, times(1)).onComplete();
655 inOrder.verifyNoMoreInteractions();
656 }
657
658 @Test
659 public void secondCompletesThenFirstInfinite() {
660 s2.onNext("1");
661 s2.onNext("2");
662 s2.onComplete();
663 s1.onNext("a");
664 inOrder.verify(observer, times(1)).onNext("a-1");
665 s1.onNext("b");
666 inOrder.verify(observer, times(1)).onNext("b-2");
667 inOrder.verify(observer, times(1)).onComplete();
668 inOrder.verifyNoMoreInteractions();
669 }
670
671 @Test
672 public void firstInfiniteThenSecondCompletes() {
673 s1.onNext("a");
674 s1.onNext("b");
675 s2.onNext("1");
676 inOrder.verify(observer, times(1)).onNext("a-1");
677 s2.onNext("2");
678 inOrder.verify(observer, times(1)).onNext("b-2");
679 s2.onComplete();
680 inOrder.verify(observer, times(1)).onComplete();
681 inOrder.verifyNoMoreInteractions();
682 }
683
684 @Test
685 public void firstFails() {
686 s2.onNext("a");
687 s1.onError(new RuntimeException("Forced failure"));
688
689 inOrder.verify(observer, times(1)).onError(any(RuntimeException.class));
690
691 s2.onNext("b");
692 s1.onNext("1");
693 s1.onNext("2");
694
695 inOrder.verify(observer, never()).onComplete();
696 inOrder.verify(observer, never()).onNext(any(String.class));
697 inOrder.verifyNoMoreInteractions();
698 }
699
700 @Test
701 public void secondFails() {
702 s1.onNext("a");
703 s1.onNext("b");
704 s2.onError(new RuntimeException("Forced failure"));
705
706 inOrder.verify(observer, times(1)).onError(any(RuntimeException.class));
707
708 s2.onNext("1");
709 s2.onNext("2");
710
711 inOrder.verify(observer, never()).onComplete();
712 inOrder.verify(observer, never()).onNext(any(String.class));
713 inOrder.verifyNoMoreInteractions();
714 }
715
716 @Test
717 public void startWithOnCompletedTwice() {
718 // issue: https://groups.google.com/forum/#!topic/rxjava/79cWTv3TFp0
719 // The problem is the original "zip" implementation does not wrap
720 // an internal observer with a SafeSubscriber. However, in the "zip",
721 // it may calls "onComplete" twice. That breaks the Rx contract.
722
723 // This test tries to emulate this case.
724 // As "TestHelper.mockObserver()" will create an instance in the package "rx",
725 // we need to wrap "TestHelper.mockObserver()" with an observer instance
726 // which is in the package "rx.operators".
727 final Observer<Integer> observer = TestHelper.mockObserver();
728
729 Observable.zip(Observable.just(1),
730 Observable.just(1), new BiFunction<Integer, Integer, Integer>() {
731 @Override
732 public Integer apply(Integer a, Integer b) {
733 return a + b;
734 }
735 }).subscribe(new DefaultObserver<Integer>() {
736
737 @Override
738 public void onComplete() {
739 observer.onComplete();
740 }
741
742 @Override
743 public void onError(Throwable e) {
744 observer.onError(e);
745 }
746
747 @Override
748 public void onNext(Integer args) {
749 observer.onNext(args);
750 }
751
752 });
753
754 InOrder inOrder = inOrder(observer);
755 inOrder.verify(observer, times(1)).onNext(2);
756 inOrder.verify(observer, times(1)).onComplete();
757 inOrder.verifyNoMoreInteractions();
758 }
759
760 @Test
761 public void start() {
762 Observable<String> os = OBSERVABLE_OF_5_INTEGERS
763 .zipWith(OBSERVABLE_OF_5_INTEGERS, new BiFunction<Integer, Integer, String>() {
764
765 @Override
766 public String apply(Integer a, Integer b) {
767 return a + "-" + b;
768 }
769 });
770
771 final ArrayList<String> list = new ArrayList<>();
772 os.subscribe(new Consumer<String>() {
773
774 @Override
775 public void accept(String s) {
776 System.out.println(s);
777 list.add(s);
778 }
779 });
780
781 assertEquals(5, list.size());
782 assertEquals("1-1", list.get(0));
783 assertEquals("2-2", list.get(1));
784 assertEquals("5-5", list.get(4));
785 }
786
787 @Test
788 public void startAsync() throws InterruptedException {
789 Observable<String> os = ASYNC_OBSERVABLE_OF_INFINITE_INTEGERS(new CountDownLatch(1))
790 .zipWith(ASYNC_OBSERVABLE_OF_INFINITE_INTEGERS(new CountDownLatch(1)), new BiFunction<Integer, Integer, String>() {
791
792 @Override
793 public String apply(Integer a, Integer b) {
794 return a + "-" + b;
795 }
796 }).take(5);
797
798 TestObserver<String> to = new TestObserver<>();
799 os.subscribe(to);
800
801 to.awaitDone(5, TimeUnit.SECONDS);
802 to.assertNoErrors();
803
804 assertEquals(5, to.values().size());
805 assertEquals("1-1", to.values().get(0));
806 assertEquals("2-2", to.values().get(1));
807 assertEquals("5-5", to.values().get(4));
808 }
809
810 @Test
811 public void startInfiniteAndFinite() throws InterruptedException {
812 final CountDownLatch latch = new CountDownLatch(1);
813 final CountDownLatch infiniteObservable = new CountDownLatch(1);
814 Observable<String> os = OBSERVABLE_OF_5_INTEGERS
815 .zipWith(ASYNC_OBSERVABLE_OF_INFINITE_INTEGERS(infiniteObservable), new BiFunction<Integer, Integer, String>() {
816
817 @Override
818 public String apply(Integer a, Integer b) {
819 return a + "-" + b;
820 }
821 });
822
823 final ArrayList<String> list = new ArrayList<>();
824 os.subscribe(new DefaultObserver<String>() {
825
826 @Override
827 public void onComplete() {
828 latch.countDown();
829 }
830
831 @Override
832 public void onError(Throwable e) {
833 e.printStackTrace();
834 latch.countDown();
835 }
836
837 @Override
838 public void onNext(String s) {
839 System.out.println(s);
840 list.add(s);
841 }
842 });
843
844 latch.await(1000, TimeUnit.MILLISECONDS);
845 if (!infiniteObservable.await(2000, TimeUnit.MILLISECONDS)) {
846 throw new RuntimeException("didn't unsubscribe");
847 }
848
849 assertEquals(5, list.size());
850 assertEquals("1-1", list.get(0));
851 assertEquals("2-2", list.get(1));
852 assertEquals("5-5", list.get(4));
853 }
854
855 @SuppressWarnings("rawtypes")
856 static String kind(Notification notification) {
857 if (notification.isOnError()) {
858 return "OnError";
859 }
860 if (notification.isOnNext()) {
861 return "OnNext";
862 }
863 return "OnComplete";
864 }
865
866 @SuppressWarnings("rawtypes")
867 static String value(Notification notification) {
868 if (notification.isOnNext()) {
869 return String.valueOf(notification.getValue());
870 }
871 return "null";
872 }
873
874 @Test
875 public void emitMaterializedNotifications() {
876 Observable<Notification<Integer>> oi = Observable.just(1, 2, 3).materialize();
877 Observable<Notification<String>> os = Observable.just("a", "b", "c").materialize();
878 Observable<String> o = Observable.zip(oi, os, new BiFunction<Notification<Integer>, Notification<String>, String>() {
879
880 @Override
881 public String apply(Notification<Integer> t1, Notification<String> t2) {
882 return kind(t1) + "_" + value(t1) + "-" + kind(t2) + "_" + value(t2);
883 }
884
885 });
886
887 final ArrayList<String> list = new ArrayList<>();
888 o.subscribe(new Consumer<String>() {
889
890 @Override
891 public void accept(String s) {
892 System.out.println(s);
893 list.add(s);
894 }
895 });
896
897 assertEquals(4, list.size());
898 assertEquals("OnNext_1-OnNext_a", list.get(0));
899 assertEquals("OnNext_2-OnNext_b", list.get(1));
900 assertEquals("OnNext_3-OnNext_c", list.get(2));
901 assertEquals("OnComplete_null-OnComplete_null", list.get(3));
902 }
903
904 @Test
905 public void startEmptyObservables() {
906
907 Observable<String> o = Observable.zip(Observable.<Integer> empty(), Observable.<String> empty(), new BiFunction<Integer, String, String>() {
908
909 @Override
910 public String apply(Integer t1, String t2) {
911 return t1 + "-" + t2;
912 }
913
914 });
915
916 final ArrayList<String> list = new ArrayList<>();
917 o.subscribe(new Consumer<String>() {
918
919 @Override
920 public void accept(String s) {
921 System.out.println(s);
922 list.add(s);
923 }
924 });
925
926 assertEquals(0, list.size());
927 }
928
929 @Test
930 public void startEmptyList() {
931
932 final Object invoked = new Object();
933 Collection<Observable<Object>> observables = Collections.emptyList();
934
935 Observable<Object> o = Observable.zip(observables, new Function<Object[], Object>() {
936 @Override
937 public Object apply(final Object[] args) {
938 assertEquals("No argument should have been passed", 0, args.length);
939 return invoked;
940 }
941 });
942
943 TestObserver<Object> to = new TestObserver<>();
944 o.subscribe(to);
945 to.awaitDone(200, TimeUnit.MILLISECONDS);
946 to.assertNoValues();
947 }
948
949 /**
950 * Expect NoSuchElementException instead of blocking forever as zip should emit onComplete and no onNext
951 * and last() expects at least a single response.
952 */
953 @Test(expected = NoSuchElementException.class)
954 public void startEmptyListBlocking() {
955
956 final Object invoked = new Object();
957 Collection<Observable<Object>> observables = Collections.emptyList();
958
959 Observable<Object> o = Observable.zip(observables, new Function<Object[], Object>() {
960 @Override
961 public Object apply(final Object[] args) {
962 assertEquals("No argument should have been passed", 0, args.length);
963 return invoked;
964 }
965 });
966
967 o.blockingLast();
968 }
969
970 @Test
971 public void downstreamBackpressureRequestsWithFiniteSyncObservables() {
972 AtomicInteger generatedA = new AtomicInteger();
973 AtomicInteger generatedB = new AtomicInteger();
974 Observable<Integer> o1 = createInfiniteObservable(generatedA).take(Observable.bufferSize() * 2);
975 Observable<Integer> o2 = createInfiniteObservable(generatedB).take(Observable.bufferSize() * 2);
976
977 TestObserver<String> to = new TestObserver<>();
978 Observable.zip(o1, o2, new BiFunction<Integer, Integer, String>() {
979
980 @Override
981 public String apply(Integer t1, Integer t2) {
982 return t1 + "-" + t2;
983 }
984
985 }).observeOn(Schedulers.computation()).take(Observable.bufferSize() * 2).subscribe(to);
986
987 to.awaitDone(5, TimeUnit.SECONDS);
988 to.assertNoErrors();
989 assertEquals(Observable.bufferSize() * 2, to.values().size());
990 System.out.println("Generated => A: " + generatedA.get() + " B: " + generatedB.get());
991 assertTrue(generatedA.get() < (Observable.bufferSize() * 3));
992 assertTrue(generatedB.get() < (Observable.bufferSize() * 3));
993 }
994
995 private Observable<Integer> createInfiniteObservable(final AtomicInteger generated) {
996 Observable<Integer> o = Observable.fromIterable(new Iterable<Integer>() {
997 @Override
998 public Iterator<Integer> iterator() {
999 return new Iterator<Integer>() {
1000
1001 @Override
1002 public void remove() {
1003 }
1004
1005 @Override
1006 public Integer next() {
1007 return generated.getAndIncrement();
1008 }
1009
1010 @Override
1011 public boolean hasNext() {
1012 return true;
1013 }
1014 };
1015 }
1016 });
1017 return o;
1018 }
1019
1020 Observable<Integer> OBSERVABLE_OF_5_INTEGERS = OBSERVABLE_OF_5_INTEGERS(new AtomicInteger());
1021
1022 Observable<Integer> OBSERVABLE_OF_5_INTEGERS(final AtomicInteger numEmitted) {
1023 return Observable.unsafeCreate(new ObservableSource<Integer>() {
1024
1025 @Override
1026 public void subscribe(final Observer<? super Integer> o) {
1027 Disposable d = Disposable.empty();
1028 o.onSubscribe(d);
1029 for (int i = 1; i <= 5; i++) {
1030 if (d.isDisposed()) {
1031 break;
1032 }
1033 numEmitted.incrementAndGet();
1034 o.onNext(i);
1035 Thread.yield();
1036 }
1037 o.onComplete();
1038 }
1039
1040 });
1041 }
1042
1043 Observable<Integer> ASYNC_OBSERVABLE_OF_INFINITE_INTEGERS(final CountDownLatch latch) {
1044 return Observable.unsafeCreate(new ObservableSource<Integer>() {
1045
1046 @Override
1047 public void subscribe(final Observer<? super Integer> o) {
1048 final Disposable d = Disposable.empty();
1049 o.onSubscribe(d);
1050 Thread t = new Thread(new Runnable() {
1051
1052 @Override
1053 public void run() {
1054 System.out.println("-------> subscribe to infinite sequence");
1055 System.out.println("Starting thread: " + Thread.currentThread());
1056 int i = 1;
1057 while (!d.isDisposed()) {
1058 o.onNext(i++);
1059 Thread.yield();
1060 }
1061 o.onComplete();
1062 latch.countDown();
1063 System.out.println("Ending thread: " + Thread.currentThread());
1064 }
1065 });
1066 t.start();
1067
1068 }
1069
1070 });
1071 }
1072
1073 @Test
1074 public void issue1812() {
1075 // https://github.com/ReactiveX/RxJava/issues/1812
1076 Observable<Integer> zip1 = Observable.zip(Observable.range(0, 1026), Observable.range(0, 1026),
1077 new BiFunction<Integer, Integer, Integer>() {
1078
1079 @Override
1080 public Integer apply(Integer i1, Integer i2) {
1081 return i1 + i2;
1082 }
1083 });
1084 Observable<Integer> zip2 = Observable.zip(zip1, Observable.range(0, 1026),
1085 new BiFunction<Integer, Integer, Integer>() {
1086
1087 @Override
1088 public Integer apply(Integer i1, Integer i2) {
1089 return i1 + i2;
1090 }
1091 });
1092 List<Integer> expected = new ArrayList<>();
1093 for (int i = 0; i < 1026; i++) {
1094 expected.add(i * 3);
1095 }
1096 assertEquals(expected, zip2.toList().blockingGet());
1097 }
1098
1099 @Test
1100 public void zipRace() {
1101 long startTime = System.currentTimeMillis();
1102 Observable<Integer> src = Observable.just(1).subscribeOn(Schedulers.computation());
1103
1104 // now try and generate a hang by zipping src with itself repeatedly. A
1105 // time limit of 9 seconds ( 1 second less than the test timeout) is
1106 // used so that this test will not timeout on slow machines.
1107 int i = 0;
1108 while (System.currentTimeMillis() - startTime < 9000 && i++ < 100000) {
1109 int value = Observable.zip(src, src, new BiFunction<Integer, Integer, Integer>() {
1110 @Override
1111 public Integer apply(Integer t1, Integer t2) {
1112 return t1 + t2 * 10;
1113 }
1114 }).blockingSingle(0);
1115
1116 Assert.assertEquals(11, value);
1117 }
1118 }
1119
1120 @Test
1121 public void zip2() {
1122 Observable.zip(Observable.just(1),
1123 Observable.just(2),
1124 new BiFunction<Integer, Integer, Object>() {
1125 @Override
1126 public Object apply(Integer a, Integer b) throws Exception {
1127 return "" + a + b;
1128 }
1129 }
1130 )
1131 .test()
1132 .assertResult("12");
1133 }
1134
1135 @Test
1136 public void zip3() {
1137 Observable.zip(Observable.just(1),
1138 Observable.just(2), Observable.just(3),
1139 new Function3<Integer, Integer, Integer, Object>() {
1140 @Override
1141 public Object apply(Integer a, Integer b, Integer c) throws Exception {
1142 return "" + a + b + c;
1143 }
1144 }
1145 )
1146 .test()
1147 .assertResult("123");
1148 }
1149
1150 @Test
1151 public void zip4() {
1152 Observable.zip(Observable.just(1),
1153 Observable.just(2), Observable.just(3),
1154 Observable.just(4),
1155 new Function4<Integer, Integer, Integer, Integer, Object>() {
1156 @Override
1157 public Object apply(Integer a, Integer b, Integer c, Integer d) throws Exception {
1158 return "" + a + b + c + d;
1159 }
1160 }
1161 )
1162 .test()
1163 .assertResult("1234");
1164 }
1165
1166 @Test
1167 public void zip5() {
1168 Observable.zip(Observable.just(1),
1169 Observable.just(2), Observable.just(3),
1170 Observable.just(4), Observable.just(5),
1171 new Function5<Integer, Integer, Integer, Integer, Integer, Object>() {
1172 @Override
1173 public Object apply(Integer a, Integer b, Integer c, Integer d, Integer e) throws Exception {
1174 return "" + a + b + c + d + e;
1175 }
1176 }
1177 )
1178 .test()
1179 .assertResult("12345");
1180 }
1181
1182 @Test
1183 public void zip6() {
1184 Observable.zip(Observable.just(1),
1185 Observable.just(2), Observable.just(3),
1186 Observable.just(4), Observable.just(5),
1187 Observable.just(6),
1188 new Function6<Integer, Integer, Integer, Integer, Integer, Integer, Object>() {
1189 @Override
1190 public Object apply(Integer a, Integer b, Integer c, Integer d, Integer e, Integer f) throws Exception {
1191 return "" + a + b + c + d + e + f;
1192 }
1193 }
1194 )
1195 .test()
1196 .assertResult("123456");
1197 }
1198
1199 @Test
1200 public void zip7() {
1201 Observable.zip(Observable.just(1),
1202 Observable.just(2), Observable.just(3),
1203 Observable.just(4), Observable.just(5),
1204 Observable.just(6), Observable.just(7),
1205 new Function7<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Object>() {
1206 @Override
1207 public Object apply(Integer a, Integer b, Integer c, Integer d, Integer e, Integer f, Integer g)
1208 throws Exception {
1209 return "" + a + b + c + d + e + f + g;
1210 }
1211 }
1212 )
1213 .test()
1214 .assertResult("1234567");
1215 }
1216
1217 @Test
1218 public void zip8() {
1219 Observable.zip(Observable.just(1),
1220 Observable.just(2), Observable.just(3),
1221 Observable.just(4), Observable.just(5),
1222 Observable.just(6), Observable.just(7),
1223 Observable.just(8),
1224 new Function8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Object>() {
1225 @Override
1226 public Object apply(Integer a, Integer b, Integer c, Integer d, Integer e, Integer f, Integer g,
1227 Integer h) throws Exception {
1228 return "" + a + b + c + d + e + f + g + h;
1229 }
1230 }
1231 )
1232 .test()
1233 .assertResult("12345678");
1234 }
1235
1236 @Test
1237 public void zip9() {
1238 Observable.zip(Observable.just(1),
1239 Observable.just(2), Observable.just(3),
1240 Observable.just(4), Observable.just(5),
1241 Observable.just(6), Observable.just(7),
1242 Observable.just(8), Observable.just(9),
1243 new Function9<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Object>() {
1244 @Override
1245 public Object apply(Integer a, Integer b, Integer c, Integer d, Integer e, Integer f, Integer g,
1246 Integer h, Integer i) throws Exception {
1247 return "" + a + b + c + d + e + f + g + h + i;
1248 }
1249 }
1250 )
1251 .test()
1252 .assertResult("123456789");
1253 }
1254
1255 @Test
1256 public void zip2DelayError() {
1257 Observable.zip(Observable.just(1).concatWith(Observable.<Integer>error(new TestException())),
1258 Observable.just(2),
1259 new BiFunction<Integer, Integer, Object>() {
1260 @Override
1261 public Object apply(Integer a, Integer b) throws Exception {
1262 return "" + a + b;
1263 }
1264 }, true
1265 )
1266 .test()
1267 .assertFailure(TestException.class, "12");
1268 }
1269
1270 @Test
1271 public void zip2Prefetch() {
1272 Observable.zip(Observable.range(1, 9),
1273 Observable.range(21, 9),
1274 new BiFunction<Integer, Integer, Object>() {
1275 @Override
1276 public Object apply(Integer a, Integer b) throws Exception {
1277 return "" + a + b;
1278 }
1279 }, false, 2
1280 )
1281 .takeLast(1)
1282 .test()
1283 .assertResult("929");
1284 }
1285
1286 @Test
1287 public void zip2DelayErrorPrefetch() {
1288 Observable.zip(Observable.range(1, 9).concatWith(Observable.<Integer>error(new TestException())),
1289 Observable.range(21, 9),
1290 new BiFunction<Integer, Integer, Object>() {
1291 @Override
1292 public Object apply(Integer a, Integer b) throws Exception {
1293 return "" + a + b;
1294 }
1295 }, true, 2
1296 )
1297 .skip(8)
1298 .test()
1299 .assertFailure(TestException.class, "929");
1300 }
1301
1302 @Test
1303 public void zipArrayEmpty() {
1304 assertSame(Observable.empty(), Observable.zipArray(Functions.<Object[]>identity(), false, 16));
1305 }
1306
1307 @Test
1308 public void zipArrayMany() {
1309 @SuppressWarnings("unchecked")
1310 Observable<Integer>[] arr = new Observable[10];
1311
1312 Arrays.fill(arr, Observable.just(1));
1313
1314 Observable.zip(Arrays.asList(arr), new Function<Object[], Object>() {
1315 @Override
1316 public Object apply(Object[] a) throws Exception {
1317 return Arrays.toString(a);
1318 }
1319 })
1320 .test()
1321 .assertResult("[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]");
1322 }
1323
1324 @Test
1325 public void dispose() {
1326 TestHelper.checkDisposed(Observable.zip(Observable.just(1), Observable.just(1), new BiFunction<Integer, Integer, Object>() {
1327 @Override
1328 public Object apply(Integer a, Integer b) throws Exception {
1329 return a + b;
1330 }
1331 }));
1332 }
1333
1334 @Test
1335 public void noCrossBoundaryFusion() {
1336 for (int i = 0; i < 500; i++) {
1337 TestObserver<List<Object>> to = Observable.zip(
1338 Observable.just(1).observeOn(Schedulers.single()).map(new Function<Integer, Object>() {
1339 @Override
1340 public Object apply(Integer v) throws Exception {
1341 return Thread.currentThread().getName().substring(0, 4);
1342 }
1343 }),
1344 Observable.just(1).observeOn(Schedulers.computation()).map(new Function<Integer, Object>() {
1345 @Override
1346 public Object apply(Integer v) throws Exception {
1347 return Thread.currentThread().getName().substring(0, 4);
1348 }
1349 }),
1350 new BiFunction<Object, Object, List<Object>>() {
1351 @Override
1352 public List<Object> apply(Object t1, Object t2) throws Exception {
1353 return Arrays.asList(t1, t2);
1354 }
1355 }
1356 )
1357 .test()
1358 .awaitDone(5, TimeUnit.SECONDS)
1359 .assertValueCount(1);
1360
1361 List<Object> list = to.values().get(0);
1362
1363 assertTrue(list.toString(), list.contains("RxSi"));
1364 assertTrue(list.toString(), list.contains("RxCo"));
1365 }
1366 }
1367
1368 @Test
1369 public void eagerDispose() {
1370 final PublishSubject<Integer> ps1 = PublishSubject.create();
1371 final PublishSubject<Integer> ps2 = PublishSubject.create();
1372
1373 TestObserver<Integer> to = new TestObserver<Integer>() {
1374 @Override
1375 public void onNext(Integer t) {
1376 super.onNext(t);
1377 dispose();
1378 if (ps1.hasObservers()) {
1379 onError(new IllegalStateException("ps1 not disposed"));
1380 } else
1381 if (ps2.hasObservers()) {
1382 onError(new IllegalStateException("ps2 not disposed"));
1383 } else {
1384 onComplete();
1385 }
1386 }
1387 };
1388
1389 Observable.zip(ps1, ps2, new BiFunction<Integer, Integer, Integer>() {
1390 @Override
1391 public Integer apply(Integer t1, Integer t2) throws Exception {
1392 return t1 + t2;
1393 }
1394 })
1395 .subscribe(to);
1396
1397 ps1.onNext(1);
1398 ps2.onNext(2);
1399 to.assertResult(3);
1400 }
1401
1402 @Test
1403 public void firstErrorPreventsSecondSubscription() {
1404 final AtomicInteger counter = new AtomicInteger();
1405
1406 List<Observable<?>> observableList = new ArrayList<>();
1407 observableList.add(Observable.create(new ObservableOnSubscribe<Object>() {
1408 @Override
1409 public void subscribe(ObservableEmitter<Object> e)
1410 throws Exception { throw new TestException(); }
1411 }));
1412 observableList.add(Observable.create(new ObservableOnSubscribe<Object>() {
1413 @Override
1414 public void subscribe(ObservableEmitter<Object> e)
1415 throws Exception { counter.getAndIncrement(); }
1416 }));
1417
1418 Observable.zip(observableList,
1419 new Function<Object[], Object>() {
1420 @Override
1421 public Object apply(Object[] a) throws Exception {
1422 return a;
1423 }
1424 })
1425 .test()
1426 .assertFailure(TestException.class)
1427 ;
1428
1429 assertEquals(0, counter.get());
1430 }
1431
1432 @Test
1433 public void observableSourcesInIterable() {
1434 ObservableSource<Integer> source = new ObservableSource<Integer>() {
1435 @Override
1436 public void subscribe(Observer<? super Integer> observer) {
1437 Observable.just(1).subscribe(observer);
1438 }
1439 };
1440
1441 Observable.zip(Arrays.asList(source, source), new Function<Object[], Integer>() {
1442 @Override
1443 public Integer apply(Object[] t) throws Throwable {
1444 return 2;
1445 }
1446 })
1447 .test()
1448 .assertResult(2);
1449 }
1450 }