Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableAnyTest.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.io.IOException;
21 import java.util.List;
22 import java.util.concurrent.TimeUnit;
23
24 import io.reactivex.rxjava3.disposables.Disposable;
25 import org.junit.Test;
26
27 import io.reactivex.rxjava3.core.*;
28 import io.reactivex.rxjava3.exceptions.TestException;
29 import io.reactivex.rxjava3.functions.*;
30 import io.reactivex.rxjava3.internal.functions.Functions;
31 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
32 import io.reactivex.rxjava3.testsupport.*;
33
34 public class ObservableAnyTest extends RxJavaTest {
35
36 @Test
37 public void anyWithTwoItemsObservable() {
38 Observable<Integer> w = Observable.just(1, 2);
39 Observable<Boolean> observable = w.any(new Predicate<Integer>() {
40 @Override
41 public boolean test(Integer v) {
42 return true;
43 }
44 }).toObservable();
45
46 Observer<Boolean> observer = TestHelper.mockObserver();
47
48 observable.subscribe(observer);
49
50 verify(observer, never()).onNext(false);
51 verify(observer, times(1)).onNext(true);
52 verify(observer, never()).onError(any(Throwable.class));
53 verify(observer, times(1)).onComplete();
54 }
55
56 @Test
57 public void isEmptyWithTwoItemsObservable() {
58 Observable<Integer> w = Observable.just(1, 2);
59 Observable<Boolean> observable = w.isEmpty().toObservable();
60
61 Observer<Boolean> observer = TestHelper.mockObserver();
62
63 observable.subscribe(observer);
64
65 verify(observer, never()).onNext(true);
66 verify(observer, times(1)).onNext(false);
67 verify(observer, never()).onError(any(Throwable.class));
68 verify(observer, times(1)).onComplete();
69 }
70
71 @Test
72 public void anyWithOneItemObservable() {
73 Observable<Integer> w = Observable.just(1);
74 Observable<Boolean> observable = w.any(new Predicate<Integer>() {
75 @Override
76 public boolean test(Integer v) {
77 return true;
78 }
79 }).toObservable();
80
81 Observer<Boolean> observer = TestHelper.mockObserver();
82
83 observable.subscribe(observer);
84
85 verify(observer, never()).onNext(false);
86 verify(observer, times(1)).onNext(true);
87 verify(observer, never()).onError(any(Throwable.class));
88 verify(observer, times(1)).onComplete();
89 }
90
91 @Test
92 public void isEmptyWithOneItemObservable() {
93 Observable<Integer> w = Observable.just(1);
94 Observable<Boolean> observable = w.isEmpty().toObservable();
95
96 Observer<Boolean> observer = TestHelper.mockObserver();
97
98 observable.subscribe(observer);
99
100 verify(observer, never()).onNext(true);
101 verify(observer, times(1)).onNext(false);
102 verify(observer, never()).onError(any(Throwable.class));
103 verify(observer, times(1)).onComplete();
104 }
105
106 @Test
107 public void anyWithEmptyObservable() {
108 Observable<Integer> w = Observable.empty();
109 Observable<Boolean> observable = w.any(new Predicate<Integer>() {
110 @Override
111 public boolean test(Integer v) {
112 return true;
113 }
114 }).toObservable();
115
116 Observer<Boolean> observer = TestHelper.mockObserver();
117
118 observable.subscribe(observer);
119
120 verify(observer, times(1)).onNext(false);
121 verify(observer, never()).onNext(true);
122 verify(observer, never()).onError(any(Throwable.class));
123 verify(observer, times(1)).onComplete();
124 }
125
126 @Test
127 public void isEmptyWithEmptyObservable() {
128 Observable<Integer> w = Observable.empty();
129 Observable<Boolean> observable = w.isEmpty().toObservable();
130
131 Observer<Boolean> observer = TestHelper.mockObserver();
132
133 observable.subscribe(observer);
134
135 verify(observer, times(1)).onNext(true);
136 verify(observer, never()).onNext(false);
137 verify(observer, never()).onError(any(Throwable.class));
138 verify(observer, times(1)).onComplete();
139 }
140
141 @Test
142 public void anyWithPredicate1Observable() {
143 Observable<Integer> w = Observable.just(1, 2, 3);
144 Observable<Boolean> observable = w.any(new Predicate<Integer>() {
145 @Override
146 public boolean test(Integer t1) {
147 return t1 < 2;
148 }
149 }).toObservable();
150
151 Observer<Boolean> observer = TestHelper.mockObserver();
152
153 observable.subscribe(observer);
154
155 verify(observer, never()).onNext(false);
156 verify(observer, times(1)).onNext(true);
157 verify(observer, never()).onError(any(Throwable.class));
158 verify(observer, times(1)).onComplete();
159 }
160
161 @Test
162 public void exists1Observable() {
163 Observable<Integer> w = Observable.just(1, 2, 3);
164 Observable<Boolean> observable = w.any(new Predicate<Integer>() {
165 @Override
166 public boolean test(Integer t1) {
167 return t1 < 2;
168 }
169 }).toObservable();
170
171 Observer<Boolean> observer = TestHelper.mockObserver();
172
173 observable.subscribe(observer);
174
175 verify(observer, never()).onNext(false);
176 verify(observer, times(1)).onNext(true);
177 verify(observer, never()).onError(any(Throwable.class));
178 verify(observer, times(1)).onComplete();
179 }
180
181 @Test
182 public void anyWithPredicate2Observable() {
183 Observable<Integer> w = Observable.just(1, 2, 3);
184 Observable<Boolean> observable = w.any(new Predicate<Integer>() {
185 @Override
186 public boolean test(Integer t1) {
187 return t1 < 1;
188 }
189 }).toObservable();
190
191 Observer<Boolean> observer = TestHelper.mockObserver();
192
193 observable.subscribe(observer);
194
195 verify(observer, times(1)).onNext(false);
196 verify(observer, never()).onNext(true);
197 verify(observer, never()).onError(any(Throwable.class));
198 verify(observer, times(1)).onComplete();
199 }
200
201 @Test
202 public void anyWithEmptyAndPredicateObservable() {
203 // If the source is empty, always output false.
204 Observable<Integer> w = Observable.empty();
205 Observable<Boolean> observable = w.any(new Predicate<Integer>() {
206 @Override
207 public boolean test(Integer t) {
208 return true;
209 }
210 }).toObservable();
211
212 Observer<Boolean> observer = TestHelper.mockObserver();
213
214 observable.subscribe(observer);
215
216 verify(observer, times(1)).onNext(false);
217 verify(observer, never()).onNext(true);
218 verify(observer, never()).onError(any(Throwable.class));
219 verify(observer, times(1)).onComplete();
220 }
221
222 @Test
223 public void withFollowingFirstObservable() {
224 Observable<Integer> o = Observable.fromArray(1, 3, 5, 6);
225 Observable<Boolean> anyEven = o.any(new Predicate<Integer>() {
226 @Override
227 public boolean test(Integer i) {
228 return i % 2 == 0;
229 }
230 }).toObservable();
231
232 assertTrue(anyEven.blockingFirst());
233 }
234
235 @Test
236 public void issue1935NoUnsubscribeDownstreamObservable() {
237 Observable<Integer> source = Observable.just(1).isEmpty().toObservable()
238 .flatMap(new Function<Boolean, Observable<Integer>>() {
239 @Override
240 public Observable<Integer> apply(Boolean t1) {
241 return Observable.just(2).delay(500, TimeUnit.MILLISECONDS);
242 }
243 });
244
245 assertEquals((Object)2, source.blockingFirst());
246 }
247
248 @Test
249 public void predicateThrowsExceptionAndValueInCauseMessageObservable() {
250 TestObserverEx<Boolean> to = new TestObserverEx<>();
251 final IllegalArgumentException ex = new IllegalArgumentException();
252
253 Observable.just("Boo!").any(new Predicate<String>() {
254 @Override
255 public boolean test(String v) {
256 throw ex;
257 }
258 }).subscribe(to);
259
260 to.assertTerminated();
261 to.assertNoValues();
262 to.assertNotComplete();
263 to.assertError(ex);
264 // FIXME value as last cause?
265 // assertTrue(ex.getCause().getMessage().contains("Boo!"));
266 }
267
268 @Test
269 public void anyWithTwoItems() {
270 Observable<Integer> w = Observable.just(1, 2);
271 Single<Boolean> single = w.any(new Predicate<Integer>() {
272 @Override
273 public boolean test(Integer v) {
274 return true;
275 }
276 });
277
278 SingleObserver<Boolean> observer = TestHelper.mockSingleObserver();
279
280 single.subscribe(observer);
281
282 verify(observer, never()).onSuccess(false);
283 verify(observer, times(1)).onSuccess(true);
284 verify(observer, never()).onError(any(Throwable.class));
285 }
286
287 @Test
288 public void isEmptyWithTwoItems() {
289 Observable<Integer> w = Observable.just(1, 2);
290 Single<Boolean> single = w.isEmpty();
291
292 SingleObserver<Boolean> observer = TestHelper.mockSingleObserver();
293
294 single.subscribe(observer);
295
296 verify(observer, never()).onSuccess(true);
297 verify(observer, times(1)).onSuccess(false);
298 verify(observer, never()).onError(any(Throwable.class));
299 }
300
301 @Test
302 public void anyWithOneItem() {
303 Observable<Integer> w = Observable.just(1);
304 Single<Boolean> single = w.any(new Predicate<Integer>() {
305 @Override
306 public boolean test(Integer v) {
307 return true;
308 }
309 });
310
311 SingleObserver<Boolean> observer = TestHelper.mockSingleObserver();
312
313 single.subscribe(observer);
314
315 verify(observer, never()).onSuccess(false);
316 verify(observer, times(1)).onSuccess(true);
317 verify(observer, never()).onError(any(Throwable.class));
318 }
319
320 @Test
321 public void isEmptyWithOneItem() {
322 Observable<Integer> w = Observable.just(1);
323 Single<Boolean> single = w.isEmpty();
324
325 SingleObserver<Boolean> observer = TestHelper.mockSingleObserver();
326
327 single.subscribe(observer);
328
329 verify(observer, never()).onSuccess(true);
330 verify(observer, times(1)).onSuccess(false);
331 verify(observer, never()).onError(any(Throwable.class));
332 }
333
334 @Test
335 public void anyWithEmpty() {
336 Observable<Integer> w = Observable.empty();
337 Single<Boolean> single = w.any(new Predicate<Integer>() {
338 @Override
339 public boolean test(Integer v) {
340 return true;
341 }
342 });
343
344 SingleObserver<Boolean> observer = TestHelper.mockSingleObserver();
345
346 single.subscribe(observer);
347
348 verify(observer, times(1)).onSuccess(false);
349 verify(observer, never()).onSuccess(true);
350 verify(observer, never()).onError(any(Throwable.class));
351 }
352
353 @Test
354 public void isEmptyWithEmpty() {
355 Observable<Integer> w = Observable.empty();
356 Single<Boolean> single = w.isEmpty();
357
358 SingleObserver<Boolean> observer = TestHelper.mockSingleObserver();
359
360 single.subscribe(observer);
361
362 verify(observer, times(1)).onSuccess(true);
363 verify(observer, never()).onSuccess(false);
364 verify(observer, never()).onError(any(Throwable.class));
365 }
366
367 @Test
368 public void anyWithPredicate1() {
369 Observable<Integer> w = Observable.just(1, 2, 3);
370 Single<Boolean> single = w.any(new Predicate<Integer>() {
371 @Override
372 public boolean test(Integer t1) {
373 return t1 < 2;
374 }
375 });
376
377 SingleObserver<Boolean> observer = TestHelper.mockSingleObserver();
378
379 single.subscribe(observer);
380
381 verify(observer, never()).onSuccess(false);
382 verify(observer, times(1)).onSuccess(true);
383 verify(observer, never()).onError(any(Throwable.class));
384 }
385
386 @Test
387 public void exists1() {
388 Observable<Integer> w = Observable.just(1, 2, 3);
389 Single<Boolean> single = w.any(new Predicate<Integer>() {
390 @Override
391 public boolean test(Integer t1) {
392 return t1 < 2;
393 }
394 });
395
396 SingleObserver<Boolean> observer = TestHelper.mockSingleObserver();
397
398 single.subscribe(observer);
399
400 verify(observer, never()).onSuccess(false);
401 verify(observer, times(1)).onSuccess(true);
402 verify(observer, never()).onError(any(Throwable.class));
403 }
404
405 @Test
406 public void anyWithPredicate2() {
407 Observable<Integer> w = Observable.just(1, 2, 3);
408 Single<Boolean> single = w.any(new Predicate<Integer>() {
409 @Override
410 public boolean test(Integer t1) {
411 return t1 < 1;
412 }
413 });
414
415 SingleObserver<Boolean> observer = TestHelper.mockSingleObserver();
416
417 single.subscribe(observer);
418
419 verify(observer, times(1)).onSuccess(false);
420 verify(observer, never()).onSuccess(true);
421 verify(observer, never()).onError(any(Throwable.class));
422 }
423
424 @Test
425 public void anyWithEmptyAndPredicate() {
426 // If the source is empty, always output false.
427 Observable<Integer> w = Observable.empty();
428 Single<Boolean> single = w.any(new Predicate<Integer>() {
429 @Override
430 public boolean test(Integer t) {
431 return true;
432 }
433 });
434
435 SingleObserver<Boolean> observer = TestHelper.mockSingleObserver();
436
437 single.subscribe(observer);
438
439 verify(observer, times(1)).onSuccess(false);
440 verify(observer, never()).onSuccess(true);
441 verify(observer, never()).onError(any(Throwable.class));
442 }
443
444 @Test
445 public void withFollowingFirst() {
446 Observable<Integer> o = Observable.fromArray(1, 3, 5, 6);
447 Single<Boolean> anyEven = o.any(new Predicate<Integer>() {
448 @Override
449 public boolean test(Integer i) {
450 return i % 2 == 0;
451 }
452 });
453
454 assertTrue(anyEven.blockingGet());
455 }
456
457 @Test
458 public void issue1935NoUnsubscribeDownstream() {
459 Observable<Integer> source = Observable.just(1).isEmpty()
460 .flatMapObservable(new Function<Boolean, Observable<Integer>>() {
461 @Override
462 public Observable<Integer> apply(Boolean t1) {
463 return Observable.just(2).delay(500, TimeUnit.MILLISECONDS);
464 }
465 });
466
467 assertEquals((Object)2, source.blockingFirst());
468 }
469
470 @Test
471 public void predicateThrowsExceptionAndValueInCauseMessage() {
472 TestObserverEx<Boolean> to = new TestObserverEx<>();
473 final IllegalArgumentException ex = new IllegalArgumentException();
474
475 Observable.just("Boo!").any(new Predicate<String>() {
476 @Override
477 public boolean test(String v) {
478 throw ex;
479 }
480 }).subscribe(to);
481
482 to.assertTerminated();
483 to.assertNoValues();
484 to.assertNotComplete();
485 to.assertError(ex);
486 // FIXME value as last cause?
487 // assertTrue(ex.getCause().getMessage().contains("Boo!"));
488 }
489
490 @Test
491 public void dispose() {
492 TestHelper.checkDisposed(Observable.just(1).any(Functions.alwaysTrue()).toObservable());
493
494 TestHelper.checkDisposed(Observable.just(1).any(Functions.alwaysTrue()));
495 }
496
497 @Test
498 public void doubleOnSubscribe() {
499 TestHelper.checkDoubleOnSubscribeObservable(new Function<Observable<Object>, ObservableSource<Boolean>>() {
500 @Override
501 public ObservableSource<Boolean> apply(Observable<Object> o) throws Exception {
502 return o.any(Functions.alwaysTrue()).toObservable();
503 }
504 });
505 TestHelper.checkDoubleOnSubscribeObservableToSingle(new Function<Observable<Object>, SingleSource<Boolean>>() {
506 @Override
507 public SingleSource<Boolean> apply(Observable<Object> o) throws Exception {
508 return o.any(Functions.alwaysTrue());
509 }
510 });
511 }
512
513 @Test
514 public void predicateThrowsSuppressOthers() {
515 List<Throwable> errors = TestHelper.trackPluginErrors();
516 try {
517 new Observable<Integer>() {
518 @Override
519 protected void subscribeActual(Observer<? super Integer> observer) {
520 observer.onSubscribe(Disposable.empty());
521
522 observer.onNext(1);
523 observer.onNext(2);
524 observer.onError(new IOException());
525 observer.onComplete();
526 }
527 }
528 .any(new Predicate<Integer>() {
529 @Override
530 public boolean test(Integer v) throws Exception {
531 throw new TestException();
532 }
533 })
534 .toObservable()
535 .test()
536 .assertFailure(TestException.class);
537
538 TestHelper.assertUndeliverable(errors, 0, IOException.class);
539 } finally {
540 RxJavaPlugins.reset();
541 }
542 }
543
544 @Test
545 public void badSourceSingle() {
546 List<Throwable> errors = TestHelper.trackPluginErrors();
547 try {
548 new Observable<Integer>() {
549 @Override
550 protected void subscribeActual(Observer<? super Integer> observer) {
551 observer.onSubscribe(Disposable.empty());
552 observer.onError(new TestException("First"));
553
554 observer.onNext(1);
555 observer.onError(new TestException("Second"));
556 observer.onComplete();
557 }
558 }
559 .any(Functions.alwaysTrue())
560 .to(TestHelper.<Boolean>testConsumer())
561 .assertFailureAndMessage(TestException.class, "First");
562
563 TestHelper.assertUndeliverable(errors, 0, TestException.class, "Second");
564 } finally {
565 RxJavaPlugins.reset();
566 }
567 }
568 }