Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableGroupJoinTest.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
22 import org.junit.*;
23 import org.mockito.MockitoAnnotations;
24
25 import io.reactivex.rxjava3.core.*;
26 import io.reactivex.rxjava3.core.Observable;
27 import io.reactivex.rxjava3.core.Observer;
28 import io.reactivex.rxjava3.disposables.Disposable;
29 import io.reactivex.rxjava3.exceptions.*;
30 import io.reactivex.rxjava3.functions.*;
31 import io.reactivex.rxjava3.internal.functions.Functions;
32 import io.reactivex.rxjava3.internal.operators.observable.ObservableGroupJoin.*;
33 import io.reactivex.rxjava3.observers.TestObserver;
34 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
35 import io.reactivex.rxjava3.subjects.PublishSubject;
36 import io.reactivex.rxjava3.testsupport.*;
37
38 public class ObservableGroupJoinTest extends RxJavaTest {
39
40 Observer<Object> observer = TestHelper.mockObserver();
41
42 BiFunction<Integer, Integer, Integer> add = new BiFunction<Integer, Integer, Integer>() {
43 @Override
44 public Integer apply(Integer t1, Integer t2) {
45 return t1 + t2;
46 }
47 };
48
49 <T> Function<Integer, Observable<T>> just(final Observable<T> observable) {
50 return new Function<Integer, Observable<T>>() {
51 @Override
52 public Observable<T> apply(Integer t1) {
53 return observable;
54 }
55 };
56 }
57
58 <T, R> Function<T, Observable<R>> just2(final Observable<R> observable) {
59 return new Function<T, Observable<R>>() {
60 @Override
61 public Observable<R> apply(T t1) {
62 return observable;
63 }
64 };
65 }
66
67 BiFunction<Integer, Observable<Integer>, Observable<Integer>> add2 = new BiFunction<Integer, Observable<Integer>, Observable<Integer>>() {
68 @Override
69 public Observable<Integer> apply(final Integer leftValue, Observable<Integer> rightValues) {
70 return rightValues.map(new Function<Integer, Integer>() {
71 @Override
72 public Integer apply(Integer rightValue) throws Throwable {
73 return add.apply(leftValue, rightValue);
74 }
75 });
76 }
77
78 };
79
80 @Before
81 public void before() {
82 MockitoAnnotations.openMocks(this);
83 }
84
85 @Test
86 public void behaveAsJoin() {
87 PublishSubject<Integer> source1 = PublishSubject.create();
88 PublishSubject<Integer> source2 = PublishSubject.create();
89
90 Observable<Integer> m = Observable.merge(source1.groupJoin(source2,
91 just(Observable.never()),
92 just(Observable.never()), add2));
93
94 m.subscribe(observer);
95
96 source1.onNext(1);
97 source1.onNext(2);
98 source1.onNext(4);
99
100 source2.onNext(16);
101 source2.onNext(32);
102 source2.onNext(64);
103
104 source1.onComplete();
105 source2.onComplete();
106
107 verify(observer, times(1)).onNext(17);
108 verify(observer, times(1)).onNext(18);
109 verify(observer, times(1)).onNext(20);
110 verify(observer, times(1)).onNext(33);
111 verify(observer, times(1)).onNext(34);
112 verify(observer, times(1)).onNext(36);
113 verify(observer, times(1)).onNext(65);
114 verify(observer, times(1)).onNext(66);
115 verify(observer, times(1)).onNext(68);
116
117 verify(observer, times(1)).onComplete(); //Never emitted?
118 verify(observer, never()).onError(any(Throwable.class));
119 }
120
121 class Person {
122 final int id;
123 final String name;
124
125 Person(int id, String name) {
126 this.id = id;
127 this.name = name;
128 }
129 }
130
131 class PersonFruit {
132 final int personId;
133 final String fruit;
134
135 PersonFruit(int personId, String fruit) {
136 this.personId = personId;
137 this.fruit = fruit;
138 }
139 }
140
141 class PPF {
142 final Person person;
143 final Observable<PersonFruit> fruits;
144
145 PPF(Person person, Observable<PersonFruit> fruits) {
146 this.person = person;
147 this.fruits = fruits;
148 }
149 }
150
151 @Test
152 public void normal1() {
153 Observable<Person> source1 = Observable.fromIterable(Arrays.asList(
154 new Person(1, "Joe"),
155 new Person(2, "Mike"),
156 new Person(3, "Charlie")
157 ));
158
159 Observable<PersonFruit> source2 = Observable.fromIterable(Arrays.asList(
160 new PersonFruit(1, "Strawberry"),
161 new PersonFruit(1, "Apple"),
162 new PersonFruit(3, "Peach")
163 ));
164
165 Observable<PPF> q = source1.groupJoin(
166 source2,
167 just2(Observable.<Object> never()),
168 just2(Observable.<Object> never()),
169 new BiFunction<Person, Observable<PersonFruit>, PPF>() {
170 @Override
171 public PPF apply(Person t1, Observable<PersonFruit> t2) {
172 return new PPF(t1, t2);
173 }
174 });
175
176 q.subscribe(
177 new Observer<PPF>() {
178 @Override
179 public void onNext(final PPF ppf) {
180 ppf.fruits.filter(new Predicate<PersonFruit>() {
181 @Override
182 public boolean test(PersonFruit t1) {
183 return ppf.person.id == t1.personId;
184 }
185 }).subscribe(new Consumer<PersonFruit>() {
186 @Override
187 public void accept(PersonFruit t1) {
188 observer.onNext(Arrays.asList(ppf.person.name, t1.fruit));
189 }
190 });
191 }
192
193 @Override
194 public void onError(Throwable e) {
195 observer.onError(e);
196 }
197
198 @Override
199 public void onComplete() {
200 observer.onComplete();
201 }
202
203 @Override
204 public void onSubscribe(Disposable d) {
205 }
206
207 }
208 );
209
210 verify(observer, times(1)).onNext(Arrays.asList("Joe", "Strawberry"));
211 verify(observer, times(1)).onNext(Arrays.asList("Joe", "Apple"));
212 verify(observer, times(1)).onNext(Arrays.asList("Charlie", "Peach"));
213
214 verify(observer, times(1)).onComplete();
215 verify(observer, never()).onError(any(Throwable.class));
216 }
217
218 @Test
219 public void leftThrows() {
220 PublishSubject<Integer> source1 = PublishSubject.create();
221 PublishSubject<Integer> source2 = PublishSubject.create();
222
223 Observable<Observable<Integer>> m = source1.groupJoin(source2,
224 just(Observable.never()),
225 just(Observable.never()), add2);
226
227 m.subscribe(observer);
228
229 source2.onNext(1);
230 source1.onError(new RuntimeException("Forced failure"));
231
232 verify(observer, times(1)).onError(any(Throwable.class));
233 verify(observer, never()).onComplete();
234 verify(observer, never()).onNext(any());
235 }
236
237 @Test
238 public void rightThrows() {
239 PublishSubject<Integer> source1 = PublishSubject.create();
240 PublishSubject<Integer> source2 = PublishSubject.create();
241
242 Observable<Observable<Integer>> m = source1.groupJoin(source2,
243 just(Observable.never()),
244 just(Observable.never()), add2);
245
246 m.subscribe(observer);
247
248 source1.onNext(1);
249 source2.onError(new RuntimeException("Forced failure"));
250
251 verify(observer, times(1)).onNext(any(Observable.class));
252 verify(observer, times(1)).onError(any(Throwable.class));
253 verify(observer, never()).onComplete();
254 }
255
256 @Test
257 public void leftDurationThrows() {
258 PublishSubject<Integer> source1 = PublishSubject.create();
259 PublishSubject<Integer> source2 = PublishSubject.create();
260
261 Observable<Integer> duration1 = Observable.<Integer> error(new RuntimeException("Forced failure"));
262
263 Observable<Observable<Integer>> m = source1.groupJoin(source2,
264 just(duration1),
265 just(Observable.never()), add2);
266 m.subscribe(observer);
267
268 source1.onNext(1);
269
270 verify(observer, times(1)).onError(any(Throwable.class));
271 verify(observer, never()).onComplete();
272 verify(observer, never()).onNext(any());
273 }
274
275 @Test
276 public void rightDurationThrows() {
277 PublishSubject<Integer> source1 = PublishSubject.create();
278 PublishSubject<Integer> source2 = PublishSubject.create();
279
280 Observable<Integer> duration1 = Observable.<Integer> error(new RuntimeException("Forced failure"));
281
282 Observable<Observable<Integer>> m = source1.groupJoin(source2,
283 just(Observable.never()),
284 just(duration1), add2);
285 m.subscribe(observer);
286
287 source2.onNext(1);
288
289 verify(observer, times(1)).onError(any(Throwable.class));
290 verify(observer, never()).onComplete();
291 verify(observer, never()).onNext(any());
292 }
293
294 @Test
295 public void leftDurationSelectorThrows() {
296 PublishSubject<Integer> source1 = PublishSubject.create();
297 PublishSubject<Integer> source2 = PublishSubject.create();
298
299 Function<Integer, Observable<Integer>> fail = new Function<Integer, Observable<Integer>>() {
300 @Override
301 public Observable<Integer> apply(Integer t1) {
302 throw new RuntimeException("Forced failure");
303 }
304 };
305
306 Observable<Observable<Integer>> m = source1.groupJoin(source2,
307 fail,
308 just(Observable.never()), add2);
309 m.subscribe(observer);
310
311 source1.onNext(1);
312
313 verify(observer, times(1)).onError(any(Throwable.class));
314 verify(observer, never()).onComplete();
315 verify(observer, never()).onNext(any());
316 }
317
318 @Test
319 public void rightDurationSelectorThrows() {
320 PublishSubject<Integer> source1 = PublishSubject.create();
321 PublishSubject<Integer> source2 = PublishSubject.create();
322
323 Function<Integer, Observable<Integer>> fail = new Function<Integer, Observable<Integer>>() {
324 @Override
325 public Observable<Integer> apply(Integer t1) {
326 throw new RuntimeException("Forced failure");
327 }
328 };
329
330 Observable<Observable<Integer>> m = source1.groupJoin(source2,
331 just(Observable.never()),
332 fail, add2);
333 m.subscribe(observer);
334
335 source2.onNext(1);
336
337 verify(observer, times(1)).onError(any(Throwable.class));
338 verify(observer, never()).onComplete();
339 verify(observer, never()).onNext(any());
340 }
341
342 @Test
343 public void resultSelectorThrows() {
344 PublishSubject<Integer> source1 = PublishSubject.create();
345 PublishSubject<Integer> source2 = PublishSubject.create();
346
347 BiFunction<Integer, Observable<Integer>, Integer> fail = new BiFunction<Integer, Observable<Integer>, Integer>() {
348 @Override
349 public Integer apply(Integer t1, Observable<Integer> t2) {
350 throw new RuntimeException("Forced failure");
351 }
352 };
353
354 Observable<Integer> m = source1.groupJoin(source2,
355 just(Observable.never()),
356 just(Observable.never()), fail);
357 m.subscribe(observer);
358
359 source1.onNext(1);
360 source2.onNext(2);
361
362 verify(observer, times(1)).onError(any(Throwable.class));
363 verify(observer, never()).onComplete();
364 verify(observer, never()).onNext(any());
365 }
366
367 @Test
368 public void dispose() {
369 TestHelper.checkDisposed(Observable.just(1).groupJoin(
370 Observable.just(2),
371 new Function<Integer, ObservableSource<Object>>() {
372 @Override
373 public ObservableSource<Object> apply(Integer left) throws Exception {
374 return Observable.never();
375 }
376 },
377 new Function<Integer, ObservableSource<Object>>() {
378 @Override
379 public ObservableSource<Object> apply(Integer right) throws Exception {
380 return Observable.never();
381 }
382 },
383 new BiFunction<Integer, Observable<Integer>, Object>() {
384 @Override
385 public Object apply(Integer r, Observable<Integer> l) throws Exception {
386 return l;
387 }
388 }
389 ));
390 }
391
392 @Test
393 public void innerCompleteLeft() {
394 Observable.just(1)
395 .groupJoin(
396 Observable.just(2),
397 new Function<Integer, ObservableSource<Object>>() {
398 @Override
399 public ObservableSource<Object> apply(Integer left) throws Exception {
400 return Observable.empty();
401 }
402 },
403 new Function<Integer, ObservableSource<Object>>() {
404 @Override
405 public ObservableSource<Object> apply(Integer right) throws Exception {
406 return Observable.never();
407 }
408 },
409 new BiFunction<Integer, Observable<Integer>, Observable<Integer>>() {
410 @Override
411 public Observable<Integer> apply(Integer r, Observable<Integer> l) throws Exception {
412 return l;
413 }
414 }
415 )
416 .flatMap(Functions.<Observable<Integer>>identity())
417 .test()
418 .assertResult();
419 }
420
421 @Test
422 public void innerErrorLeft() {
423 Observable.just(1)
424 .groupJoin(
425 Observable.just(2),
426 new Function<Integer, ObservableSource<Object>>() {
427 @Override
428 public ObservableSource<Object> apply(Integer left) throws Exception {
429 return Observable.error(new TestException());
430 }
431 },
432 new Function<Integer, ObservableSource<Object>>() {
433 @Override
434 public ObservableSource<Object> apply(Integer right) throws Exception {
435 return Observable.never();
436 }
437 },
438 new BiFunction<Integer, Observable<Integer>, Observable<Integer>>() {
439 @Override
440 public Observable<Integer> apply(Integer r, Observable<Integer> l) throws Exception {
441 return l;
442 }
443 }
444 )
445 .flatMap(Functions.<Observable<Integer>>identity())
446 .test()
447 .assertFailure(TestException.class);
448 }
449
450 @Test
451 public void innerCompleteRight() {
452 Observable.just(1)
453 .groupJoin(
454 Observable.just(2),
455 new Function<Integer, ObservableSource<Object>>() {
456 @Override
457 public ObservableSource<Object> apply(Integer left) throws Exception {
458 return Observable.never();
459 }
460 },
461 new Function<Integer, ObservableSource<Object>>() {
462 @Override
463 public ObservableSource<Object> apply(Integer right) throws Exception {
464 return Observable.empty();
465 }
466 },
467 new BiFunction<Integer, Observable<Integer>, Observable<Integer>>() {
468 @Override
469 public Observable<Integer> apply(Integer r, Observable<Integer> l) throws Exception {
470 return l;
471 }
472 }
473 )
474 .flatMap(Functions.<Observable<Integer>>identity())
475 .test()
476 .assertResult(2);
477 }
478
479 @Test
480 @SuppressUndeliverable
481 public void innerErrorRight() {
482 Observable.just(1)
483 .groupJoin(
484 Observable.just(2),
485 new Function<Integer, ObservableSource<Object>>() {
486 @Override
487 public ObservableSource<Object> apply(Integer left) throws Exception {
488 return Observable.never();
489 }
490 },
491 new Function<Integer, ObservableSource<Object>>() {
492 @Override
493 public ObservableSource<Object> apply(Integer right) throws Exception {
494 return Observable.error(new TestException());
495 }
496 },
497 new BiFunction<Integer, Observable<Integer>, Observable<Integer>>() {
498 @Override
499 public Observable<Integer> apply(Integer r, Observable<Integer> l) throws Exception {
500 return l;
501 }
502 }
503 )
504 .flatMap(Functions.<Observable<Integer>>identity())
505 .test()
506 .assertFailure(TestException.class);
507 }
508
509 @Test
510 public void innerErrorRace() {
511 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
512 final PublishSubject<Object> ps1 = PublishSubject.create();
513 final PublishSubject<Object> ps2 = PublishSubject.create();
514
515 List<Throwable> errors = TestHelper.trackPluginErrors();
516
517 try {
518 TestObserverEx<Observable<Integer>> to = Observable.just(1)
519 .groupJoin(
520 Observable.just(2).concatWith(Observable.<Integer>never()),
521 new Function<Integer, ObservableSource<Object>>() {
522 @Override
523 public ObservableSource<Object> apply(Integer left) throws Exception {
524 return ps1;
525 }
526 },
527 new Function<Integer, ObservableSource<Object>>() {
528 @Override
529 public ObservableSource<Object> apply(Integer right) throws Exception {
530 return ps2;
531 }
532 },
533 new BiFunction<Integer, Observable<Integer>, Observable<Integer>>() {
534 @Override
535 public Observable<Integer> apply(Integer r, Observable<Integer> l) throws Exception {
536 return l;
537 }
538 }
539 )
540 .to(TestHelper.<Observable<Integer>>testConsumer());
541
542 final TestException ex1 = new TestException();
543 final TestException ex2 = new TestException();
544
545 Runnable r1 = new Runnable() {
546 @Override
547 public void run() {
548 ps1.onError(ex1);
549 }
550 };
551 Runnable r2 = new Runnable() {
552 @Override
553 public void run() {
554 ps2.onError(ex2);
555 }
556 };
557
558 TestHelper.race(r1, r2);
559
560 to.assertError(Throwable.class).assertSubscribed().assertNotComplete().assertValueCount(1);
561
562 Throwable exc = to.errors().get(0);
563
564 if (exc instanceof CompositeException) {
565 List<Throwable> es = TestHelper.compositeList(exc);
566 TestHelper.assertError(es, 0, TestException.class);
567 TestHelper.assertError(es, 1, TestException.class);
568 } else {
569 to.assertError(TestException.class);
570 }
571
572 if (!errors.isEmpty()) {
573 TestHelper.assertUndeliverable(errors, 0, TestException.class);
574 }
575 } finally {
576 RxJavaPlugins.reset();
577 }
578 }
579 }
580
581 @Test
582 public void outerErrorRace() {
583 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
584 final PublishSubject<Object> ps1 = PublishSubject.create();
585 final PublishSubject<Object> ps2 = PublishSubject.create();
586
587 List<Throwable> errors = TestHelper.trackPluginErrors();
588
589 try {
590 TestObserverEx<Object> to = ps1
591 .groupJoin(
592 ps2,
593 new Function<Object, ObservableSource<Object>>() {
594 @Override
595 public ObservableSource<Object> apply(Object left) throws Exception {
596 return Observable.never();
597 }
598 },
599 new Function<Object, ObservableSource<Object>>() {
600 @Override
601 public ObservableSource<Object> apply(Object right) throws Exception {
602 return Observable.never();
603 }
604 },
605 new BiFunction<Object, Observable<Object>, Observable<Object>>() {
606 @Override
607 public Observable<Object> apply(Object r, Observable<Object> l) throws Exception {
608 return l;
609 }
610 }
611 )
612 .flatMap(Functions.<Observable<Object>>identity())
613 .to(TestHelper.<Object>testConsumer());
614
615 final TestException ex1 = new TestException();
616 final TestException ex2 = new TestException();
617
618 Runnable r1 = new Runnable() {
619 @Override
620 public void run() {
621 ps1.onError(ex1);
622 }
623 };
624 Runnable r2 = new Runnable() {
625 @Override
626 public void run() {
627 ps2.onError(ex2);
628 }
629 };
630
631 TestHelper.race(r1, r2);
632
633 to.assertError(Throwable.class).assertSubscribed().assertNotComplete().assertNoValues();
634
635 Throwable exc = to.errors().get(0);
636
637 if (exc instanceof CompositeException) {
638 List<Throwable> es = TestHelper.compositeList(exc);
639 TestHelper.assertError(es, 0, TestException.class);
640 TestHelper.assertError(es, 1, TestException.class);
641 } else {
642 to.assertError(TestException.class);
643 }
644
645 if (!errors.isEmpty()) {
646 TestHelper.assertUndeliverable(errors, 0, TestException.class);
647 }
648 } finally {
649 RxJavaPlugins.reset();
650 }
651 }
652 }
653
654 @Test
655 public void rightEmission() {
656 final PublishSubject<Object> ps1 = PublishSubject.create();
657 final PublishSubject<Object> ps2 = PublishSubject.create();
658
659 TestObserver<Object> to = ps1
660 .groupJoin(
661 ps2,
662 new Function<Object, ObservableSource<Object>>() {
663 @Override
664 public ObservableSource<Object> apply(Object left) throws Exception {
665 return Observable.never();
666 }
667 },
668 new Function<Object, ObservableSource<Object>>() {
669 @Override
670 public ObservableSource<Object> apply(Object right) throws Exception {
671 return Observable.never();
672 }
673 },
674 new BiFunction<Object, Observable<Object>, Observable<Object>>() {
675 @Override
676 public Observable<Object> apply(Object r, Observable<Object> l) throws Exception {
677 return l;
678 }
679 }
680 )
681 .flatMap(Functions.<Observable<Object>>identity())
682 .test();
683
684 ps2.onNext(2);
685
686 ps1.onNext(1);
687 ps1.onComplete();
688
689 ps2.onComplete();
690
691 to.assertResult(2);
692 }
693
694 @Test
695 public void leftRightState() {
696 JoinSupport js = mock(JoinSupport.class);
697
698 LeftRightObserver o = new LeftRightObserver(js, false);
699
700 assertFalse(o.isDisposed());
701
702 o.onNext(1);
703 o.onNext(2);
704
705 o.dispose();
706
707 assertTrue(o.isDisposed());
708
709 verify(js).innerValue(false, 1);
710 verify(js).innerValue(false, 2);
711 }
712
713 @Test
714 public void leftRightEndState() {
715 JoinSupport js = mock(JoinSupport.class);
716
717 LeftRightEndObserver o = new LeftRightEndObserver(js, false, 0);
718
719 assertFalse(o.isDisposed());
720
721 o.onNext(1);
722 o.onNext(2);
723
724 assertTrue(o.isDisposed());
725
726 verify(js).innerClose(false, o);
727 }
728
729 @Test
730 public void disposeAfterOnNext() {
731 PublishSubject<Integer> ps1 = PublishSubject.create();
732 PublishSubject<Integer> ps2 = PublishSubject.create();
733
734 TestObserver<Integer> to = new TestObserver<>();
735
736 ps1.groupJoin(ps2, v -> Observable.never(), v -> Observable.never(), (a, b) -> a)
737 .doOnNext(v -> {
738 to.dispose();
739 })
740 .subscribe(to);
741
742 ps2.onNext(1);
743 ps1.onNext(1);
744 }
745
746 @Test
747 public void completeWithMoreWork() {
748 PublishSubject<Integer> ps1 = PublishSubject.create();
749 PublishSubject<Integer> ps2 = PublishSubject.create();
750
751 TestObserver<Integer> to = new TestObserver<>();
752
753 ps1.groupJoin(ps2, v -> Observable.never(), v -> Observable.never(), (a, b) -> a)
754 .doOnNext(v -> {
755 if (v == 1) {
756 ps2.onNext(2);
757 ps1.onComplete();
758 ps2.onComplete();
759 }
760 })
761 .subscribe(to);
762
763 ps2.onNext(1);
764 ps1.onNext(1);
765 }
766 }