Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableFirstTest.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.*;
17 import static org.mockito.Mockito.*;
18
19 import java.util.NoSuchElementException;
20
21 import org.junit.*;
22 import org.mockito.InOrder;
23
24 import io.reactivex.rxjava3.core.*;
25 import io.reactivex.rxjava3.functions.Predicate;
26 import io.reactivex.rxjava3.testsupport.TestHelper;
27
28 public class ObservableFirstTest extends RxJavaTest {
29
30 Observer<String> w;
31 SingleObserver<Object> wo;
32 MaybeObserver<Object> wm;
33
34 private static final Predicate<String> IS_D = new Predicate<String>() {
35 @Override
36 public boolean test(String value) {
37 return "d".equals(value);
38 }
39 };
40
41 @Before
42 public void before() {
43 w = TestHelper.mockObserver();
44 wo = TestHelper.mockSingleObserver();
45 wm = TestHelper.mockMaybeObserver();
46 }
47
48 @Test
49 public void firstOrElseOfNoneObservable() {
50 Observable<String> src = Observable.empty();
51 src.first("default").toObservable().subscribe(w);
52
53 verify(w, times(1)).onNext(anyString());
54 verify(w, times(1)).onNext("default");
55 verify(w, never()).onError(any(Throwable.class));
56 verify(w, times(1)).onComplete();
57 }
58
59 @Test
60 public void firstOrElseOfSomeObservable() {
61 Observable<String> src = Observable.just("a", "b", "c");
62 src.first("default").toObservable().subscribe(w);
63
64 verify(w, times(1)).onNext(anyString());
65 verify(w, times(1)).onNext("a");
66 verify(w, never()).onError(any(Throwable.class));
67 verify(w, times(1)).onComplete();
68 }
69
70 @Test
71 public void firstOrElseWithPredicateOfNoneMatchingThePredicateObservable() {
72 Observable<String> src = Observable.just("a", "b", "c");
73 src.filter(IS_D).first("default").toObservable().subscribe(w);
74
75 verify(w, times(1)).onNext(anyString());
76 verify(w, times(1)).onNext("default");
77 verify(w, never()).onError(any(Throwable.class));
78 verify(w, times(1)).onComplete();
79 }
80
81 @Test
82 public void firstOrElseWithPredicateOfSomeObservable() {
83 Observable<String> src = Observable.just("a", "b", "c", "d", "e", "f");
84 src.filter(IS_D).first("default").toObservable().subscribe(w);
85
86 verify(w, times(1)).onNext(anyString());
87 verify(w, times(1)).onNext("d");
88 verify(w, never()).onError(any(Throwable.class));
89 verify(w, times(1)).onComplete();
90 }
91
92 @Test
93 public void firstObservable() {
94 Observable<Integer> o = Observable.just(1, 2, 3).firstElement().toObservable();
95
96 Observer<Integer> observer = TestHelper.mockObserver();
97 o.subscribe(observer);
98
99 InOrder inOrder = inOrder(observer);
100 inOrder.verify(observer, times(1)).onNext(1);
101 inOrder.verify(observer, times(1)).onComplete();
102 inOrder.verifyNoMoreInteractions();
103 }
104
105 @Test
106 public void firstWithOneElementObservable() {
107 Observable<Integer> o = Observable.just(1).firstElement().toObservable();
108
109 Observer<Integer> observer = TestHelper.mockObserver();
110 o.subscribe(observer);
111
112 InOrder inOrder = inOrder(observer);
113 inOrder.verify(observer, times(1)).onNext(1);
114 inOrder.verify(observer, times(1)).onComplete();
115 inOrder.verifyNoMoreInteractions();
116 }
117
118 @Test
119 public void firstWithEmptyObservable() {
120 Observable<Integer> o = Observable.<Integer> empty().firstElement().toObservable();
121
122 Observer<Integer> observer = TestHelper.mockObserver();
123 o.subscribe(observer);
124
125 InOrder inOrder = inOrder(observer);
126 inOrder.verify(observer).onComplete();
127 inOrder.verify(observer, never()).onError(any(Throwable.class));
128 inOrder.verifyNoMoreInteractions();
129 }
130
131 @Test
132 public void firstWithPredicateObservable() {
133 Observable<Integer> o = Observable.just(1, 2, 3, 4, 5, 6)
134 .filter(new Predicate<Integer>() {
135 @Override
136 public boolean test(Integer t1) {
137 return t1 % 2 == 0;
138 }
139 })
140 .firstElement().toObservable();
141
142 Observer<Integer> observer = TestHelper.mockObserver();
143 o.subscribe(observer);
144
145 InOrder inOrder = inOrder(observer);
146 inOrder.verify(observer, times(1)).onNext(2);
147 inOrder.verify(observer, times(1)).onComplete();
148 inOrder.verifyNoMoreInteractions();
149 }
150
151 @Test
152 public void firstWithPredicateAndOneElementObservable() {
153 Observable<Integer> o = Observable.just(1, 2)
154 .filter(new Predicate<Integer>() {
155 @Override
156 public boolean test(Integer t1) {
157 return t1 % 2 == 0;
158 }
159 })
160 .firstElement().toObservable();
161
162 Observer<Integer> observer = TestHelper.mockObserver();
163 o.subscribe(observer);
164
165 InOrder inOrder = inOrder(observer);
166 inOrder.verify(observer, times(1)).onNext(2);
167 inOrder.verify(observer, times(1)).onComplete();
168 inOrder.verifyNoMoreInteractions();
169 }
170
171 @Test
172 public void firstWithPredicateAndEmptyObservable() {
173 Observable<Integer> o = Observable.just(1)
174 .filter(new Predicate<Integer>() {
175 @Override
176 public boolean test(Integer t1) {
177 return t1 % 2 == 0;
178 }
179 })
180 .firstElement().toObservable();
181
182 Observer<Integer> observer = TestHelper.mockObserver();
183 o.subscribe(observer);
184
185 InOrder inOrder = inOrder(observer);
186 inOrder.verify(observer).onComplete();
187 inOrder.verify(observer, never()).onError(any(Throwable.class));
188 inOrder.verifyNoMoreInteractions();
189 }
190
191 @Test
192 public void firstOrDefaultObservable() {
193 Observable<Integer> o = Observable.just(1, 2, 3)
194 .first(4).toObservable();
195
196 Observer<Integer> observer = TestHelper.mockObserver();
197 o.subscribe(observer);
198
199 InOrder inOrder = inOrder(observer);
200 inOrder.verify(observer, times(1)).onNext(1);
201 inOrder.verify(observer, times(1)).onComplete();
202 inOrder.verifyNoMoreInteractions();
203 }
204
205 @Test
206 public void firstOrDefaultWithOneElementObservable() {
207 Observable<Integer> o = Observable.just(1).first(2).toObservable();
208
209 Observer<Integer> observer = TestHelper.mockObserver();
210 o.subscribe(observer);
211
212 InOrder inOrder = inOrder(observer);
213 inOrder.verify(observer, times(1)).onNext(1);
214 inOrder.verify(observer, times(1)).onComplete();
215 inOrder.verifyNoMoreInteractions();
216 }
217
218 @Test
219 public void firstOrDefaultWithEmptyObservable() {
220 Observable<Integer> o = Observable.<Integer> empty()
221 .first(1).toObservable();
222
223 Observer<Integer> observer = TestHelper.mockObserver();
224 o.subscribe(observer);
225
226 InOrder inOrder = inOrder(observer);
227 inOrder.verify(observer, times(1)).onNext(1);
228 inOrder.verify(observer, times(1)).onComplete();
229 inOrder.verifyNoMoreInteractions();
230 }
231
232 @Test
233 public void firstOrDefaultWithPredicateObservable() {
234 Observable<Integer> o = Observable.just(1, 2, 3, 4, 5, 6)
235 .filter(new Predicate<Integer>() {
236 @Override
237 public boolean test(Integer t1) {
238 return t1 % 2 == 0;
239 }
240 })
241 .first(8).toObservable();
242
243 Observer<Integer> observer = TestHelper.mockObserver();
244 o.subscribe(observer);
245
246 InOrder inOrder = inOrder(observer);
247 inOrder.verify(observer, times(1)).onNext(2);
248 inOrder.verify(observer, times(1)).onComplete();
249 inOrder.verifyNoMoreInteractions();
250 }
251
252 @Test
253 public void firstOrDefaultWithPredicateAndOneElementObservable() {
254 Observable<Integer> o = Observable.just(1, 2)
255 .filter(new Predicate<Integer>() {
256 @Override
257 public boolean test(Integer t1) {
258 return t1 % 2 == 0;
259 }
260 })
261 .first(4).toObservable();
262
263 Observer<Integer> observer = TestHelper.mockObserver();
264 o.subscribe(observer);
265
266 InOrder inOrder = inOrder(observer);
267 inOrder.verify(observer, times(1)).onNext(2);
268 inOrder.verify(observer, times(1)).onComplete();
269 inOrder.verifyNoMoreInteractions();
270 }
271
272 @Test
273 public void firstOrDefaultWithPredicateAndEmptyObservable() {
274 Observable<Integer> o = Observable.just(1)
275 .filter(new Predicate<Integer>() {
276 @Override
277 public boolean test(Integer t1) {
278 return t1 % 2 == 0;
279 }
280 })
281 .first(2).toObservable();
282
283 Observer<Integer> observer = TestHelper.mockObserver();
284 o.subscribe(observer);
285
286 InOrder inOrder = inOrder(observer);
287 inOrder.verify(observer, times(1)).onNext(2);
288 inOrder.verify(observer, times(1)).onComplete();
289 inOrder.verifyNoMoreInteractions();
290 }
291
292 @Test
293 public void firstOrElseOfNone() {
294 Observable<String> src = Observable.empty();
295 src.first("default").subscribe(wo);
296
297 verify(wo, times(1)).onSuccess(anyString());
298 verify(wo, times(1)).onSuccess("default");
299 verify(wo, never()).onError(any(Throwable.class));
300 }
301
302 @Test
303 public void firstOrElseOfSome() {
304 Observable<String> src = Observable.just("a", "b", "c");
305 src.first("default").subscribe(wo);
306
307 verify(wo, times(1)).onSuccess(anyString());
308 verify(wo, times(1)).onSuccess("a");
309 verify(wo, never()).onError(any(Throwable.class));
310 }
311
312 @Test
313 public void firstOrElseWithPredicateOfNoneMatchingThePredicate() {
314 Observable<String> src = Observable.just("a", "b", "c");
315 src.filter(IS_D).first("default").subscribe(wo);
316
317 verify(wo, times(1)).onSuccess(anyString());
318 verify(wo, times(1)).onSuccess("default");
319 verify(wo, never()).onError(any(Throwable.class));
320 }
321
322 @Test
323 public void firstOrElseWithPredicateOfSome() {
324 Observable<String> src = Observable.just("a", "b", "c", "d", "e", "f");
325 src.filter(IS_D).first("default").subscribe(wo);
326
327 verify(wo, times(1)).onSuccess(anyString());
328 verify(wo, times(1)).onSuccess("d");
329 verify(wo, never()).onError(any(Throwable.class));
330 }
331
332 @Test
333 public void first() {
334 Maybe<Integer> o = Observable.just(1, 2, 3).firstElement();
335
336 o.subscribe(wm);
337
338 InOrder inOrder = inOrder(wm);
339 inOrder.verify(wm, times(1)).onSuccess(1);
340 inOrder.verifyNoMoreInteractions();
341 }
342
343 @Test
344 public void firstWithOneElement() {
345 Maybe<Integer> o = Observable.just(1).firstElement();
346
347 o.subscribe(wm);
348
349 InOrder inOrder = inOrder(wm);
350 inOrder.verify(wm, times(1)).onSuccess(1);
351 inOrder.verifyNoMoreInteractions();
352 }
353
354 @Test
355 public void firstWithEmpty() {
356 Maybe<Integer> o = Observable.<Integer> empty().firstElement();
357
358 o.subscribe(wm);
359
360 InOrder inOrder = inOrder(wm);
361 inOrder.verify(wm, times(1)).onComplete();
362 inOrder.verify(wm, never()).onError(any(Throwable.class));
363 inOrder.verifyNoMoreInteractions();
364 }
365
366 @Test
367 public void firstWithPredicate() {
368 Maybe<Integer> o = Observable.just(1, 2, 3, 4, 5, 6)
369 .filter(new Predicate<Integer>() {
370 @Override
371 public boolean test(Integer t1) {
372 return t1 % 2 == 0;
373 }
374 })
375 .firstElement();
376
377 o.subscribe(wm);
378
379 InOrder inOrder = inOrder(wm);
380 inOrder.verify(wm, times(1)).onSuccess(2);
381 inOrder.verifyNoMoreInteractions();
382 }
383
384 @Test
385 public void firstWithPredicateAndOneElement() {
386 Maybe<Integer> o = Observable.just(1, 2)
387 .filter(new Predicate<Integer>() {
388 @Override
389 public boolean test(Integer t1) {
390 return t1 % 2 == 0;
391 }
392 })
393 .firstElement();
394
395 o.subscribe(wm);
396
397 InOrder inOrder = inOrder(wm);
398 inOrder.verify(wm, times(1)).onSuccess(2);
399 inOrder.verifyNoMoreInteractions();
400 }
401
402 @Test
403 public void firstWithPredicateAndEmpty() {
404 Maybe<Integer> o = Observable.just(1)
405 .filter(new Predicate<Integer>() {
406 @Override
407 public boolean test(Integer t1) {
408 return t1 % 2 == 0;
409 }
410 })
411 .firstElement();
412
413 o.subscribe(wm);
414
415 InOrder inOrder = inOrder(wm);
416 inOrder.verify(wm, times(1)).onComplete();
417 inOrder.verify(wm, never()).onError(any(Throwable.class));
418 inOrder.verifyNoMoreInteractions();
419 }
420
421 @Test
422 public void firstOrDefault() {
423 Single<Integer> o = Observable.just(1, 2, 3)
424 .first(4);
425
426 o.subscribe(wo);
427
428 InOrder inOrder = inOrder(wo);
429 inOrder.verify(wo, times(1)).onSuccess(1);
430 inOrder.verifyNoMoreInteractions();
431 }
432
433 @Test
434 public void firstOrDefaultWithOneElement() {
435 Single<Integer> o = Observable.just(1).first(2);
436
437 o.subscribe(wo);
438
439 InOrder inOrder = inOrder(wo);
440 inOrder.verify(wo, times(1)).onSuccess(1);
441 inOrder.verifyNoMoreInteractions();
442 }
443
444 @Test
445 public void firstOrDefaultWithEmpty() {
446 Single<Integer> o = Observable.<Integer> empty()
447 .first(1);
448
449 o.subscribe(wo);
450
451 InOrder inOrder = inOrder(wo);
452 inOrder.verify(wo, times(1)).onSuccess(1);
453 inOrder.verifyNoMoreInteractions();
454 }
455
456 @Test
457 public void firstOrDefaultWithPredicate() {
458 Single<Integer> o = Observable.just(1, 2, 3, 4, 5, 6)
459 .filter(new Predicate<Integer>() {
460 @Override
461 public boolean test(Integer t1) {
462 return t1 % 2 == 0;
463 }
464 })
465 .first(8);
466
467 o.subscribe(wo);
468
469 InOrder inOrder = inOrder(wo);
470 inOrder.verify(wo, times(1)).onSuccess(2);
471 inOrder.verifyNoMoreInteractions();
472 }
473
474 @Test
475 public void firstOrDefaultWithPredicateAndOneElement() {
476 Single<Integer> o = Observable.just(1, 2)
477 .filter(new Predicate<Integer>() {
478 @Override
479 public boolean test(Integer t1) {
480 return t1 % 2 == 0;
481 }
482 })
483 .first(4);
484
485 o.subscribe(wo);
486
487 InOrder inOrder = inOrder(wo);
488 inOrder.verify(wo, times(1)).onSuccess(2);
489 inOrder.verifyNoMoreInteractions();
490 }
491
492 @Test
493 public void firstOrDefaultWithPredicateAndEmpty() {
494 Single<Integer> o = Observable.just(1)
495 .filter(new Predicate<Integer>() {
496 @Override
497 public boolean test(Integer t1) {
498 return t1 % 2 == 0;
499 }
500 })
501 .first(2);
502
503 o.subscribe(wo);
504
505 InOrder inOrder = inOrder(wo);
506 inOrder.verify(wo, times(1)).onSuccess(2);
507 inOrder.verifyNoMoreInteractions();
508 }
509
510 @Test
511 public void firstOrErrorNoElement() {
512 Observable.empty()
513 .firstOrError()
514 .test()
515 .assertNoValues()
516 .assertError(NoSuchElementException.class);
517 }
518
519 @Test
520 public void firstOrErrorOneElement() {
521 Observable.just(1)
522 .firstOrError()
523 .test()
524 .assertNoErrors()
525 .assertValue(1);
526 }
527
528 @Test
529 public void firstOrErrorMultipleElements() {
530 Observable.just(1, 2, 3)
531 .firstOrError()
532 .test()
533 .assertNoErrors()
534 .assertValue(1);
535 }
536
537 @Test
538 public void firstOrErrorError() {
539 Observable.error(new RuntimeException("error"))
540 .firstOrError()
541 .to(TestHelper.testConsumer())
542 .assertNoValues()
543 .assertErrorMessage("error")
544 .assertError(RuntimeException.class);
545 }
546
547 @Test
548 public void firstOrErrorNoElementObservable() {
549 Observable.empty()
550 .firstOrError()
551 .toObservable()
552 .test()
553 .assertNoValues()
554 .assertError(NoSuchElementException.class);
555 }
556
557 @Test
558 public void firstOrErrorOneElementObservable() {
559 Observable.just(1)
560 .firstOrError()
561 .toObservable()
562 .test()
563 .assertNoErrors()
564 .assertValue(1);
565 }
566
567 @Test
568 public void firstOrErrorMultipleElementsObservable() {
569 Observable.just(1, 2, 3)
570 .firstOrError()
571 .toObservable()
572 .test()
573 .assertNoErrors()
574 .assertValue(1);
575 }
576
577 @Test
578 public void firstOrErrorErrorObservable() {
579 Observable.error(new RuntimeException("error"))
580 .firstOrError()
581 .toObservable()
582 .to(TestHelper.testConsumer())
583 .assertNoValues()
584 .assertErrorMessage("error")
585 .assertError(RuntimeException.class);
586 }
587 }