Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableCombineLatestTest.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.*;
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.Disposable;
31 import io.reactivex.rxjava3.exceptions.*;
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.plugins.RxJavaPlugins;
36 import io.reactivex.rxjava3.schedulers.*;
37 import io.reactivex.rxjava3.subjects.PublishSubject;
38 import io.reactivex.rxjava3.testsupport.*;
39
40 public class ObservableCombineLatestTest extends RxJavaTest {
41
42 @Test
43 public void combineLatestWithFunctionThatThrowsAnException() {
44 Observer<String> w = TestHelper.mockObserver();
45
46 PublishSubject<String> w1 = PublishSubject.create();
47 PublishSubject<String> w2 = PublishSubject.create();
48
49 Observable<String> combined = Observable.combineLatest(w1, w2, new BiFunction<String, String, String>() {
50 @Override
51 public String apply(String v1, String v2) {
52 throw new RuntimeException("I don't work.");
53 }
54 });
55 combined.subscribe(w);
56
57 w1.onNext("first value of w1");
58 w2.onNext("first value of w2");
59
60 verify(w, never()).onNext(anyString());
61 verify(w, never()).onComplete();
62 verify(w, times(1)).onError(Mockito.<RuntimeException> any());
63 }
64
65 @Test
66 public void combineLatestDifferentLengthObservableSequences1() {
67 Observer<String> w = TestHelper.mockObserver();
68
69 PublishSubject<String> w1 = PublishSubject.create();
70 PublishSubject<String> w2 = PublishSubject.create();
71 PublishSubject<String> w3 = PublishSubject.create();
72
73 Observable<String> combineLatestW = Observable.combineLatest(w1, w2, w3,
74 getConcat3StringsCombineLatestFunction());
75 combineLatestW.subscribe(w);
76
77 /* simulate sending data */
78 // once for w1
79 w1.onNext("1a");
80 w2.onNext("2a");
81 w3.onNext("3a");
82 w1.onComplete();
83 // twice for w2
84 w2.onNext("2b");
85 w2.onComplete();
86 // 4 times for w3
87 w3.onNext("3b");
88 w3.onNext("3c");
89 w3.onNext("3d");
90 w3.onComplete();
91
92 /* we should have been called 4 times on the Observer */
93 InOrder inOrder = inOrder(w);
94 inOrder.verify(w).onNext("1a2a3a");
95 inOrder.verify(w).onNext("1a2b3a");
96 inOrder.verify(w).onNext("1a2b3b");
97 inOrder.verify(w).onNext("1a2b3c");
98 inOrder.verify(w).onNext("1a2b3d");
99 inOrder.verify(w, never()).onNext(anyString());
100 inOrder.verify(w, times(1)).onComplete();
101 }
102
103 @Test
104 public void combineLatestDifferentLengthObservableSequences2() {
105 Observer<String> w = TestHelper.mockObserver();
106
107 PublishSubject<String> w1 = PublishSubject.create();
108 PublishSubject<String> w2 = PublishSubject.create();
109 PublishSubject<String> w3 = PublishSubject.create();
110
111 Observable<String> combineLatestW = Observable.combineLatest(w1, w2, w3, getConcat3StringsCombineLatestFunction());
112 combineLatestW.subscribe(w);
113
114 /* simulate sending data */
115 // 4 times for w1
116 w1.onNext("1a");
117 w1.onNext("1b");
118 w1.onNext("1c");
119 w1.onNext("1d");
120 w1.onComplete();
121 // twice for w2
122 w2.onNext("2a");
123 w2.onNext("2b");
124 w2.onComplete();
125 // 1 times for w3
126 w3.onNext("3a");
127 w3.onComplete();
128
129 /* we should have been called 1 time only on the Observer since we only combine the "latest" we don't go back and loop through others once completed */
130 InOrder inOrder = inOrder(w);
131 inOrder.verify(w, times(1)).onNext("1d2b3a");
132 inOrder.verify(w, never()).onNext(anyString());
133
134 inOrder.verify(w, times(1)).onComplete();
135
136 }
137
138 @Test
139 public void combineLatestWithInterleavingSequences() {
140 Observer<String> w = TestHelper.mockObserver();
141
142 PublishSubject<String> w1 = PublishSubject.create();
143 PublishSubject<String> w2 = PublishSubject.create();
144 PublishSubject<String> w3 = PublishSubject.create();
145
146 Observable<String> combineLatestW = Observable.combineLatest(w1, w2, w3, getConcat3StringsCombineLatestFunction());
147 combineLatestW.subscribe(w);
148
149 /* simulate sending data */
150 w1.onNext("1a");
151 w2.onNext("2a");
152 w2.onNext("2b");
153 w3.onNext("3a");
154
155 w1.onNext("1b");
156 w2.onNext("2c");
157 w2.onNext("2d");
158 w3.onNext("3b");
159
160 w1.onComplete();
161 w2.onComplete();
162 w3.onComplete();
163
164 /* we should have been called 5 times on the Observer */
165 InOrder inOrder = inOrder(w);
166 inOrder.verify(w).onNext("1a2b3a");
167 inOrder.verify(w).onNext("1b2b3a");
168 inOrder.verify(w).onNext("1b2c3a");
169 inOrder.verify(w).onNext("1b2d3a");
170 inOrder.verify(w).onNext("1b2d3b");
171
172 inOrder.verify(w, never()).onNext(anyString());
173 inOrder.verify(w, times(1)).onComplete();
174 }
175
176 @Test
177 public void combineLatest2Types() {
178 BiFunction<String, Integer, String> combineLatestFunction = getConcatStringIntegerCombineLatestFunction();
179
180 /* define an Observer to receive aggregated events */
181 Observer<String> observer = TestHelper.mockObserver();
182
183 Observable<String> w = Observable.combineLatest(Observable.just("one", "two"), Observable.just(2, 3, 4), combineLatestFunction);
184 w.subscribe(observer);
185
186 verify(observer, never()).onError(any(Throwable.class));
187 verify(observer, times(1)).onComplete();
188 verify(observer, times(1)).onNext("two2");
189 verify(observer, times(1)).onNext("two3");
190 verify(observer, times(1)).onNext("two4");
191 }
192
193 @Test
194 public void combineLatest3TypesA() {
195 Function3<String, Integer, int[], String> combineLatestFunction = getConcatStringIntegerIntArrayCombineLatestFunction();
196
197 /* define an Observer to receive aggregated events */
198 Observer<String> observer = TestHelper.mockObserver();
199
200 Observable<String> w = Observable.combineLatest(Observable.just("one", "two"), Observable.just(2), Observable.just(new int[] { 4, 5, 6 }), combineLatestFunction);
201 w.subscribe(observer);
202
203 verify(observer, never()).onError(any(Throwable.class));
204 verify(observer, times(1)).onComplete();
205 verify(observer, times(1)).onNext("two2[4, 5, 6]");
206 }
207
208 @Test
209 public void combineLatest3TypesB() {
210 Function3<String, Integer, int[], String> combineLatestFunction = getConcatStringIntegerIntArrayCombineLatestFunction();
211
212 /* define an Observer to receive aggregated events */
213 Observer<String> observer = TestHelper.mockObserver();
214
215 Observable<String> w = Observable.combineLatest(Observable.just("one"), Observable.just(2), Observable.just(new int[] { 4, 5, 6 }, new int[] { 7, 8 }), combineLatestFunction);
216 w.subscribe(observer);
217
218 verify(observer, never()).onError(any(Throwable.class));
219 verify(observer, times(1)).onComplete();
220 verify(observer, times(1)).onNext("one2[4, 5, 6]");
221 verify(observer, times(1)).onNext("one2[7, 8]");
222 }
223
224 private Function3<String, String, String, String> getConcat3StringsCombineLatestFunction() {
225 Function3<String, String, String, String> combineLatestFunction = new Function3<String, String, String, String>() {
226 @Override
227 public String apply(String a1, String a2, String a3) {
228 if (a1 == null) {
229 a1 = "";
230 }
231 if (a2 == null) {
232 a2 = "";
233 }
234 if (a3 == null) {
235 a3 = "";
236 }
237 return a1 + a2 + a3;
238 }
239 };
240 return combineLatestFunction;
241 }
242
243 private BiFunction<String, Integer, String> getConcatStringIntegerCombineLatestFunction() {
244 BiFunction<String, Integer, String> combineLatestFunction = new BiFunction<String, Integer, String>() {
245 @Override
246 public String apply(String s, Integer i) {
247 return getStringValue(s) + getStringValue(i);
248 }
249 };
250 return combineLatestFunction;
251 }
252
253 private Function3<String, Integer, int[], String> getConcatStringIntegerIntArrayCombineLatestFunction() {
254 return new Function3<String, Integer, int[], String>() {
255 @Override
256 public String apply(String s, Integer i, int[] iArray) {
257 return getStringValue(s) + getStringValue(i) + getStringValue(iArray);
258 }
259 };
260 }
261
262 private static String getStringValue(Object o) {
263 if (o == null) {
264 return "";
265 } else {
266 if (o instanceof int[]) {
267 return Arrays.toString((int[]) o);
268 } else {
269 return String.valueOf(o);
270 }
271 }
272 }
273
274 BiFunction<Integer, Integer, Integer> or = new BiFunction<Integer, Integer, Integer>() {
275 @Override
276 public Integer apply(Integer t1, Integer t2) {
277 return t1 | t2;
278 }
279 };
280
281 @Test
282 public void combineSimple() {
283 PublishSubject<Integer> a = PublishSubject.create();
284 PublishSubject<Integer> b = PublishSubject.create();
285
286 Observable<Integer> source = Observable.combineLatest(a, b, or);
287
288 Observer<Object> observer = TestHelper.mockObserver();
289 InOrder inOrder = inOrder(observer);
290
291 source.subscribe(observer);
292
293 a.onNext(1);
294
295 inOrder.verify(observer, never()).onNext(any());
296
297 a.onNext(2);
298
299 inOrder.verify(observer, never()).onNext(any());
300
301 b.onNext(0x10);
302
303 inOrder.verify(observer, times(1)).onNext(0x12);
304
305 b.onNext(0x20);
306 inOrder.verify(observer, times(1)).onNext(0x22);
307
308 b.onComplete();
309
310 inOrder.verify(observer, never()).onComplete();
311
312 a.onComplete();
313
314 inOrder.verify(observer, times(1)).onComplete();
315
316 a.onNext(3);
317 b.onNext(0x30);
318 a.onComplete();
319 b.onComplete();
320
321 inOrder.verifyNoMoreInteractions();
322 verify(observer, never()).onError(any(Throwable.class));
323 }
324
325 @Test
326 public void combineMultipleObservers() {
327 PublishSubject<Integer> a = PublishSubject.create();
328 PublishSubject<Integer> b = PublishSubject.create();
329
330 Observable<Integer> source = Observable.combineLatest(a, b, or);
331
332 Observer<Object> observer1 = TestHelper.mockObserver();
333
334 Observer<Object> observer2 = TestHelper.mockObserver();
335
336 InOrder inOrder1 = inOrder(observer1);
337 InOrder inOrder2 = inOrder(observer2);
338
339 source.subscribe(observer1);
340 source.subscribe(observer2);
341
342 a.onNext(1);
343
344 inOrder1.verify(observer1, never()).onNext(any());
345 inOrder2.verify(observer2, never()).onNext(any());
346
347 a.onNext(2);
348
349 inOrder1.verify(observer1, never()).onNext(any());
350 inOrder2.verify(observer2, never()).onNext(any());
351
352 b.onNext(0x10);
353
354 inOrder1.verify(observer1, times(1)).onNext(0x12);
355 inOrder2.verify(observer2, times(1)).onNext(0x12);
356
357 b.onNext(0x20);
358 inOrder1.verify(observer1, times(1)).onNext(0x22);
359 inOrder2.verify(observer2, times(1)).onNext(0x22);
360
361 b.onComplete();
362
363 inOrder1.verify(observer1, never()).onComplete();
364 inOrder2.verify(observer2, never()).onComplete();
365
366 a.onComplete();
367
368 inOrder1.verify(observer1, times(1)).onComplete();
369 inOrder2.verify(observer2, times(1)).onComplete();
370
371 a.onNext(3);
372 b.onNext(0x30);
373 a.onComplete();
374 b.onComplete();
375
376 inOrder1.verifyNoMoreInteractions();
377 inOrder2.verifyNoMoreInteractions();
378 verify(observer1, never()).onError(any(Throwable.class));
379 verify(observer2, never()).onError(any(Throwable.class));
380 }
381
382 @Test
383 public void firstNeverProduces() {
384 PublishSubject<Integer> a = PublishSubject.create();
385 PublishSubject<Integer> b = PublishSubject.create();
386
387 Observable<Integer> source = Observable.combineLatest(a, b, or);
388
389 Observer<Object> observer = TestHelper.mockObserver();
390 InOrder inOrder = inOrder(observer);
391
392 source.subscribe(observer);
393
394 b.onNext(0x10);
395 b.onNext(0x20);
396
397 a.onComplete();
398
399 inOrder.verify(observer, times(1)).onComplete();
400 verify(observer, never()).onNext(any());
401 verify(observer, never()).onError(any(Throwable.class));
402 }
403
404 @Test
405 public void secondNeverProduces() {
406 PublishSubject<Integer> a = PublishSubject.create();
407 PublishSubject<Integer> b = PublishSubject.create();
408
409 Observable<Integer> source = Observable.combineLatest(a, b, or);
410
411 Observer<Object> observer = TestHelper.mockObserver();
412 InOrder inOrder = inOrder(observer);
413
414 source.subscribe(observer);
415
416 a.onNext(0x1);
417 a.onNext(0x2);
418
419 b.onComplete();
420 a.onComplete();
421
422 inOrder.verify(observer, times(1)).onComplete();
423 verify(observer, never()).onNext(any());
424 verify(observer, never()).onError(any(Throwable.class));
425 }
426
427 @Test
428 public void oneToNSources() {
429 int n = 30;
430 Function<Object[], List<Object>> func = new Function<Object[], List<Object>>() {
431
432 @Override
433 public List<Object> apply(Object[] args) {
434 return Arrays.asList(args);
435 }
436 };
437 for (int i = 1; i <= n; i++) {
438 System.out.println("test1ToNSources: " + i + " sources");
439 List<Observable<Integer>> sources = new ArrayList<>();
440 List<Object> values = new ArrayList<>();
441 for (int j = 0; j < i; j++) {
442 sources.add(Observable.just(j));
443 values.add(j);
444 }
445
446 Observable<List<Object>> result = Observable.combineLatest(sources, func);
447
448 Observer<List<Object>> o = TestHelper.mockObserver();
449
450 result.subscribe(o);
451
452 verify(o).onNext(values);
453 verify(o).onComplete();
454 verify(o, never()).onError(any(Throwable.class));
455 }
456 }
457
458 @Test
459 public void oneToNSourcesScheduled() throws InterruptedException {
460 int n = 10;
461 Function<Object[], List<Object>> func = new Function<Object[], List<Object>>() {
462
463 @Override
464 public List<Object> apply(Object[] args) {
465 return Arrays.asList(args);
466 }
467 };
468 for (int i = 1; i <= n; i++) {
469 System.out.println("test1ToNSourcesScheduled: " + i + " sources");
470 List<Observable<Integer>> sources = new ArrayList<>();
471 List<Object> values = new ArrayList<>();
472 for (int j = 0; j < i; j++) {
473 sources.add(Observable.just(j).subscribeOn(Schedulers.io()));
474 values.add(j);
475 }
476
477 Observable<List<Object>> result = Observable.combineLatest(sources, func);
478
479 final Observer<List<Object>> o = TestHelper.mockObserver();
480
481 final CountDownLatch cdl = new CountDownLatch(1);
482
483 Observer<List<Object>> observer = new DefaultObserver<List<Object>>() {
484
485 @Override
486 public void onNext(List<Object> t) {
487 o.onNext(t);
488 }
489
490 @Override
491 public void onError(Throwable e) {
492 o.onError(e);
493 cdl.countDown();
494 }
495
496 @Override
497 public void onComplete() {
498 o.onComplete();
499 cdl.countDown();
500 }
501 };
502
503 result.subscribe(observer);
504
505 cdl.await();
506
507 verify(o).onNext(values);
508 verify(o).onComplete();
509 verify(o, never()).onError(any(Throwable.class));
510 }
511 }
512
513 @Test
514 public void twoSourcesOverload() {
515 Observable<Integer> s1 = Observable.just(1);
516 Observable<Integer> s2 = Observable.just(2);
517
518 Observable<List<Integer>> result = Observable.combineLatest(s1, s2,
519 new BiFunction<Integer, Integer, List<Integer>>() {
520 @Override
521 public List<Integer> apply(Integer t1, Integer t2) {
522 return Arrays.asList(t1, t2);
523 }
524 });
525
526 Observer<Object> o = TestHelper.mockObserver();
527
528 result.subscribe(o);
529
530 verify(o).onNext(Arrays.asList(1, 2));
531 verify(o).onComplete();
532 verify(o, never()).onError(any(Throwable.class));
533 }
534
535 @Test
536 public void threeSourcesOverload() {
537 Observable<Integer> s1 = Observable.just(1);
538 Observable<Integer> s2 = Observable.just(2);
539 Observable<Integer> s3 = Observable.just(3);
540
541 Observable<List<Integer>> result = Observable.combineLatest(s1, s2, s3,
542 new Function3<Integer, Integer, Integer, List<Integer>>() {
543 @Override
544 public List<Integer> apply(Integer t1, Integer t2, Integer t3) {
545 return Arrays.asList(t1, t2, t3);
546 }
547 });
548
549 Observer<Object> o = TestHelper.mockObserver();
550
551 result.subscribe(o);
552
553 verify(o).onNext(Arrays.asList(1, 2, 3));
554 verify(o).onComplete();
555 verify(o, never()).onError(any(Throwable.class));
556 }
557
558 @Test
559 public void fourSourcesOverload() {
560 Observable<Integer> s1 = Observable.just(1);
561 Observable<Integer> s2 = Observable.just(2);
562 Observable<Integer> s3 = Observable.just(3);
563 Observable<Integer> s4 = Observable.just(4);
564
565 Observable<List<Integer>> result = Observable.combineLatest(s1, s2, s3, s4,
566 new Function4<Integer, Integer, Integer, Integer, List<Integer>>() {
567 @Override
568 public List<Integer> apply(Integer t1, Integer t2, Integer t3, Integer t4) {
569 return Arrays.asList(t1, t2, t3, t4);
570 }
571 });
572
573 Observer<Object> o = TestHelper.mockObserver();
574
575 result.subscribe(o);
576
577 verify(o).onNext(Arrays.asList(1, 2, 3, 4));
578 verify(o).onComplete();
579 verify(o, never()).onError(any(Throwable.class));
580 }
581
582 @Test
583 public void fiveSourcesOverload() {
584 Observable<Integer> s1 = Observable.just(1);
585 Observable<Integer> s2 = Observable.just(2);
586 Observable<Integer> s3 = Observable.just(3);
587 Observable<Integer> s4 = Observable.just(4);
588 Observable<Integer> s5 = Observable.just(5);
589
590 Observable<List<Integer>> result = Observable.combineLatest(s1, s2, s3, s4, s5,
591 new Function5<Integer, Integer, Integer, Integer, Integer, List<Integer>>() {
592 @Override
593 public List<Integer> apply(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5) {
594 return Arrays.asList(t1, t2, t3, t4, t5);
595 }
596 });
597
598 Observer<Object> o = TestHelper.mockObserver();
599
600 result.subscribe(o);
601
602 verify(o).onNext(Arrays.asList(1, 2, 3, 4, 5));
603 verify(o).onComplete();
604 verify(o, never()).onError(any(Throwable.class));
605 }
606
607 @Test
608 public void sixSourcesOverload() {
609 Observable<Integer> s1 = Observable.just(1);
610 Observable<Integer> s2 = Observable.just(2);
611 Observable<Integer> s3 = Observable.just(3);
612 Observable<Integer> s4 = Observable.just(4);
613 Observable<Integer> s5 = Observable.just(5);
614 Observable<Integer> s6 = Observable.just(6);
615
616 Observable<List<Integer>> result = Observable.combineLatest(s1, s2, s3, s4, s5, s6,
617 new Function6<Integer, Integer, Integer, Integer, Integer, Integer, List<Integer>>() {
618 @Override
619 public List<Integer> apply(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6) {
620 return Arrays.asList(t1, t2, t3, t4, t5, t6);
621 }
622 });
623
624 Observer<Object> o = TestHelper.mockObserver();
625
626 result.subscribe(o);
627
628 verify(o).onNext(Arrays.asList(1, 2, 3, 4, 5, 6));
629 verify(o).onComplete();
630 verify(o, never()).onError(any(Throwable.class));
631 }
632
633 @Test
634 public void sevenSourcesOverload() {
635 Observable<Integer> s1 = Observable.just(1);
636 Observable<Integer> s2 = Observable.just(2);
637 Observable<Integer> s3 = Observable.just(3);
638 Observable<Integer> s4 = Observable.just(4);
639 Observable<Integer> s5 = Observable.just(5);
640 Observable<Integer> s6 = Observable.just(6);
641 Observable<Integer> s7 = Observable.just(7);
642
643 Observable<List<Integer>> result = Observable.combineLatest(s1, s2, s3, s4, s5, s6, s7,
644 new Function7<Integer, Integer, Integer, Integer, Integer, Integer, Integer, List<Integer>>() {
645 @Override
646 public List<Integer> apply(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6, Integer t7) {
647 return Arrays.asList(t1, t2, t3, t4, t5, t6, t7);
648 }
649 });
650
651 Observer<Object> o = TestHelper.mockObserver();
652
653 result.subscribe(o);
654
655 verify(o).onNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7));
656 verify(o).onComplete();
657 verify(o, never()).onError(any(Throwable.class));
658 }
659
660 @Test
661 public void eightSourcesOverload() {
662 Observable<Integer> s1 = Observable.just(1);
663 Observable<Integer> s2 = Observable.just(2);
664 Observable<Integer> s3 = Observable.just(3);
665 Observable<Integer> s4 = Observable.just(4);
666 Observable<Integer> s5 = Observable.just(5);
667 Observable<Integer> s6 = Observable.just(6);
668 Observable<Integer> s7 = Observable.just(7);
669 Observable<Integer> s8 = Observable.just(8);
670
671 Observable<List<Integer>> result = Observable.combineLatest(s1, s2, s3, s4, s5, s6, s7, s8,
672 new Function8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, List<Integer>>() {
673 @Override
674 public List<Integer> apply(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6, Integer t7, Integer t8) {
675 return Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8);
676 }
677 });
678
679 Observer<Object> o = TestHelper.mockObserver();
680
681 result.subscribe(o);
682
683 verify(o).onNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8));
684 verify(o).onComplete();
685 verify(o, never()).onError(any(Throwable.class));
686 }
687
688 @Test
689 public void nineSourcesOverload() {
690 Observable<Integer> s1 = Observable.just(1);
691 Observable<Integer> s2 = Observable.just(2);
692 Observable<Integer> s3 = Observable.just(3);
693 Observable<Integer> s4 = Observable.just(4);
694 Observable<Integer> s5 = Observable.just(5);
695 Observable<Integer> s6 = Observable.just(6);
696 Observable<Integer> s7 = Observable.just(7);
697 Observable<Integer> s8 = Observable.just(8);
698 Observable<Integer> s9 = Observable.just(9);
699
700 Observable<List<Integer>> result = Observable.combineLatest(s1, s2, s3, s4, s5, s6, s7, s8, s9,
701 new Function9<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, List<Integer>>() {
702 @Override
703 public List<Integer> apply(Integer t1, Integer t2, Integer t3, Integer t4, Integer t5, Integer t6, Integer t7, Integer t8, Integer t9) {
704 return Arrays.asList(t1, t2, t3, t4, t5, t6, t7, t8, t9);
705 }
706 });
707
708 Observer<Object> o = TestHelper.mockObserver();
709
710 result.subscribe(o);
711
712 verify(o).onNext(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9));
713 verify(o).onComplete();
714 verify(o, never()).onError(any(Throwable.class));
715 }
716
717 @Test
718 public void zeroSources() {
719 Observable<Object> result = Observable.combineLatest(
720 Collections.<Observable<Object>> emptyList(), new Function<Object[], Object>() {
721
722 @Override
723 public Object apply(Object[] args) {
724 return args;
725 }
726
727 });
728
729 Observer<Object> o = TestHelper.mockObserver();
730
731 result.subscribe(o);
732
733 verify(o).onComplete();
734 verify(o, never()).onNext(any());
735 verify(o, never()).onError(any(Throwable.class));
736
737 }
738
739 @Test
740 public void withCombineLatestIssue1717() throws InterruptedException {
741 final CountDownLatch latch = new CountDownLatch(1);
742 final AtomicInteger count = new AtomicInteger();
743 final int SIZE = 2000;
744 Observable<Long> timer = Observable.interval(0, 1, TimeUnit.MILLISECONDS)
745 .observeOn(Schedulers.newThread())
746 .doOnEach(new Consumer<Notification<Long>>() {
747 @Override
748 public void accept(Notification<Long> n) {
749 // System.out.println(n);
750 if (count.incrementAndGet() >= SIZE) {
751 latch.countDown();
752 }
753 }
754 }).take(SIZE);
755
756 TestObserver<Long> to = new TestObserver<>();
757
758 Observable.combineLatest(timer, Observable.<Integer> never(), new BiFunction<Long, Integer, Long>() {
759 @Override
760 public Long apply(Long t1, Integer t2) {
761 return t1;
762 }
763 }).subscribe(to);
764
765 if (!latch.await(SIZE + 1000, TimeUnit.MILLISECONDS)) {
766 fail("timed out");
767 }
768
769 assertEquals(SIZE, count.get());
770 }
771
772 @SuppressWarnings("unchecked")
773 @Test
774 public void combineLatestArrayOfSources() {
775
776 Observable.combineLatestArray(new ObservableSource[] {
777 Observable.just(1), Observable.just(2)
778 }, new Function<Object[], Object>() {
779 @Override
780 public Object apply(Object[] a) throws Exception {
781 return Arrays.toString(a);
782 }
783 })
784 .test()
785 .assertResult("[1, 2]");
786 }
787
788 @Test
789 @SuppressWarnings("unchecked")
790 public void combineLatestDelayErrorArrayOfSources() {
791
792 Observable.combineLatestArrayDelayError(new ObservableSource[] {
793 Observable.just(1), Observable.just(2)
794 }, new Function<Object[], Object>() {
795 @Override
796 public Object apply(Object[] a) throws Exception {
797 return Arrays.toString(a);
798 }
799 })
800 .test()
801 .assertResult("[1, 2]");
802 }
803
804 @Test
805 @SuppressWarnings("unchecked")
806 public void combineLatestDelayErrorArrayOfSourcesWithError() {
807
808 Observable.combineLatestArrayDelayError(new ObservableSource[] {
809 Observable.just(1), Observable.just(2).concatWith(Observable.<Integer>error(new TestException()))
810 }, new Function<Object[], Object>() {
811 @Override
812 public Object apply(Object[] a) throws Exception {
813 return Arrays.toString(a);
814 }
815 })
816 .test()
817 .assertFailure(TestException.class, "[1, 2]");
818 }
819
820 @Test
821 public void combineLatestDelayErrorIterableOfSources() {
822
823 Observable.combineLatestDelayError(Arrays.asList(
824 Observable.just(1), Observable.just(2)
825 ), new Function<Object[], Object>() {
826 @Override
827 public Object apply(Object[] a) throws Exception {
828 return Arrays.toString(a);
829 }
830 })
831 .test()
832 .assertResult("[1, 2]");
833 }
834
835 @Test
836 public void combineLatestDelayErrorIterableOfSourcesWithError() {
837
838 Observable.combineLatestDelayError(Arrays.asList(
839 Observable.just(1), Observable.just(2).concatWith(Observable.<Integer>error(new TestException()))
840 ), new Function<Object[], Object>() {
841 @Override
842 public Object apply(Object[] a) throws Exception {
843 return Arrays.toString(a);
844 }
845 })
846 .test()
847 .assertFailure(TestException.class, "[1, 2]");
848 }
849
850 @SuppressWarnings("unchecked")
851 @Test
852 public void combineLatestArrayEmpty() {
853 assertSame(Observable.empty(), Observable.combineLatestArray(new ObservableSource[0], Functions.<Object[]>identity(), 16));
854 }
855
856 @SuppressWarnings("unchecked")
857 @Test
858 public void combineLatestDelayErrorEmpty() {
859 assertSame(Observable.empty(), Observable.combineLatestArrayDelayError(new ObservableSource[0], Functions.<Object[]>identity(), 16));
860 }
861
862 @Test
863 public void disposed() {
864 TestHelper.checkDisposed(Observable.combineLatest(Observable.never(), Observable.never(), new BiFunction<Object, Object, Object>() {
865 @Override
866 public Object apply(Object a, Object b) throws Exception {
867 return a;
868 }
869 }));
870 }
871
872 @Test
873 public void cancelWhileSubscribing() {
874 final TestObserver<Object> to = new TestObserver<>();
875
876 Observable.combineLatest(
877 Observable.just(1)
878 .doOnNext(new Consumer<Integer>() {
879 @Override
880 public void accept(Integer v) throws Exception {
881 to.dispose();
882 }
883 }),
884 Observable.never(),
885 new BiFunction<Object, Object, Object>() {
886 @Override
887 public Object apply(Object a, Object b) throws Exception {
888 return a;
889 }
890 })
891 .subscribe(to);
892 }
893
894 @Test
895 public void combineAsync() {
896 Observable<Integer> source = Observable.range(1, 1000).subscribeOn(Schedulers.computation());
897
898 Observable.combineLatest(source, source, new BiFunction<Object, Object, Object>() {
899 @Override
900 public Object apply(Object a, Object b) throws Exception {
901 return a;
902 }
903 })
904 .take(500)
905 .test()
906 .awaitDone(5, TimeUnit.SECONDS)
907 .assertNoErrors()
908 .assertComplete();
909 }
910
911 @Test
912 public void error() {
913 Observable.combineLatest(Observable.never(), Observable.error(new TestException()), new BiFunction<Object, Object, Object>() {
914 @Override
915 public Object apply(Object a, Object b) throws Exception {
916 return a;
917 }
918 })
919 .test()
920 .assertFailure(TestException.class);
921 }
922
923 @SuppressWarnings("unchecked")
924 @Test
925 public void errorDelayed() {
926 Observable.combineLatestArrayDelayError(
927 new ObservableSource[] { Observable.error(new TestException()), Observable.just(1) },
928 new Function<Object[], Object>() {
929 @Override
930 public Object apply(Object[] a) throws Exception {
931 return a;
932 }
933 },
934 128
935 )
936 .test()
937 .assertFailure(TestException.class);
938 }
939
940 @SuppressWarnings("unchecked")
941 @Test
942 public void errorDelayed2() {
943 Observable.combineLatestArrayDelayError(
944 new ObservableSource[] { Observable.error(new TestException()).startWithItem(1), Observable.empty() },
945 new Function<Object[], Object>() {
946 @Override
947 public Object apply(Object[] a) throws Exception {
948 return a;
949 }
950 },
951 128
952 )
953 .test()
954 .assertFailure(TestException.class);
955 }
956
957 @Test
958 public void onErrorRace() {
959 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
960 List<Throwable> errors = TestHelper.trackPluginErrors();
961 try {
962 final PublishSubject<Integer> ps1 = PublishSubject.create();
963 final PublishSubject<Integer> ps2 = PublishSubject.create();
964
965 TestObserverEx<Integer> to = Observable.combineLatest(ps1, ps2, new BiFunction<Integer, Integer, Integer>() {
966 @Override
967 public Integer apply(Integer a, Integer b) throws Exception {
968 return a;
969 }
970 }).to(TestHelper.<Integer>testConsumer());
971
972 final TestException ex1 = new TestException();
973 final TestException ex2 = new TestException();
974
975 Runnable r1 = new Runnable() {
976 @Override
977 public void run() {
978 ps1.onError(ex1);
979 }
980 };
981 Runnable r2 = new Runnable() {
982 @Override
983 public void run() {
984 ps2.onError(ex2);
985 }
986 };
987
988 TestHelper.race(r1, r2);
989
990 if (to.errors().size() != 0) {
991 if (to.errors().get(0) instanceof CompositeException) {
992 to.assertSubscribed()
993 .assertNotComplete()
994 .assertNoValues();
995
996 for (Throwable e : TestHelper.errorList(to)) {
997 assertTrue(e.toString(), e instanceof TestException);
998 }
999
1000 } else {
1001 to.assertFailure(TestException.class);
1002 }
1003 }
1004
1005 for (Throwable e : errors) {
1006 assertTrue(e.toString(), e.getCause() instanceof TestException);
1007 }
1008 } finally {
1009 RxJavaPlugins.reset();
1010 }
1011 }
1012 }
1013
1014 @Test
1015 public void dontSubscribeIfDone() {
1016 List<Throwable> errors = TestHelper.trackPluginErrors();
1017 try {
1018 final int[] count = { 0 };
1019
1020 Observable.combineLatest(Observable.empty(),
1021 Observable.error(new TestException())
1022 .doOnSubscribe(new Consumer<Disposable>() {
1023 @Override
1024 public void accept(Disposable d) throws Exception {
1025 count[0]++;
1026 }
1027 }),
1028 new BiFunction<Object, Object, Object>() {
1029 @Override
1030 public Object apply(Object a, Object b) throws Exception {
1031 return 0;
1032 }
1033 })
1034 .test()
1035 .assertResult();
1036
1037 assertEquals(0, count[0]);
1038
1039 assertTrue(errors.toString(), errors.isEmpty());
1040 } finally {
1041 RxJavaPlugins.reset();
1042 }
1043 }
1044
1045 @Test
1046 public void dontSubscribeIfDone2() {
1047 List<Throwable> errors = TestHelper.trackPluginErrors();
1048 try {
1049 final int[] count = { 0 };
1050
1051 Observable.combineLatestDelayError(
1052 Arrays.asList(Observable.empty(),
1053 Observable.error(new TestException())
1054 .doOnSubscribe(new Consumer<Disposable>() {
1055 @Override
1056 public void accept(Disposable d) throws Exception {
1057 count[0]++;
1058 }
1059 })
1060 ),
1061 new Function<Object[], Object>() {
1062 @Override
1063 public Object apply(Object[] a) throws Exception {
1064 return 0;
1065 }
1066 })
1067 .test()
1068 .assertResult();
1069
1070 assertEquals(0, count[0]);
1071
1072 assertTrue(errors.toString(), errors.isEmpty());
1073 } finally {
1074 RxJavaPlugins.reset();
1075 }
1076 }
1077
1078 @Test
1079 public void combine2Observable2Errors() throws Exception {
1080 List<Throwable> errors = TestHelper.trackPluginErrors();
1081 try {
1082 TestObserver<Object> testObserver = TestObserver.create();
1083
1084 TestScheduler testScheduler = new TestScheduler();
1085
1086 Observable<Integer> emptyObservable = Observable.timer(10, TimeUnit.MILLISECONDS, testScheduler)
1087 .flatMap(new Function<Long, ObservableSource<Integer>>() {
1088 @Override
1089 public ObservableSource<Integer> apply(Long aLong) throws Exception {
1090 return Observable.error(new Exception());
1091 }
1092 });
1093 Observable<Object> errorObservable = Observable.timer(100, TimeUnit.MILLISECONDS, testScheduler).map(new Function<Long, Object>() {
1094 @Override
1095 public Object apply(Long aLong) throws Exception {
1096 throw new Exception();
1097 }
1098 });
1099
1100 Observable.combineLatestDelayError(
1101 Arrays.asList(
1102 emptyObservable
1103 .doOnEach(new Consumer<Notification<Integer>>() {
1104 @Override
1105 public void accept(Notification<Integer> integerNotification) throws Exception {
1106 System.out.println("emptyObservable: " + integerNotification);
1107 }
1108 })
1109 .doFinally(new Action() {
1110 @Override
1111 public void run() throws Exception {
1112 System.out.println("emptyObservable: doFinally");
1113 }
1114 }),
1115 errorObservable
1116 .doOnEach(new Consumer<Notification<Object>>() {
1117 @Override
1118 public void accept(Notification<Object> integerNotification) throws Exception {
1119 System.out.println("errorObservable: " + integerNotification);
1120 }
1121 })
1122 .doFinally(new Action() {
1123 @Override
1124 public void run() throws Exception {
1125 System.out.println("errorObservable: doFinally");
1126 }
1127 })),
1128 new Function<Object[], Object>() {
1129 @Override
1130 public Object apply(Object[] objects) throws Exception {
1131 return 0;
1132 }
1133 }
1134 )
1135 .doOnEach(new Consumer<Notification<Object>>() {
1136 @Override
1137 public void accept(Notification<Object> integerNotification) throws Exception {
1138 System.out.println("combineLatestDelayError: " + integerNotification);
1139 }
1140 })
1141 .doFinally(new Action() {
1142 @Override
1143 public void run() throws Exception {
1144 System.out.println("combineLatestDelayError: doFinally");
1145 }
1146 })
1147 .subscribe(testObserver);
1148
1149 testScheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
1150
1151 testObserver.awaitDone(5, TimeUnit.SECONDS);
1152
1153 assertTrue(errors.toString(), errors.isEmpty());
1154 } finally {
1155 RxJavaPlugins.reset();
1156 }
1157 }
1158
1159 @Test
1160 public void eagerDispose() {
1161 final PublishSubject<Integer> ps1 = PublishSubject.create();
1162 final PublishSubject<Integer> ps2 = PublishSubject.create();
1163
1164 TestObserver<Integer> to = new TestObserver<Integer>() {
1165 @Override
1166 public void onNext(Integer t) {
1167 super.onNext(t);
1168 dispose();
1169 if (ps1.hasObservers()) {
1170 onError(new IllegalStateException("ps1 not disposed"));
1171 } else
1172 if (ps2.hasObservers()) {
1173 onError(new IllegalStateException("ps2 not disposed"));
1174 } else {
1175 onComplete();
1176 }
1177 }
1178 };
1179
1180 Observable.combineLatest(ps1, ps2, new BiFunction<Integer, Integer, Integer>() {
1181 @Override
1182 public Integer apply(Integer t1, Integer t2) throws Exception {
1183 return t1 + t2;
1184 }
1185 })
1186 .subscribe(to);
1187
1188 ps1.onNext(1);
1189 ps2.onNext(2);
1190 to.assertResult(3);
1191 }
1192
1193 @Test
1194 public void syncFirstErrorsAfterItemDelayError() {
1195 Observable.combineLatestDelayError(Arrays.asList(
1196 Observable.just(21).concatWith(Observable.<Integer>error(new TestException())),
1197 Observable.just(21).delay(100, TimeUnit.MILLISECONDS)
1198 ),
1199 new Function<Object[], Object>() {
1200 @Override
1201 public Object apply(Object[] a) throws Exception {
1202 return (Integer)a[0] + (Integer)a[1];
1203 }
1204 }
1205 )
1206 .test()
1207 .awaitDone(5, TimeUnit.SECONDS)
1208 .assertFailure(TestException.class, 42);
1209 }
1210
1211 @Test
1212 public void observableSourcesInIterable() {
1213 ObservableSource<Integer> source = new ObservableSource<Integer>() {
1214 @Override
1215 public void subscribe(Observer<? super Integer> observer) {
1216 Observable.just(1).subscribe(observer);
1217 }
1218 };
1219
1220 Observable.combineLatest(Arrays.asList(source, source), new Function<Object[], Integer>() {
1221 @Override
1222 public Integer apply(Object[] t) throws Throwable {
1223 return 2;
1224 }
1225 })
1226 .test()
1227 .assertResult(2);
1228 }
1229
1230 @Test
1231 public void onCompleteDisposeRace() {
1232 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
1233
1234 TestObserver<Integer> to = new TestObserver<>();
1235 PublishSubject<Integer> ps = PublishSubject.create();
1236
1237 Observable.combineLatest(ps, Observable.never(), (a, b) -> a)
1238 .subscribe(to);
1239
1240 TestHelper.race(() -> ps.onComplete(), () -> to.dispose());
1241 }
1242 }
1243
1244 @Test
1245 public void onErrorDisposeDelayErrorRace() throws Throwable {
1246 TestHelper.withErrorTracking(errors -> {
1247 TestException ex = new TestException();
1248
1249 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
1250
1251 TestObserverEx<Object[]> to = new TestObserverEx<>();
1252 AtomicReference<Observer<? super Object>> ref = new AtomicReference<>();
1253 Observable<Object> o = new Observable<Object>() {
1254 @Override
1255 public void subscribeActual(Observer<? super Object> observer) {
1256 ref.set(observer);
1257 }
1258 };
1259
1260 Observable.combineLatestDelayError(Arrays.asList(o, Observable.never()), (a) -> a)
1261 .subscribe(to);
1262
1263 ref.get().onSubscribe(Disposable.empty());
1264
1265 TestHelper.race(() -> ref.get().onError(ex), () -> to.dispose());
1266
1267 if (to.errors().isEmpty()) {
1268 TestHelper.assertUndeliverable(errors, 0, TestException.class);
1269 }
1270 }
1271 });
1272 }
1273
1274 @Test
1275 public void doneButNotEmpty() {
1276 PublishSubject<Integer> ps1 = PublishSubject.create();
1277 PublishSubject<Integer> ps2 = PublishSubject.create();
1278
1279 TestObserver<Integer> to = Observable.combineLatest(ps1, ps2, (a, b) -> a + b)
1280 .doOnNext(v -> {
1281 if (v == 2) {
1282 ps2.onNext(3);
1283 ps2.onComplete();
1284 ps1.onComplete();
1285 }
1286 })
1287 .test();
1288
1289 ps1.onNext(1);
1290 ps2.onNext(1);
1291
1292 to.assertResult(2, 4);
1293 }
1294
1295 @Test
1296 public void iterableNullPublisher() {
1297 Observable.combineLatest(Arrays.asList(Observable.never(), null), (a) -> a)
1298 .test()
1299 .assertFailure(NullPointerException.class);
1300 }
1301 }