Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableJoinTest.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.mockito.ArgumentMatchers.any;
17 import static org.mockito.Mockito.*;
18
19 import java.util.List;
20
21 import io.reactivex.rxjava3.disposables.Disposable;
22 import org.junit.*;
23 import org.mockito.MockitoAnnotations;
24
25 import io.reactivex.rxjava3.core.*;
26 import io.reactivex.rxjava3.exceptions.TestException;
27 import io.reactivex.rxjava3.functions.*;
28 import io.reactivex.rxjava3.internal.functions.Functions;
29 import io.reactivex.rxjava3.observers.TestObserver;
30 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
31 import io.reactivex.rxjava3.subjects.PublishSubject;
32 import io.reactivex.rxjava3.testsupport.*;
33
34 public class ObservableJoinTest extends RxJavaTest {
35 Observer<Object> observer = TestHelper.mockObserver();
36
37 BiFunction<Integer, Integer, Integer> add = new BiFunction<Integer, Integer, Integer>() {
38 @Override
39 public Integer apply(Integer t1, Integer t2) {
40 return t1 + t2;
41 }
42 };
43
44 <T> Function<Integer, Observable<T>> just(final Observable<T> observable) {
45 return new Function<Integer, Observable<T>>() {
46 @Override
47 public Observable<T> apply(Integer t1) {
48 return observable;
49 }
50 };
51 }
52
53 @Before
54 public void before() {
55 MockitoAnnotations.openMocks(this);
56 }
57
58 @Test
59 public void normal1() {
60 PublishSubject<Integer> source1 = PublishSubject.create();
61 PublishSubject<Integer> source2 = PublishSubject.create();
62
63 Observable<Integer> m = source1.join(source2,
64 just(Observable.never()),
65 just(Observable.never()), add);
66
67 m.subscribe(observer);
68
69 source1.onNext(1);
70 source1.onNext(2);
71 source1.onNext(4);
72
73 source2.onNext(16);
74 source2.onNext(32);
75 source2.onNext(64);
76
77 source1.onComplete();
78 source2.onComplete();
79
80 verify(observer, times(1)).onNext(17);
81 verify(observer, times(1)).onNext(18);
82 verify(observer, times(1)).onNext(20);
83 verify(observer, times(1)).onNext(33);
84 verify(observer, times(1)).onNext(34);
85 verify(observer, times(1)).onNext(36);
86 verify(observer, times(1)).onNext(65);
87 verify(observer, times(1)).onNext(66);
88 verify(observer, times(1)).onNext(68);
89
90 verify(observer, times(1)).onComplete();
91 verify(observer, never()).onError(any(Throwable.class));
92 }
93
94 @Test
95 public void normal1WithDuration() {
96 PublishSubject<Integer> source1 = PublishSubject.create();
97 PublishSubject<Integer> source2 = PublishSubject.create();
98
99 PublishSubject<Integer> duration1 = PublishSubject.create();
100
101 Observable<Integer> m = source1.join(source2,
102 just(duration1),
103 just(Observable.never()), add);
104 m.subscribe(observer);
105
106 source1.onNext(1);
107 source1.onNext(2);
108 source2.onNext(16);
109
110 duration1.onNext(1);
111
112 source1.onNext(4);
113 source1.onNext(8);
114
115 source1.onComplete();
116 source2.onComplete();
117
118 verify(observer, times(1)).onNext(17);
119 verify(observer, times(1)).onNext(18);
120 verify(observer, times(1)).onNext(20);
121 verify(observer, times(1)).onNext(24);
122
123 verify(observer, times(1)).onComplete();
124 verify(observer, never()).onError(any(Throwable.class));
125
126 }
127
128 @Test
129 public void normal2() {
130 PublishSubject<Integer> source1 = PublishSubject.create();
131 PublishSubject<Integer> source2 = PublishSubject.create();
132
133 Observable<Integer> m = source1.join(source2,
134 just(Observable.never()),
135 just(Observable.never()), add);
136
137 m.subscribe(observer);
138
139 source1.onNext(1);
140 source1.onNext(2);
141 source1.onComplete();
142
143 source2.onNext(16);
144 source2.onNext(32);
145 source2.onNext(64);
146
147 source2.onComplete();
148
149 verify(observer, times(1)).onNext(17);
150 verify(observer, times(1)).onNext(18);
151 verify(observer, times(1)).onNext(33);
152 verify(observer, times(1)).onNext(34);
153 verify(observer, times(1)).onNext(65);
154 verify(observer, times(1)).onNext(66);
155
156 verify(observer, times(1)).onComplete();
157 verify(observer, never()).onError(any(Throwable.class));
158 }
159
160 @Test
161 public void leftThrows() {
162 PublishSubject<Integer> source1 = PublishSubject.create();
163 PublishSubject<Integer> source2 = PublishSubject.create();
164
165 Observable<Integer> m = source1.join(source2,
166 just(Observable.never()),
167 just(Observable.never()), add);
168
169 m.subscribe(observer);
170
171 source2.onNext(1);
172 source1.onError(new RuntimeException("Forced failure"));
173
174 verify(observer, times(1)).onError(any(Throwable.class));
175 verify(observer, never()).onComplete();
176 verify(observer, never()).onNext(any());
177 }
178
179 @Test
180 public void rightThrows() {
181 PublishSubject<Integer> source1 = PublishSubject.create();
182 PublishSubject<Integer> source2 = PublishSubject.create();
183
184 Observable<Integer> m = source1.join(source2,
185 just(Observable.never()),
186 just(Observable.never()), add);
187
188 m.subscribe(observer);
189
190 source1.onNext(1);
191 source2.onError(new RuntimeException("Forced failure"));
192
193 verify(observer, times(1)).onError(any(Throwable.class));
194 verify(observer, never()).onComplete();
195 verify(observer, never()).onNext(any());
196 }
197
198 @Test
199 public void leftDurationThrows() {
200 PublishSubject<Integer> source1 = PublishSubject.create();
201 PublishSubject<Integer> source2 = PublishSubject.create();
202
203 Observable<Integer> duration1 = Observable.<Integer> error(new RuntimeException("Forced failure"));
204
205 Observable<Integer> m = source1.join(source2,
206 just(duration1),
207 just(Observable.never()), add);
208 m.subscribe(observer);
209
210 source1.onNext(1);
211
212 verify(observer, times(1)).onError(any(Throwable.class));
213 verify(observer, never()).onComplete();
214 verify(observer, never()).onNext(any());
215 }
216
217 @Test
218 public void rightDurationThrows() {
219 PublishSubject<Integer> source1 = PublishSubject.create();
220 PublishSubject<Integer> source2 = PublishSubject.create();
221
222 Observable<Integer> duration1 = Observable.<Integer> error(new RuntimeException("Forced failure"));
223
224 Observable<Integer> m = source1.join(source2,
225 just(Observable.never()),
226 just(duration1), add);
227 m.subscribe(observer);
228
229 source2.onNext(1);
230
231 verify(observer, times(1)).onError(any(Throwable.class));
232 verify(observer, never()).onComplete();
233 verify(observer, never()).onNext(any());
234 }
235
236 @Test
237 public void leftDurationSelectorThrows() {
238 PublishSubject<Integer> source1 = PublishSubject.create();
239 PublishSubject<Integer> source2 = PublishSubject.create();
240
241 Function<Integer, Observable<Integer>> fail = new Function<Integer, Observable<Integer>>() {
242 @Override
243 public Observable<Integer> apply(Integer t1) {
244 throw new RuntimeException("Forced failure");
245 }
246 };
247
248 Observable<Integer> m = source1.join(source2,
249 fail,
250 just(Observable.never()), add);
251 m.subscribe(observer);
252
253 source1.onNext(1);
254
255 verify(observer, times(1)).onError(any(Throwable.class));
256 verify(observer, never()).onComplete();
257 verify(observer, never()).onNext(any());
258 }
259
260 @Test
261 public void rightDurationSelectorThrows() {
262 PublishSubject<Integer> source1 = PublishSubject.create();
263 PublishSubject<Integer> source2 = PublishSubject.create();
264
265 Function<Integer, Observable<Integer>> fail = new Function<Integer, Observable<Integer>>() {
266 @Override
267 public Observable<Integer> apply(Integer t1) {
268 throw new RuntimeException("Forced failure");
269 }
270 };
271
272 Observable<Integer> m = source1.join(source2,
273 just(Observable.never()),
274 fail, add);
275 m.subscribe(observer);
276
277 source2.onNext(1);
278
279 verify(observer, times(1)).onError(any(Throwable.class));
280 verify(observer, never()).onComplete();
281 verify(observer, never()).onNext(any());
282 }
283
284 @Test
285 public void resultSelectorThrows() {
286 PublishSubject<Integer> source1 = PublishSubject.create();
287 PublishSubject<Integer> source2 = PublishSubject.create();
288
289 BiFunction<Integer, Integer, Integer> fail = new BiFunction<Integer, Integer, Integer>() {
290 @Override
291 public Integer apply(Integer t1, Integer t2) {
292 throw new RuntimeException("Forced failure");
293 }
294 };
295
296 Observable<Integer> m = source1.join(source2,
297 just(Observable.never()),
298 just(Observable.never()), fail);
299 m.subscribe(observer);
300
301 source1.onNext(1);
302 source2.onNext(2);
303
304 verify(observer, times(1)).onError(any(Throwable.class));
305 verify(observer, never()).onComplete();
306 verify(observer, never()).onNext(any());
307 }
308
309 @Test
310 public void dispose() {
311 TestHelper.checkDisposed(PublishSubject.<Integer>create().join(Observable.just(1),
312 Functions.justFunction(Observable.never()),
313 Functions.justFunction(Observable.never()), new BiFunction<Integer, Integer, Integer>() {
314 @Override
315 public Integer apply(Integer a, Integer b) throws Exception {
316 return a + b;
317 }
318 }));
319 }
320
321 @Test
322 public void take() {
323 Observable.just(1).join(
324 Observable.just(2),
325 Functions.justFunction(Observable.never()),
326 Functions.justFunction(Observable.never()),
327 new BiFunction<Integer, Integer, Integer>() {
328 @Override
329 public Integer apply(Integer a, Integer b) throws Exception {
330 return a + b;
331 }
332 })
333 .take(1)
334 .test()
335 .assertResult(3);
336 }
337
338 @Test
339 public void rightClose() {
340 PublishSubject<Integer> ps = PublishSubject.create();
341
342 TestObserver<Integer> to = ps.join(Observable.just(2),
343 Functions.justFunction(Observable.never()),
344 Functions.justFunction(Observable.empty()),
345 new BiFunction<Integer, Integer, Integer>() {
346 @Override
347 public Integer apply(Integer a, Integer b) throws Exception {
348 return a + b;
349 }
350 })
351 .test()
352 .assertEmpty();
353
354 ps.onNext(1);
355
356 to.assertEmpty();
357 }
358
359 @Test
360 public void resultSelectorThrows2() {
361 PublishSubject<Integer> ps = PublishSubject.create();
362
363 TestObserver<Integer> to = ps.join(
364 Observable.just(2),
365 Functions.justFunction(Observable.never()),
366 Functions.justFunction(Observable.never()),
367 new BiFunction<Integer, Integer, Integer>() {
368 @Override
369 public Integer apply(Integer a, Integer b) throws Exception {
370 throw new TestException();
371 }
372 })
373 .test();
374
375 ps.onNext(1);
376 ps.onComplete();
377
378 to.assertFailure(TestException.class);
379 }
380
381 @Test
382 public void badOuterSource() {
383 List<Throwable> errors = TestHelper.trackPluginErrors();
384 try {
385 new Observable<Integer>() {
386 @Override
387 protected void subscribeActual(Observer<? super Integer> observer) {
388 observer.onSubscribe(Disposable.empty());
389 observer.onError(new TestException("First"));
390 observer.onError(new TestException("Second"));
391 }
392 }
393 .join(Observable.just(2),
394 Functions.justFunction(Observable.never()),
395 Functions.justFunction(Observable.never()),
396 new BiFunction<Integer, Integer, Integer>() {
397 @Override
398 public Integer apply(Integer a, Integer b) throws Exception {
399 return a + b;
400 }
401 })
402 .to(TestHelper.<Integer>testConsumer())
403 .assertFailureAndMessage(TestException.class, "First");
404
405 TestHelper.assertUndeliverable(errors, 0, TestException.class, "Second");
406 } finally {
407 RxJavaPlugins.reset();
408 }
409 }
410
411 @Test
412 public void badEndSource() {
413 List<Throwable> errors = TestHelper.trackPluginErrors();
414 try {
415 @SuppressWarnings("rawtypes")
416 final Observer[] o = { null };
417
418 TestObserverEx<Integer> to = Observable.just(1)
419 .join(Observable.just(2),
420 Functions.justFunction(Observable.never()),
421 Functions.justFunction(new Observable<Integer>() {
422 @Override
423 protected void subscribeActual(Observer<? super Integer> observer) {
424 o[0] = observer;
425 observer.onSubscribe(Disposable.empty());
426 observer.onError(new TestException("First"));
427 }
428 }),
429 new BiFunction<Integer, Integer, Integer>() {
430 @Override
431 public Integer apply(Integer a, Integer b) throws Exception {
432 return a + b;
433 }
434 })
435 .to(TestHelper.<Integer>testConsumer());
436
437 o[0].onError(new TestException("Second"));
438
439 to
440 .assertFailureAndMessage(TestException.class, "First");
441
442 TestHelper.assertUndeliverable(errors, 0, TestException.class, "Second");
443 } finally {
444 RxJavaPlugins.reset();
445 }
446 }
447
448 @Test
449 public void bothTerminateWithWorkRemaining() {
450 PublishSubject<Integer> ps1 = PublishSubject.create();
451 PublishSubject<Integer> ps2 = PublishSubject.create();
452
453 TestObserver<Integer> to = ps1.join(
454 ps2,
455 v -> Observable.never(),
456 v -> Observable.never(),
457 (a, b) -> a + b)
458 .doOnNext(v -> {
459 ps1.onComplete();
460 ps2.onNext(2);
461 ps2.onComplete();
462 })
463 .test();
464
465 ps1.onNext(0);
466 ps2.onNext(1);
467
468 to.assertComplete();
469 }
470 }