Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableSingleTest.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.NoSuchElementException;
21 import java.util.concurrent.atomic.AtomicReference;
22
23 import org.junit.Test;
24 import org.mockito.InOrder;
25
26 import io.reactivex.rxjava3.core.*;
27 import io.reactivex.rxjava3.functions.*;
28 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
29 import io.reactivex.rxjava3.testsupport.TestHelper;
30
31 public class ObservableSingleTest extends RxJavaTest {
32
33 @Test
34 public void singleObservable() {
35 Observable<Integer> o = Observable.just(1).singleElement().toObservable();
36
37 Observer<Integer> observer = TestHelper.mockObserver();
38 o.subscribe(observer);
39
40 InOrder inOrder = inOrder(observer);
41 inOrder.verify(observer, times(1)).onNext(1);
42 inOrder.verify(observer, times(1)).onComplete();
43 inOrder.verifyNoMoreInteractions();
44 }
45
46 @Test
47 public void singleWithTooManyElementsObservable() {
48 Observable<Integer> o = Observable.just(1, 2).singleElement().toObservable();
49
50 Observer<Integer> observer = TestHelper.mockObserver();
51 o.subscribe(observer);
52
53 InOrder inOrder = inOrder(observer);
54 inOrder.verify(observer, times(1)).onError(
55 isA(IllegalArgumentException.class));
56 inOrder.verifyNoMoreInteractions();
57 }
58
59 @Test
60 public void singleWithEmptyObservable() {
61 Observable<Integer> o = Observable.<Integer> empty().singleElement().toObservable();
62
63 Observer<Integer> observer = TestHelper.mockObserver();
64 o.subscribe(observer);
65
66 InOrder inOrder = inOrder(observer);
67 inOrder.verify(observer).onComplete();
68 inOrder.verify(observer, never()).onError(any(Throwable.class));
69 inOrder.verifyNoMoreInteractions();
70 }
71
72 @Test
73 public void singleWithPredicateObservable() {
74 Observable<Integer> o = Observable.just(1, 2)
75 .filter(
76 new Predicate<Integer>() {
77
78 @Override
79 public boolean test(Integer t1) {
80 return t1 % 2 == 0;
81 }
82 })
83 .singleElement().toObservable();
84
85 Observer<Integer> observer = TestHelper.mockObserver();
86 o.subscribe(observer);
87
88 InOrder inOrder = inOrder(observer);
89 inOrder.verify(observer, times(1)).onNext(2);
90 inOrder.verify(observer, times(1)).onComplete();
91 inOrder.verifyNoMoreInteractions();
92 }
93
94 @Test
95 public void singleWithPredicateAndTooManyElementsObservable() {
96 Observable<Integer> o = Observable.just(1, 2, 3, 4)
97 .filter(
98 new Predicate<Integer>() {
99
100 @Override
101 public boolean test(Integer t1) {
102 return t1 % 2 == 0;
103 }
104 })
105 .singleElement().toObservable();
106
107 Observer<Integer> observer = TestHelper.mockObserver();
108 o.subscribe(observer);
109
110 InOrder inOrder = inOrder(observer);
111 inOrder.verify(observer, times(1)).onError(
112 isA(IllegalArgumentException.class));
113 inOrder.verifyNoMoreInteractions();
114 }
115
116 @Test
117 public void singleWithPredicateAndEmptyObservable() {
118 Observable<Integer> o = Observable.just(1)
119 .filter(
120 new Predicate<Integer>() {
121
122 @Override
123 public boolean test(Integer t1) {
124 return t1 % 2 == 0;
125 }
126 })
127 .singleElement().toObservable();
128 Observer<Integer> observer = TestHelper.mockObserver();
129 o.subscribe(observer);
130
131 InOrder inOrder = inOrder(observer);
132 inOrder.verify(observer).onComplete();
133 inOrder.verify(observer, never()).onError(any(Throwable.class));
134 inOrder.verifyNoMoreInteractions();
135 }
136
137 @Test
138 public void singleOrDefaultObservable() {
139 Observable<Integer> o = Observable.just(1).single(2).toObservable();
140
141 Observer<Integer> observer = TestHelper.mockObserver();
142 o.subscribe(observer);
143
144 InOrder inOrder = inOrder(observer);
145 inOrder.verify(observer, times(1)).onNext(1);
146 inOrder.verify(observer, times(1)).onComplete();
147 inOrder.verifyNoMoreInteractions();
148 }
149
150 @Test
151 public void singleOrDefaultWithTooManyElementsObservable() {
152 Observable<Integer> o = Observable.just(1, 2).single(3).toObservable();
153
154 Observer<Integer> observer = TestHelper.mockObserver();
155 o.subscribe(observer);
156
157 InOrder inOrder = inOrder(observer);
158 inOrder.verify(observer, times(1)).onError(
159 isA(IllegalArgumentException.class));
160 inOrder.verifyNoMoreInteractions();
161 }
162
163 @Test
164 public void singleOrDefaultWithEmptyObservable() {
165 Observable<Integer> o = Observable.<Integer> empty()
166 .single(1).toObservable();
167
168 Observer<Integer> observer = TestHelper.mockObserver();
169 o.subscribe(observer);
170
171 InOrder inOrder = inOrder(observer);
172 inOrder.verify(observer, times(1)).onNext(1);
173 inOrder.verify(observer, times(1)).onComplete();
174 inOrder.verifyNoMoreInteractions();
175 }
176
177 @Test
178 public void singleOrDefaultWithPredicateObservable() {
179 Observable<Integer> o = Observable.just(1, 2)
180 .filter(new Predicate<Integer>() {
181 @Override
182 public boolean test(Integer t1) {
183 return t1 % 2 == 0;
184 }
185 })
186 .single(4).toObservable();
187
188 Observer<Integer> observer = TestHelper.mockObserver();
189 o.subscribe(observer);
190
191 InOrder inOrder = inOrder(observer);
192 inOrder.verify(observer, times(1)).onNext(2);
193 inOrder.verify(observer, times(1)).onComplete();
194 inOrder.verifyNoMoreInteractions();
195 }
196
197 @Test
198 public void singleOrDefaultWithPredicateAndTooManyElementsObservable() {
199 Observable<Integer> o = Observable.just(1, 2, 3, 4)
200 .filter(new Predicate<Integer>() {
201 @Override
202 public boolean test(Integer t1) {
203 return t1 % 2 == 0;
204 }
205 })
206 .single(6).toObservable();
207
208 Observer<Integer> observer = TestHelper.mockObserver();
209 o.subscribe(observer);
210
211 InOrder inOrder = inOrder(observer);
212 inOrder.verify(observer, times(1)).onError(
213 isA(IllegalArgumentException.class));
214 inOrder.verifyNoMoreInteractions();
215 }
216
217 @Test
218 public void singleOrDefaultWithPredicateAndEmptyObservable() {
219 Observable<Integer> o = Observable.just(1)
220 .filter(new Predicate<Integer>() {
221 @Override
222 public boolean test(Integer t1) {
223 return t1 % 2 == 0;
224 }
225 })
226 .single(2).toObservable();
227
228 Observer<Integer> observer = TestHelper.mockObserver();
229 o.subscribe(observer);
230
231 InOrder inOrder = inOrder(observer);
232 inOrder.verify(observer, times(1)).onNext(2);
233 inOrder.verify(observer, times(1)).onComplete();
234 inOrder.verifyNoMoreInteractions();
235 }
236
237 @Test
238 public void issue1527Observable() throws InterruptedException {
239 //https://github.com/ReactiveX/RxJava/pull/1527
240 Observable<Integer> source = Observable.just(1, 2, 3, 4, 5, 6);
241 Observable<Integer> reduced = source.reduce(new BiFunction<Integer, Integer, Integer>() {
242 @Override
243 public Integer apply(Integer i1, Integer i2) {
244 return i1 + i2;
245 }
246 }).toObservable();
247
248 Integer r = reduced.blockingFirst();
249 assertEquals(21, r.intValue());
250 }
251
252 @Test
253 public void single() {
254 Maybe<Integer> o = Observable.just(1).singleElement();
255
256 MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver();
257 o.subscribe(observer);
258
259 InOrder inOrder = inOrder(observer);
260 inOrder.verify(observer, times(1)).onSuccess(1);
261 inOrder.verifyNoMoreInteractions();
262 }
263
264 @Test
265 public void singleWithTooManyElements() {
266 Maybe<Integer> o = Observable.just(1, 2).singleElement();
267
268 MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver();
269 o.subscribe(observer);
270
271 InOrder inOrder = inOrder(observer);
272 inOrder.verify(observer, times(1)).onError(
273 isA(IllegalArgumentException.class));
274 inOrder.verifyNoMoreInteractions();
275 }
276
277 @Test
278 public void singleWithEmpty() {
279 Maybe<Integer> o = Observable.<Integer> empty().singleElement();
280
281 MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver();
282 o.subscribe(observer);
283
284 InOrder inOrder = inOrder(observer);
285 inOrder.verify(observer).onComplete();
286 inOrder.verify(observer, never()).onError(any(Throwable.class));
287 inOrder.verifyNoMoreInteractions();
288 }
289
290 @Test
291 public void singleWithPredicate() {
292 Maybe<Integer> o = Observable.just(1, 2)
293 .filter(
294 new Predicate<Integer>() {
295
296 @Override
297 public boolean test(Integer t1) {
298 return t1 % 2 == 0;
299 }
300 })
301 .singleElement();
302
303 MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver();
304 o.subscribe(observer);
305
306 InOrder inOrder = inOrder(observer);
307 inOrder.verify(observer, times(1)).onSuccess(2);
308 inOrder.verifyNoMoreInteractions();
309 }
310
311 @Test
312 public void singleWithPredicateAndTooManyElements() {
313 Maybe<Integer> o = Observable.just(1, 2, 3, 4)
314 .filter(
315 new Predicate<Integer>() {
316
317 @Override
318 public boolean test(Integer t1) {
319 return t1 % 2 == 0;
320 }
321 })
322 .singleElement();
323
324 MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver();
325 o.subscribe(observer);
326
327 InOrder inOrder = inOrder(observer);
328 inOrder.verify(observer, times(1)).onError(
329 isA(IllegalArgumentException.class));
330 inOrder.verifyNoMoreInteractions();
331 }
332
333 @Test
334 public void singleWithPredicateAndEmpty() {
335 Maybe<Integer> o = Observable.just(1)
336 .filter(
337 new Predicate<Integer>() {
338
339 @Override
340 public boolean test(Integer t1) {
341 return t1 % 2 == 0;
342 }
343 })
344 .singleElement();
345 MaybeObserver<Integer> observer = TestHelper.mockMaybeObserver();
346 o.subscribe(observer);
347
348 InOrder inOrder = inOrder(observer);
349 inOrder.verify(observer).onComplete();
350 inOrder.verify(observer, never()).onError(any(Throwable.class));
351 inOrder.verifyNoMoreInteractions();
352 }
353
354 @Test
355 public void singleOrDefault() {
356 Single<Integer> o = Observable.just(1).single(2);
357
358 SingleObserver<Integer> observer = TestHelper.mockSingleObserver();
359 o.subscribe(observer);
360
361 InOrder inOrder = inOrder(observer);
362 inOrder.verify(observer, times(1)).onSuccess(1);
363 inOrder.verifyNoMoreInteractions();
364 }
365
366 @Test
367 public void singleOrDefaultWithTooManyElements() {
368 Single<Integer> o = Observable.just(1, 2).single(3);
369
370 SingleObserver<Integer> observer = TestHelper.mockSingleObserver();
371 o.subscribe(observer);
372
373 InOrder inOrder = inOrder(observer);
374 inOrder.verify(observer, times(1)).onError(
375 isA(IllegalArgumentException.class));
376 inOrder.verifyNoMoreInteractions();
377 }
378
379 @Test
380 public void singleOrDefaultWithEmpty() {
381 Single<Integer> o = Observable.<Integer> empty()
382 .single(1);
383
384 SingleObserver<Integer> observer = TestHelper.mockSingleObserver();
385 o.subscribe(observer);
386
387 InOrder inOrder = inOrder(observer);
388 inOrder.verify(observer, times(1)).onSuccess(1);
389 inOrder.verifyNoMoreInteractions();
390 }
391
392 @Test
393 public void singleOrDefaultWithPredicate() {
394 Single<Integer> o = Observable.just(1, 2)
395 .filter(new Predicate<Integer>() {
396 @Override
397 public boolean test(Integer t1) {
398 return t1 % 2 == 0;
399 }
400 })
401 .single(4);
402
403 SingleObserver<Integer> observer = TestHelper.mockSingleObserver();
404 o.subscribe(observer);
405
406 InOrder inOrder = inOrder(observer);
407 inOrder.verify(observer, times(1)).onSuccess(2);
408 inOrder.verifyNoMoreInteractions();
409 }
410
411 @Test
412 public void singleOrDefaultWithPredicateAndTooManyElements() {
413 Single<Integer> o = Observable.just(1, 2, 3, 4)
414 .filter(new Predicate<Integer>() {
415 @Override
416 public boolean test(Integer t1) {
417 return t1 % 2 == 0;
418 }
419 })
420 .single(6);
421
422 SingleObserver<Integer> observer = TestHelper.mockSingleObserver();
423 o.subscribe(observer);
424
425 InOrder inOrder = inOrder(observer);
426 inOrder.verify(observer, times(1)).onError(
427 isA(IllegalArgumentException.class));
428 inOrder.verifyNoMoreInteractions();
429 }
430
431 @Test
432 public void singleOrDefaultWithPredicateAndEmpty() {
433 Single<Integer> o = Observable.just(1)
434 .filter(new Predicate<Integer>() {
435 @Override
436 public boolean test(Integer t1) {
437 return t1 % 2 == 0;
438 }
439 })
440 .single(2);
441
442 SingleObserver<Integer> observer = TestHelper.mockSingleObserver();
443 o.subscribe(observer);
444
445 InOrder inOrder = inOrder(observer);
446 inOrder.verify(observer, times(1)).onSuccess(2);
447 inOrder.verifyNoMoreInteractions();
448 }
449
450 @Test
451 public void issue1527() throws InterruptedException {
452 //https://github.com/ReactiveX/RxJava/pull/1527
453 Observable<Integer> source = Observable.just(1, 2, 3, 4, 5, 6);
454 Maybe<Integer> reduced = source.reduce(new BiFunction<Integer, Integer, Integer>() {
455 @Override
456 public Integer apply(Integer i1, Integer i2) {
457 return i1 + i2;
458 }
459 });
460
461 Integer r = reduced.blockingGet();
462 assertEquals(21, r.intValue());
463 }
464
465 @Test
466 public void singleElementOperatorDoNotSwallowExceptionWhenDone() {
467 final Throwable exception = new RuntimeException("some error");
468 final AtomicReference<Throwable> error = new AtomicReference<>();
469
470 try {
471 RxJavaPlugins.setErrorHandler(new Consumer<Throwable>() {
472 @Override public void accept(final Throwable throwable) throws Exception {
473 error.set(throwable);
474 }
475 });
476
477 Observable.unsafeCreate(new ObservableSource<Integer>() {
478 @Override public void subscribe(final Observer<? super Integer> observer) {
479 observer.onComplete();
480 observer.onError(exception);
481 }
482 }).singleElement().test().assertComplete();
483
484 assertSame(exception, error.get().getCause());
485 } finally {
486 RxJavaPlugins.reset();
487 }
488 }
489
490 @Test
491 public void singleOrErrorNoElement() {
492 Observable.empty()
493 .singleOrError()
494 .test()
495 .assertNoValues()
496 .assertError(NoSuchElementException.class);
497 }
498
499 @Test
500 public void singleOrErrorOneElement() {
501 Observable.just(1)
502 .singleOrError()
503 .test()
504 .assertNoErrors()
505 .assertValue(1);
506 }
507
508 @Test
509 public void singleOrErrorMultipleElements() {
510 Observable.just(1, 2, 3)
511 .singleOrError()
512 .test()
513 .assertNoValues()
514 .assertError(IllegalArgumentException.class);
515 }
516
517 @Test
518 public void singleOrErrorError() {
519 Observable.error(new RuntimeException("error"))
520 .singleOrError()
521 .to(TestHelper.testConsumer())
522 .assertNoValues()
523 .assertErrorMessage("error")
524 .assertError(RuntimeException.class);
525 }
526
527 @Test
528 public void badSource() {
529 TestHelper.checkBadSourceObservable(new Function<Observable<Object>, Object>() {
530 @Override
531 public Object apply(Observable<Object> o) throws Exception {
532 return o.singleOrError();
533 }
534 }, false, 1, 1, 1);
535
536 TestHelper.checkBadSourceObservable(new Function<Observable<Object>, Object>() {
537 @Override
538 public Object apply(Observable<Object> o) throws Exception {
539 return o.singleElement();
540 }
541 }, false, 1, 1, 1);
542 }
543
544 @Test
545 public void doubleOnSubscribe() {
546 TestHelper.checkDoubleOnSubscribeObservableToSingle(new Function<Observable<Object>, SingleSource<Object>>() {
547 @Override
548 public SingleSource<Object> apply(Observable<Object> o) throws Exception {
549 return o.singleOrError();
550 }
551 });
552
553 TestHelper.checkDoubleOnSubscribeObservableToMaybe(new Function<Observable<Object>, MaybeSource<Object>>() {
554 @Override
555 public MaybeSource<Object> apply(Observable<Object> o) throws Exception {
556 return o.singleElement();
557 }
558 });
559 }
560
561 @Test
562 public void singleOrError() {
563 Observable.empty()
564 .singleOrError()
565 .toObservable()
566 .test()
567 .assertFailure(NoSuchElementException.class);
568 }
569 }