Debian Codegraph @

src/test/java/io/reactivex/rxjava3/observable/ObservableTest.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.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.*;
21 import java.util.concurrent.*;
22 import java.util.concurrent.atomic.*;
23
24 import org.junit.*;
25 import org.mockito.InOrder;
26
27 import io.reactivex.rxjava3.core.*;
28 import io.reactivex.rxjava3.core.Observable;
29 import io.reactivex.rxjava3.core.Observer;
30 import io.reactivex.rxjava3.disposables.*;
31 import io.reactivex.rxjava3.functions.*;
32 import io.reactivex.rxjava3.internal.functions.Functions;
33 import io.reactivex.rxjava3.observables.ConnectableObservable;
34 import io.reactivex.rxjava3.observers.*;
35 import io.reactivex.rxjava3.schedulers.*;
36 import io.reactivex.rxjava3.subjects.*;
37 import io.reactivex.rxjava3.testsupport.*;
38
39 public class ObservableTest extends RxJavaTest {
40
41 Observer<Number> w;
42 SingleObserver<Number> wo;
43 MaybeObserver<Number> wm;
44
45 private static final Predicate<Integer> IS_EVEN = new Predicate<Integer>() {
46 @Override
47 public boolean test(Integer v) {
48 return v % 2 == 0;
49 }
50 };
51
52 @Before
53 public void before() {
54 w = TestHelper.mockObserver();
55 wo = TestHelper.mockSingleObserver();
56 wm = TestHelper.mockMaybeObserver();
57 }
58
59 @Test
60 public void fromArray() {
61 String[] items = new String[] { "one", "two", "three" };
62 assertEquals((Long)3L, Observable.fromArray(items).count().blockingGet());
63 assertEquals("two", Observable.fromArray(items).skip(1).take(1).blockingSingle());
64 assertEquals("three", Observable.fromArray(items).takeLast(1).blockingSingle());
65 }
66
67 @Test
68 public void fromIterable() {
69 ArrayList<String> items = new ArrayList<>();
70 items.add("one");
71 items.add("two");
72 items.add("three");
73
74 assertEquals((Long)3L, Observable.fromIterable(items).count().blockingGet());
75 assertEquals("two", Observable.fromIterable(items).skip(1).take(1).blockingSingle());
76 assertEquals("three", Observable.fromIterable(items).takeLast(1).blockingSingle());
77 }
78
79 @Test
80 public void fromArityArgs3() {
81 Observable<String> items = Observable.just("one", "two", "three");
82
83 assertEquals((Long)3L, items.count().blockingGet());
84 assertEquals("two", items.skip(1).take(1).blockingSingle());
85 assertEquals("three", items.takeLast(1).blockingSingle());
86 }
87
88 @Test
89 public void fromArityArgs1() {
90 Observable<String> items = Observable.just("one");
91
92 assertEquals((Long)1L, items.count().blockingGet());
93 assertEquals("one", items.takeLast(1).blockingSingle());
94 }
95
96 @Test
97 public void create() {
98
99 Observable<String> o = Observable.just("one", "two", "three");
100
101 Observer<String> observer = TestHelper.mockObserver();
102
103 o.subscribe(observer);
104
105 verify(observer, times(1)).onNext("one");
106 verify(observer, times(1)).onNext("two");
107 verify(observer, times(1)).onNext("three");
108 verify(observer, never()).onError(any(Throwable.class));
109 verify(observer, times(1)).onComplete();
110 }
111
112 @Test
113 public void countAFewItemsObservable() {
114 Observable<String> o = Observable.just("a", "b", "c", "d");
115
116 o.count().toObservable().subscribe(w);
117
118 // we should be called only once
119 verify(w, times(1)).onNext(anyLong());
120 verify(w).onNext(4L);
121 verify(w, never()).onError(any(Throwable.class));
122 verify(w, times(1)).onComplete();
123 }
124
125 @Test
126 public void countZeroItemsObservable() {
127 Observable<String> o = Observable.empty();
128 o.count().toObservable().subscribe(w);
129 // we should be called only once
130 verify(w, times(1)).onNext(anyLong());
131 verify(w).onNext(0L);
132 verify(w, never()).onError(any(Throwable.class));
133 verify(w, times(1)).onComplete();
134 }
135
136 @Test
137 public void countErrorObservable() {
138 Observable<String> o = Observable.error(new Supplier<Throwable>() {
139 @Override
140 public Throwable get() {
141 return new RuntimeException();
142 }
143 });
144
145 o.count().toObservable().subscribe(w);
146 verify(w, never()).onNext(anyInt());
147 verify(w, never()).onComplete();
148 verify(w, times(1)).onError(any(RuntimeException.class));
149 }
150
151 @Test
152 public void countAFewItems() {
153 Observable<String> o = Observable.just("a", "b", "c", "d");
154
155 o.count().subscribe(wo);
156
157 // we should be called only once
158 verify(wo, times(1)).onSuccess(anyLong());
159 verify(wo).onSuccess(4L);
160 verify(wo, never()).onError(any(Throwable.class));
161 }
162
163 @Test
164 public void countZeroItems() {
165 Observable<String> o = Observable.empty();
166 o.count().subscribe(wo);
167 // we should be called only once
168 verify(wo, times(1)).onSuccess(anyLong());
169 verify(wo).onSuccess(0L);
170 verify(wo, never()).onError(any(Throwable.class));
171 }
172
173 @Test
174 public void countError() {
175 Observable<String> o = Observable.error(new Supplier<Throwable>() {
176 @Override
177 public Throwable get() {
178 return new RuntimeException();
179 }
180 });
181
182 o.count().subscribe(wo);
183 verify(wo, never()).onSuccess(anyInt());
184 verify(wo, times(1)).onError(any(RuntimeException.class));
185 }
186
187 @Test
188 public void takeFirstWithPredicateOfSome() {
189 Observable<Integer> o = Observable.just(1, 3, 5, 4, 6, 3);
190 o.filter(IS_EVEN).take(1).subscribe(w);
191 verify(w, times(1)).onNext(anyInt());
192 verify(w).onNext(4);
193 verify(w, times(1)).onComplete();
194 verify(w, never()).onError(any(Throwable.class));
195 }
196
197 @Test
198 public void takeFirstWithPredicateOfNoneMatchingThePredicate() {
199 Observable<Integer> o = Observable.just(1, 3, 5, 7, 9, 7, 5, 3, 1);
200 o.filter(IS_EVEN).take(1).subscribe(w);
201 verify(w, never()).onNext(anyInt());
202 verify(w, times(1)).onComplete();
203 verify(w, never()).onError(any(Throwable.class));
204 }
205
206 @Test
207 public void takeFirstOfSome() {
208 Observable<Integer> o = Observable.just(1, 2, 3);
209 o.take(1).subscribe(w);
210 verify(w, times(1)).onNext(anyInt());
211 verify(w).onNext(1);
212 verify(w, times(1)).onComplete();
213 verify(w, never()).onError(any(Throwable.class));
214 }
215
216 @Test
217 public void takeFirstOfNone() {
218 Observable<Integer> o = Observable.empty();
219 o.take(1).subscribe(w);
220 verify(w, never()).onNext(anyInt());
221 verify(w, times(1)).onComplete();
222 verify(w, never()).onError(any(Throwable.class));
223 }
224
225 @Test
226 public void firstOfNone() {
227 Observable<Integer> o = Observable.empty();
228 o.firstElement().subscribe(wm);
229 verify(wm, never()).onSuccess(anyInt());
230 verify(wm).onComplete();
231 verify(wm, never()).onError(any(Throwable.class));
232 }
233
234 @Test
235 public void firstWithPredicateOfNoneMatchingThePredicate() {
236 Observable<Integer> o = Observable.just(1, 3, 5, 7, 9, 7, 5, 3, 1);
237 o.filter(IS_EVEN).firstElement().subscribe(wm);
238 verify(wm, never()).onSuccess(anyInt());
239 verify(wm).onComplete();
240 verify(wm, never()).onError(any(Throwable.class));
241 }
242
243 @Test
244 public void reduce() {
245 Observable<Integer> o = Observable.just(1, 2, 3, 4);
246 o.reduce(new BiFunction<Integer, Integer, Integer>() {
247 @Override
248 public Integer apply(Integer t1, Integer t2) {
249 return t1 + t2;
250 }
251 })
252 .subscribe(wm);
253 // we should be called only once
254 verify(wm, times(1)).onSuccess(anyInt());
255 verify(wm).onSuccess(10);
256 verify(wm, never()).onError(any(Throwable.class));
257 verify(wm, never()).onComplete();
258 }
259
260 @Test
261 public void reduceObservable() {
262 Observable<Integer> o = Observable.just(1, 2, 3, 4);
263 o.reduce(new BiFunction<Integer, Integer, Integer>() {
264 @Override
265 public Integer apply(Integer t1, Integer t2) {
266 return t1 + t2;
267 }
268 })
269 .toObservable()
270 .subscribe(w);
271 // we should be called only once
272 verify(w, times(1)).onNext(anyInt());
273 verify(w).onNext(10);
274 verify(w, never()).onError(any(Throwable.class));
275 verify(w).onComplete();
276 }
277
278 @Test
279 public void reduceWithEmptyObservable() {
280 Observable<Integer> o = Observable.range(1, 0);
281 o.reduce(new BiFunction<Integer, Integer, Integer>() {
282 @Override
283 public Integer apply(Integer t1, Integer t2) {
284 return t1 + t2;
285 }
286 })
287 .toObservable()
288 .test()
289 .assertResult();
290 }
291
292 /**
293 * A reduce on an empty Observable and a seed should just pass the seed through.
294 *
295 * This is confirmed at https://github.com/ReactiveX/RxJava/issues/423#issuecomment-27642456
296 */
297 @Test
298 public void reduceWithEmptyObservableAndSeed() {
299 Observable<Integer> o = Observable.range(1, 0);
300 int value = o.reduce(1, new BiFunction<Integer, Integer, Integer>() {
301 @Override
302 public Integer apply(Integer t1, Integer t2) {
303 return t1 + t2;
304 }
305 })
306 .blockingGet();
307
308 assertEquals(1, value);
309 }
310
311 @Test
312 public void reduceWithInitialValue() {
313 Observable<Integer> o = Observable.just(1, 2, 3, 4);
314 o.reduce(50, new BiFunction<Integer, Integer, Integer>() {
315 @Override
316 public Integer apply(Integer t1, Integer t2) {
317 return t1 + t2;
318 }
319 })
320 .subscribe(wo);
321 // we should be called only once
322 verify(wo, times(1)).onSuccess(anyInt());
323 verify(wo).onSuccess(60);
324 verify(wo, never()).onError(any(Throwable.class));
325 }
326
327 @Test
328 public void reduceWithInitialValueObservable() {
329 Observable<Integer> o = Observable.just(1, 2, 3, 4);
330 o.reduce(50, new BiFunction<Integer, Integer, Integer>() {
331 @Override
332 public Integer apply(Integer t1, Integer t2) {
333 return t1 + t2;
334 }
335 })
336 .toObservable()
337 .subscribe(w);
338 // we should be called only once
339 verify(w, times(1)).onNext(anyInt());
340 verify(w).onNext(60);
341 }
342
343 @Test
344 public void materializeDematerializeChaining() {
345 Observable<Integer> obs = Observable.just(1);
346 Observable<Integer> chained = obs.materialize()
347 .dematerialize(Functions.<Notification<Integer>>identity());
348
349 Observer<Integer> observer = TestHelper.mockObserver();
350
351 chained.subscribe(observer);
352
353 verify(observer, times(1)).onNext(1);
354 verify(observer, times(1)).onComplete();
355 verify(observer, times(0)).onError(any(Throwable.class));
356 }
357
358 /**
359 * The error from the user provided Observer is not handled by the subscribe method try/catch.
360 *
361 * It is handled by the AtomicObserver that wraps the provided Observer.
362 *
363 * Result: Passes (if AtomicObserver functionality exists)
364 * @throws InterruptedException if the test is interrupted
365 */
366 @Test
367 public void customObservableWithErrorInObserverAsynchronous() throws InterruptedException {
368 final CountDownLatch latch = new CountDownLatch(1);
369 final AtomicInteger count = new AtomicInteger();
370 final AtomicReference<Throwable> error = new AtomicReference<>();
371
372 // FIXME custom built???
373 Observable.just("1", "2", "three", "4")
374 .subscribeOn(Schedulers.newThread())
375 .safeSubscribe(new DefaultObserver<String>() {
376 @Override
377 public void onComplete() {
378 System.out.println("completed");
379 latch.countDown();
380 }
381
382 @Override
383 public void onError(Throwable e) {
384 error.set(e);
385 System.out.println("error");
386 e.printStackTrace();
387 latch.countDown();
388 }
389
390 @Override
391 public void onNext(String v) {
392 int num = Integer.parseInt(v);
393 System.out.println(num);
394 // doSomething(num);
395 count.incrementAndGet();
396 }
397
398 });
399
400 // wait for async sequence to complete
401 latch.await();
402
403 assertEquals(2, count.get());
404 assertNotNull(error.get());
405 if (!(error.get() instanceof NumberFormatException)) {
406 fail("It should be a NumberFormatException");
407 }
408 }
409
410 /**
411 * The error from the user provided Observer is handled by the subscribe try/catch because this is synchronous.
412 *
413 * Result: Passes
414 */
415 @Test
416 public void customObservableWithErrorInObserverSynchronous() {
417 final AtomicInteger count = new AtomicInteger();
418 final AtomicReference<Throwable> error = new AtomicReference<>();
419
420 // FIXME custom built???
421 Observable.just("1", "2", "three", "4")
422 .safeSubscribe(new DefaultObserver<String>() {
423
424 @Override
425 public void onComplete() {
426 System.out.println("completed");
427 }
428
429 @Override
430 public void onError(Throwable e) {
431 error.set(e);
432 System.out.println("error");
433 e.printStackTrace();
434 }
435
436 @Override
437 public void onNext(String v) {
438 int num = Integer.parseInt(v);
439 System.out.println(num);
440 // doSomething(num);
441 count.incrementAndGet();
442 }
443
444 });
445 assertEquals(2, count.get());
446 assertNotNull(error.get());
447 if (!(error.get() instanceof NumberFormatException)) {
448 fail("It should be a NumberFormatException");
449 }
450 }
451
452 /**
453 * The error from the user provided Observable is handled by the subscribe try/catch because this is synchronous.
454 *
455 *
456 * Result: Passes
457 */
458 @Test
459 public void customObservableWithErrorInObservableSynchronous() {
460 final AtomicInteger count = new AtomicInteger();
461 final AtomicReference<Throwable> error = new AtomicReference<>();
462 // FIXME custom built???
463 Observable.just("1", "2").concatWith(Observable.<String>error(new Supplier<Throwable>() {
464 @Override
465 public Throwable get() {
466 return new NumberFormatException();
467 }
468 }))
469 .subscribe(new DefaultObserver<String>() {
470
471 @Override
472 public void onComplete() {
473 System.out.println("completed");
474 }
475
476 @Override
477 public void onError(Throwable e) {
478 error.set(e);
479 System.out.println("error");
480 e.printStackTrace();
481 }
482
483 @Override
484 public void onNext(String v) {
485 System.out.println(v);
486 count.incrementAndGet();
487 }
488
489 });
490 assertEquals(2, count.get());
491 assertNotNull(error.get());
492 if (!(error.get() instanceof NumberFormatException)) {
493 fail("It should be a NumberFormatException");
494 }
495 }
496
497 @Test
498 public void publishLast() throws InterruptedException {
499 final AtomicInteger count = new AtomicInteger();
500 ConnectableObservable<String> connectable = Observable.<String>unsafeCreate(new ObservableSource<String>() {
501 @Override
502 public void subscribe(final Observer<? super String> observer) {
503 observer.onSubscribe(Disposable.empty());
504 count.incrementAndGet();
505 new Thread(new Runnable() {
506 @Override
507 public void run() {
508 observer.onNext("first");
509 observer.onNext("last");
510 observer.onComplete();
511 }
512 }).start();
513 }
514 }).takeLast(1).publish();
515
516 // subscribe once
517 final CountDownLatch latch = new CountDownLatch(1);
518 connectable.subscribe(new Consumer<String>() {
519 @Override
520 public void accept(String value) {
521 assertEquals("last", value);
522 latch.countDown();
523 }
524 });
525
526 // subscribe twice
527 connectable.subscribe();
528
529 Disposable subscription = connectable.connect();
530 assertTrue(latch.await(1000, TimeUnit.MILLISECONDS));
531 assertEquals(1, count.get());
532 subscription.dispose();
533 }
534
535 @Test
536 public void replay() throws InterruptedException {
537 final AtomicInteger counter = new AtomicInteger();
538 ConnectableObservable<String> o = Observable.<String>unsafeCreate(new ObservableSource<String>() {
539 @Override
540 public void subscribe(final Observer<? super String> observer) {
541 observer.onSubscribe(Disposable.empty());
542 new Thread(new Runnable() {
543
544 @Override
545 public void run() {
546 counter.incrementAndGet();
547 observer.onNext("one");
548 observer.onComplete();
549 }
550 }).start();
551 }
552 }).replay();
553
554 // we connect immediately and it will emit the value
555 Disposable connection = o.connect();
556 try {
557
558 // we then expect the following 2 subscriptions to get that same value
559 final CountDownLatch latch = new CountDownLatch(2);
560
561 // subscribe once
562 o.subscribe(new Consumer<String>() {
563 @Override
564 public void accept(String v) {
565 assertEquals("one", v);
566 latch.countDown();
567 }
568 });
569
570 // subscribe again
571 o.subscribe(new Consumer<String>() {
572 @Override
573 public void accept(String v) {
574 assertEquals("one", v);
575 latch.countDown();
576 }
577 });
578
579 if (!latch.await(1000, TimeUnit.MILLISECONDS)) {
580 fail("subscriptions did not receive values");
581 }
582 assertEquals(1, counter.get());
583 } finally {
584 connection.dispose();
585 }
586 }
587
588 @Test
589 public void cache() throws InterruptedException {
590 final AtomicInteger counter = new AtomicInteger();
591 Observable<String> o = Observable.<String>unsafeCreate(new ObservableSource<String>() {
592 @Override
593 public void subscribe(final Observer<? super String> observer) {
594 observer.onSubscribe(Disposable.empty());
595 new Thread(new Runnable() {
596 @Override
597 public void run() {
598 counter.incrementAndGet();
599 observer.onNext("one");
600 observer.onComplete();
601 }
602 }).start();
603 }
604 }).cache();
605
606 // we then expect the following 2 subscriptions to get that same value
607 final CountDownLatch latch = new CountDownLatch(2);
608
609 // subscribe once
610 o.subscribe(new Consumer<String>() {
611 @Override
612 public void accept(String v) {
613 assertEquals("one", v);
614 latch.countDown();
615 }
616 });
617
618 // subscribe again
619 o.subscribe(new Consumer<String>() {
620 @Override
621 public void accept(String v) {
622 assertEquals("one", v);
623 latch.countDown();
624 }
625 });
626
627 if (!latch.await(1000, TimeUnit.MILLISECONDS)) {
628 fail("subscriptions did not receive values");
629 }
630 assertEquals(1, counter.get());
631 }
632
633 @Test
634 public void cacheWithCapacity() throws InterruptedException {
635 final AtomicInteger counter = new AtomicInteger();
636 Observable<String> o = Observable.<String>unsafeCreate(new ObservableSource<String>() {
637 @Override
638 public void subscribe(final Observer<? super String> observer) {
639 observer.onSubscribe(Disposable.empty());
640 new Thread(new Runnable() {
641 @Override
642 public void run() {
643 counter.incrementAndGet();
644 observer.onNext("one");
645 observer.onComplete();
646 }
647 }).start();
648 }
649 }).cacheWithInitialCapacity(1);
650
651 // we then expect the following 2 subscriptions to get that same value
652 final CountDownLatch latch = new CountDownLatch(2);
653
654 // subscribe once
655 o.subscribe(new Consumer<String>() {
656 @Override
657 public void accept(String v) {
658 assertEquals("one", v);
659 latch.countDown();
660 }
661 });
662
663 // subscribe again
664 o.subscribe(new Consumer<String>() {
665 @Override
666 public void accept(String v) {
667 assertEquals("one", v);
668 latch.countDown();
669 }
670 });
671
672 if (!latch.await(1000, TimeUnit.MILLISECONDS)) {
673 fail("subscriptions did not receive values");
674 }
675 assertEquals(1, counter.get());
676 }
677
678 @Test
679 public void takeWithErrorInObserver() {
680 final AtomicInteger count = new AtomicInteger();
681 final AtomicReference<Throwable> error = new AtomicReference<>();
682 Observable.just("1", "2", "three", "4").take(3)
683 .safeSubscribe(new DefaultObserver<String>() {
684
685 @Override
686 public void onComplete() {
687 System.out.println("completed");
688 }
689
690 @Override
691 public void onError(Throwable e) {
692 error.set(e);
693 System.out.println("error");
694 e.printStackTrace();
695 }
696
697 @Override
698 public void onNext(String v) {
699 int num = Integer.parseInt(v);
700 System.out.println(num);
701 // doSomething(num);
702 count.incrementAndGet();
703 }
704
705 });
706 assertEquals(2, count.get());
707 assertNotNull(error.get());
708 if (!(error.get() instanceof NumberFormatException)) {
709 fail("It should be a NumberFormatException");
710 }
711 }
712
713 @Test
714 public void ofType() {
715 Observable<String> o = Observable.just(1, "abc", false, 2L).ofType(String.class);
716
717 Observer<Object> observer = TestHelper.mockObserver();
718
719 o.subscribe(observer);
720
721 verify(observer, never()).onNext(1);
722 verify(observer, times(1)).onNext("abc");
723 verify(observer, never()).onNext(false);
724 verify(observer, never()).onNext(2L);
725 verify(observer, never()).onError(
726 any(Throwable.class));
727 verify(observer, times(1)).onComplete();
728 }
729
730 @Test
731 public void ofTypeWithPolymorphism() {
732 ArrayList<Integer> l1 = new ArrayList<>();
733 l1.add(1);
734 LinkedList<Integer> l2 = new LinkedList<>();
735 l2.add(2);
736
737 @SuppressWarnings("rawtypes")
738 Observable<List> o = Observable.<Object> just(l1, l2, "123").ofType(List.class);
739
740 Observer<Object> observer = TestHelper.mockObserver();
741
742 o.subscribe(observer);
743
744 verify(observer, times(1)).onNext(l1);
745 verify(observer, times(1)).onNext(l2);
746 verify(observer, never()).onNext("123");
747 verify(observer, never()).onError(
748 any(Throwable.class));
749 verify(observer, times(1)).onComplete();
750 }
751
752 @Test
753 public void containsObservable() {
754 Observable<Boolean> o = Observable.just("a", "b", "c").contains("b").toObservable();
755
756 Observer<Boolean> observer = TestHelper.mockObserver();
757
758 o.subscribe(observer);
759
760 verify(observer, times(1)).onNext(true);
761 verify(observer, never()).onNext(false);
762 verify(observer, never()).onError(
763 any(Throwable.class));
764 verify(observer, times(1)).onComplete();
765 }
766
767 @Test
768 public void containsWithInexistenceObservable() {
769 Observable<Boolean> o = Observable.just("a", "b").contains("c").toObservable();
770
771 Observer<Object> observer = TestHelper.mockObserver();
772
773 o.subscribe(observer);
774
775 verify(observer, times(1)).onNext(false);
776 verify(observer, never()).onNext(true);
777 verify(observer, never()).onError(
778 any(Throwable.class));
779 verify(observer, times(1)).onComplete();
780 }
781
782 @Test
783 public void containsWithEmptyObservableObservable() {
784 Observable<Boolean> o = Observable.<String> empty().contains("a").toObservable();
785
786 Observer<Object> observer = TestHelper.mockObserver();
787
788 o.subscribe(observer);
789
790 verify(observer, times(1)).onNext(false);
791 verify(observer, never()).onNext(true);
792 verify(observer, never()).onError(
793 any(Throwable.class));
794 verify(observer, times(1)).onComplete();
795 }
796
797 @Test
798 public void contains() {
799 Single<Boolean> o = Observable.just("a", "b", "c").contains("b"); // FIXME nulls not allowed, changed to "c"
800
801 SingleObserver<Boolean> observer = TestHelper.mockSingleObserver();
802
803 o.subscribe(observer);
804
805 verify(observer, times(1)).onSuccess(true);
806 verify(observer, never()).onSuccess(false);
807 verify(observer, never()).onError(
808 any(Throwable.class));
809 }
810
811 @Test
812 public void containsWithInexistence() {
813 Single<Boolean> o = Observable.just("a", "b").contains("c"); // FIXME null values are not allowed, removed
814
815 SingleObserver<Object> observer = TestHelper.mockSingleObserver();
816
817 o.subscribe(observer);
818
819 verify(observer, times(1)).onSuccess(false);
820 verify(observer, never()).onSuccess(true);
821 verify(observer, never()).onError(
822 any(Throwable.class));
823 }
824
825 @Test
826 public void containsWithEmptyObservable() {
827 Single<Boolean> o = Observable.<String> empty().contains("a");
828
829 SingleObserver<Object> observer = TestHelper.mockSingleObserver();
830
831 o.subscribe(observer);
832
833 verify(observer, times(1)).onSuccess(false);
834 verify(observer, never()).onSuccess(true);
835 verify(observer, never()).onError(
836 any(Throwable.class));
837 }
838
839 @Test
840 public void ignoreElements() {
841 Completable o = Observable.just(1, 2, 3).ignoreElements();
842
843 CompletableObserver observer = TestHelper.mockCompletableObserver();
844
845 o.subscribe(observer);
846
847 verify(observer, never()).onError(any(Throwable.class));
848 verify(observer, times(1)).onComplete();
849 }
850
851 @Test
852 public void ignoreElementsObservable() {
853 Observable<Integer> o = Observable.just(1, 2, 3).ignoreElements().toObservable();
854
855 Observer<Object> observer = TestHelper.mockObserver();
856
857 o.subscribe(observer);
858
859 verify(observer, never()).onNext(any(Integer.class));
860 verify(observer, never()).onError(any(Throwable.class));
861 verify(observer, times(1)).onComplete();
862 }
863
864 @Test
865 public void justWithScheduler() {
866 TestScheduler scheduler = new TestScheduler();
867 Observable<Integer> o = Observable.fromArray(1, 2).subscribeOn(scheduler);
868
869 Observer<Integer> observer = TestHelper.mockObserver();
870
871 o.subscribe(observer);
872
873 scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS);
874
875 InOrder inOrder = inOrder(observer);
876 inOrder.verify(observer, times(1)).onNext(1);
877 inOrder.verify(observer, times(1)).onNext(2);
878 inOrder.verify(observer, times(1)).onComplete();
879 inOrder.verifyNoMoreInteractions();
880 }
881
882 @Test
883 public void startWithWithScheduler() {
884 TestScheduler scheduler = new TestScheduler();
885 Observable<Integer> o = Observable.just(3, 4).startWithIterable(Arrays.asList(1, 2)).subscribeOn(scheduler);
886
887 Observer<Integer> observer = TestHelper.mockObserver();
888
889 o.subscribe(observer);
890
891 scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS);
892
893 InOrder inOrder = inOrder(observer);
894 inOrder.verify(observer, times(1)).onNext(1);
895 inOrder.verify(observer, times(1)).onNext(2);
896 inOrder.verify(observer, times(1)).onNext(3);
897 inOrder.verify(observer, times(1)).onNext(4);
898 inOrder.verify(observer, times(1)).onComplete();
899 inOrder.verifyNoMoreInteractions();
900 }
901
902 @Test
903 public void rangeWithScheduler() {
904 TestScheduler scheduler = new TestScheduler();
905 Observable<Integer> o = Observable.range(3, 4).subscribeOn(scheduler);
906
907 Observer<Integer> observer = TestHelper.mockObserver();
908
909 o.subscribe(observer);
910
911 scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS);
912
913 InOrder inOrder = inOrder(observer);
914 inOrder.verify(observer, times(1)).onNext(3);
915 inOrder.verify(observer, times(1)).onNext(4);
916 inOrder.verify(observer, times(1)).onNext(5);
917 inOrder.verify(observer, times(1)).onNext(6);
918 inOrder.verify(observer, times(1)).onComplete();
919 inOrder.verifyNoMoreInteractions();
920 }
921
922 @Test
923 public void mergeWith() {
924 TestObserver<Integer> to = new TestObserver<>();
925 Observable.just(1).mergeWith(Observable.just(2)).subscribe(to);
926 to.assertValues(1, 2);
927 }
928
929 @Test
930 public void concatWith() {
931 TestObserver<Integer> to = new TestObserver<>();
932 Observable.just(1).concatWith(Observable.just(2)).subscribe(to);
933 to.assertValues(1, 2);
934 }
935
936 @Test
937 public void ambWith() {
938 TestObserver<Integer> to = new TestObserver<>();
939 Observable.just(1).ambWith(Observable.just(2)).subscribe(to);
940 to.assertValue(1);
941 }
942
943 @Test
944 public void takeWhileToList() {
945 final int expectedCount = 3;
946 final AtomicInteger count = new AtomicInteger();
947 for (int i = 0; i < expectedCount; i++) {
948 Observable
949 .just(Boolean.TRUE, Boolean.FALSE)
950 .takeWhile(new Predicate<Boolean>() {
951 @Override
952 public boolean test(Boolean v) {
953 return v;
954 }
955 })
956 .toList()
957 .doOnSuccess(new Consumer<List<Boolean>>() {
958 @Override
959 public void accept(List<Boolean> booleans) {
960 count.incrementAndGet();
961 }
962 })
963 .subscribe();
964 }
965 assertEquals(expectedCount, count.get());
966 }
967
968 @Test
969 public void compose() {
970 TestObserverEx<String> to = new TestObserverEx<>();
971
972 Observable.just(1, 2, 3).compose(new ObservableTransformer<Integer, String>() {
973 @Override
974 public Observable<String> apply(Observable<Integer> t1) {
975 return t1.map(new Function<Integer, String>() {
976 @Override
977 public String apply(Integer v) {
978 return String.valueOf(v);
979 }
980 });
981 }
982 })
983 .subscribe(to);
984
985 to.assertTerminated();
986 to.assertNoErrors();
987 to.assertValues("1", "2", "3");
988 }
989
990 @Test
991 public void errorThrownIssue1685() {
992 Subject<Object> subject = ReplaySubject.create();
993
994 Observable.error(new RuntimeException("oops"))
995 .materialize()
996 .delay(1, TimeUnit.SECONDS)
997 .dematerialize(Functions.<Notification<Object>>identity())
998 .subscribe(subject);
999
1000 subject.subscribe();
1001 subject.materialize().blockingFirst();
1002
1003 System.out.println("Done");
1004 }
1005
1006 @Test
1007 public void emptyIdentity() {
1008 assertEquals(Observable.empty(), Observable.empty());
1009 }
1010
1011 @Test
1012 public void emptyIsEmpty() {
1013 Observable.<Integer>empty().subscribe(w);
1014
1015 verify(w).onComplete();
1016 verify(w, never()).onNext(any(Integer.class));
1017 verify(w, never()).onError(any(Throwable.class));
1018 }
1019
1020 // FIXME this test doesn't make sense
1021 // @Test // cf. https://github.com/ReactiveX/RxJava/issues/2599
1022 // public void testSubscribingSubscriberAsObserverMaintainsSubscriptionChain() {
1023 // TestObserver<Object> observer = new TestObserver<T>();
1024 // Subscription subscription = Observable.just("event").subscribe((Observer<Object>) observer);
1025 // subscription.unsubscribe();
1026 //
1027 // subscriber.assertUnsubscribed();
1028 // }
1029
1030 // FIXME subscribers can't throw
1031 // @Test(expected=OnErrorNotImplementedException.class)
1032 // public void testForEachWithError() {
1033 // Observable.error(new Exception("boo"))
1034 // //
1035 // .forEach(new Action1<Object>() {
1036 // @Override
1037 // public void call(Object t) {
1038 // //do nothing
1039 // }});
1040 // }
1041
1042 @Test
1043 public void extend() {
1044 final TestObserver<Object> to = new TestObserver<>();
1045 final Object value = new Object();
1046 Object returned = Observable.just(value).to(new ObservableConverter<Object, Object>() {
1047 @Override
1048 public Object apply(Observable<Object> onSubscribe) {
1049 onSubscribe.subscribe(to);
1050 to.assertNoErrors();
1051 to.assertComplete();
1052 to.assertValue(value);
1053 return to.values().get(0);
1054 }
1055 });
1056 assertSame(returned, value);
1057 }
1058
1059 @Test
1060 public void asExtend() {
1061 final TestObserver<Object> to = new TestObserver<>();
1062 final Object value = new Object();
1063 Object returned = Observable.just(value).to(new ObservableConverter<Object, Object>() {
1064 @Override
1065 public Object apply(Observable<Object> onSubscribe) {
1066 onSubscribe.subscribe(to);
1067 to.assertNoErrors();
1068 to.assertComplete();
1069 to.assertValue(value);
1070 return to.values().get(0);
1071 }
1072 });
1073 assertSame(returned, value);
1074 }
1075
1076 @Test
1077 public void as() {
1078 Observable.just(1).to(new ObservableConverter<Integer, Flowable<Integer>>() {
1079 @Override
1080 public Flowable<Integer> apply(Observable<Integer> v) {
1081 return v.toFlowable(BackpressureStrategy.MISSING);
1082 }
1083 })
1084 .test()
1085 .assertResult(1);
1086 }
1087
1088 @Test
1089 public void flatMap() {
1090 List<Integer> list = Observable.range(1, 5).flatMap(new Function<Integer, Observable<Integer>>() {
1091 @Override
1092 public Observable<Integer> apply(Integer v) {
1093 return Observable.range(v, 2);
1094 }
1095 }).toList().blockingGet();
1096
1097 Assert.assertEquals(Arrays.asList(1, 2, 2, 3, 3, 4, 4, 5, 5, 6), list);
1098 }
1099
1100 @Test
1101 public void singleDefault() {
1102 Observable.just(1).single(100).test().assertResult(1);
1103
1104 Observable.empty().single(100).test().assertResult(100);
1105 }
1106
1107 @Test
1108 public void singleDefaultObservable() {
1109 Observable.just(1).single(100).toObservable().test().assertResult(1);
1110
1111 Observable.empty().single(100).toObservable().test().assertResult(100);
1112 }
1113
1114 @Test
1115 public void zipIterableObject() {
1116 final List<Observable<Integer>> observables = Arrays.asList(Observable.just(1, 2, 3), Observable.just(1, 2, 3));
1117 Observable.zip(observables, new Function<Object[], Object>() {
1118 @Override
1119 public Object apply(Object[] o) throws Exception {
1120 int sum = 0;
1121 for (Object i : o) {
1122 sum += (Integer) i;
1123 }
1124 return sum;
1125 }
1126 }).test().assertResult(2, 4, 6);
1127 }
1128
1129 @Test
1130 public void combineLatestObject() {
1131 final List<Observable<Integer>> observables = Arrays.asList(Observable.just(1, 2, 3), Observable.just(1, 2, 3));
1132 Observable.combineLatest(observables, new Function<Object[], Object>() {
1133 @Override
1134 public Object apply(final Object[] o) throws Exception {
1135 int sum = 1;
1136 for (Object i : o) {
1137 sum *= (Integer) i;
1138 }
1139 return sum;
1140 }
1141 }).test().assertResult(3, 6, 9);
1142 }
1143 }