Debian Codegraph @

src/test/java/io/reactivex/rxjava3/observable/ObservableNullTests.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 java.lang.reflect.*;
17 import java.util.*;
18 import java.util.concurrent.*;
19
20 import org.junit.*;
21
22 import io.reactivex.rxjava3.core.*;
23 import io.reactivex.rxjava3.core.Observable;
24 import io.reactivex.rxjava3.core.Observer;
25 import io.reactivex.rxjava3.exceptions.TestException;
26 import io.reactivex.rxjava3.functions.*;
27 import io.reactivex.rxjava3.internal.functions.Functions;
28 import io.reactivex.rxjava3.observers.TestObserver;
29 import io.reactivex.rxjava3.schedulers.Schedulers;
30
31 /**
32 * Verifies the operators handle null values properly by emitting/throwing NullPointerExceptions.
33 */
34 public class ObservableNullTests extends RxJavaTest {
35
36 Observable<Integer> just1 = Observable.just(1);
37
38 //***********************************************************
39 // Static methods
40 //***********************************************************
41
42 @Test
43 public void ambIterableIteratorNull() {
44 Observable.amb(new Iterable<Observable<Object>>() {
45 @Override
46 public Iterator<Observable<Object>> iterator() {
47 return null;
48 }
49 }).test().assertError(NullPointerException.class);
50 }
51
52 @Test
53 public void ambIterableOneIsNull() {
54 Observable.amb(Arrays.asList(Observable.never(), null))
55 .test()
56 .assertError(NullPointerException.class);
57 }
58
59 @Test(expected = NullPointerException.class)
60 public void combineLatestIterableIteratorNull() {
61 Observable.combineLatest(new Iterable<Observable<Object>>() {
62 @Override
63 public Iterator<Observable<Object>> iterator() {
64 return null;
65 }
66 }, new Function<Object[], Object>() {
67 @Override
68 public Object apply(Object[] v) {
69 return 1;
70 }
71 }, 128).blockingLast();
72 }
73
74 @Test(expected = NullPointerException.class)
75 public void combineLatestIterableOneIsNull() {
76 Observable.combineLatest(Arrays.asList(Observable.never(), null), new Function<Object[], Object>() {
77 @Override
78 public Object apply(Object[] v) {
79 return 1;
80 }
81 }, 128).blockingLast();
82 }
83
84 @Test(expected = NullPointerException.class)
85 public void combineLatestIterableFunctionReturnsNull() {
86 Observable.combineLatest(Arrays.asList(just1), new Function<Object[], Object>() {
87 @Override
88 public Object apply(Object[] v) {
89 return null;
90 }
91 }, 128).blockingLast();
92 }
93
94 @Test(expected = NullPointerException.class)
95 public void combineLatestDelayErrorIterableIteratorNull() {
96 Observable.combineLatestDelayError(new Iterable<Observable<Object>>() {
97 @Override
98 public Iterator<Observable<Object>> iterator() {
99 return null;
100 }
101 }, new Function<Object[], Object>() {
102 @Override
103 public Object apply(Object[] v) {
104 return 1;
105 }
106 }, 128).blockingLast();
107 }
108
109 @Test(expected = NullPointerException.class)
110 public void combineLatestDelayErrorIterableOneIsNull() {
111 Observable.combineLatestDelayError(Arrays.asList(Observable.never(), null), new Function<Object[], Object>() {
112 @Override
113 public Object apply(Object[] v) {
114 return 1;
115 }
116 }, 128).blockingLast();
117 }
118
119 @Test(expected = NullPointerException.class)
120 public void combineLatestDelayErrorIterableFunctionReturnsNull() {
121 Observable.combineLatestDelayError(Arrays.asList(just1), new Function<Object[], Object>() {
122 @Override
123 public Object apply(Object[] v) {
124 return null;
125 }
126 }, 128).blockingLast();
127 }
128
129 @Test(expected = NullPointerException.class)
130 public void concatIterableIteratorNull() {
131 Observable.concat(new Iterable<Observable<Object>>() {
132 @Override
133 public Iterator<Observable<Object>> iterator() {
134 return null;
135 }
136 }).blockingLast();
137 }
138
139 @Test(expected = NullPointerException.class)
140 public void concatIterableOneIsNull() {
141 Observable.concat(Arrays.asList(just1, null)).blockingLast();
142 }
143
144 @Test(expected = NullPointerException.class)
145 public void concatArrayOneIsNull() {
146 Observable.concatArray(just1, null).blockingLast();
147 }
148
149 @Test(expected = NullPointerException.class)
150 public void deferFunctionReturnsNull() {
151 Observable.defer(new Supplier<Observable<Object>>() {
152 @Override
153 public Observable<Object> get() {
154 return null;
155 }
156 }).blockingLast();
157 }
158
159 @Test(expected = NullPointerException.class)
160 public void errorFunctionReturnsNull() {
161 Observable.error(new Supplier<Throwable>() {
162 @Override
163 public Throwable get() {
164 return null;
165 }
166 }).blockingSubscribe();
167 }
168
169 @Test(expected = NullPointerException.class)
170 public void fromArrayOneIsNull() {
171 Observable.fromArray(1, null).blockingLast();
172 }
173
174 @Test(expected = NullPointerException.class)
175 public void fromCallableReturnsNull() {
176 Observable.fromCallable(new Callable<Object>() {
177 @Override
178 public Object call() throws Exception {
179 return null;
180 }
181 }).blockingLast();
182 }
183
184 @Test
185 public void fromFutureReturnsNull() {
186 FutureTask<Object> f = new FutureTask<>(Functions.EMPTY_RUNNABLE, null);
187 f.run();
188
189 TestObserver<Object> to = new TestObserver<>();
190 Observable.fromFuture(f).subscribe(to);
191 to.assertNoValues();
192 to.assertNotComplete();
193 to.assertError(NullPointerException.class);
194 }
195
196 @Test(expected = NullPointerException.class)
197 public void fromFutureTimedReturnsNull() {
198 FutureTask<Object> f = new FutureTask<>(Functions.EMPTY_RUNNABLE, null);
199 f.run();
200 Observable.fromFuture(f, 1, TimeUnit.SECONDS).blockingLast();
201 }
202
203 @Test(expected = NullPointerException.class)
204 public void fromIterableIteratorNull() {
205 Observable.fromIterable(new Iterable<Object>() {
206 @Override
207 public Iterator<Object> iterator() {
208 return null;
209 }
210 }).blockingLast();
211 }
212
213 @Test(expected = NullPointerException.class)
214 public void fromIterableValueNull() {
215 Observable.fromIterable(Arrays.asList(1, null)).blockingLast();
216 }
217
218 @Test(expected = NullPointerException.class)
219 public void generateConsumerEmitsNull() {
220 Observable.generate(new Consumer<Emitter<Object>>() {
221 @Override
222 public void accept(Emitter<Object> s) {
223 s.onNext(null);
224 }
225 }).blockingLast();
226 }
227
228 @Test
229 public void generateConsumerStateNullAllowed() {
230 BiConsumer<Integer, Emitter<Integer>> generator = new BiConsumer<Integer, Emitter<Integer>>() {
231 @Override
232 public void accept(Integer s, Emitter<Integer> o) {
233 o.onComplete();
234 }
235 };
236 Observable.generate(new Supplier<Integer>() {
237 @Override
238 public Integer get() {
239 return null;
240 }
241 }, generator).blockingSubscribe();
242 }
243
244 @Test
245 public void generateFunctionStateNullAllowed() {
246 Observable.generate(new Supplier<Object>() {
247 @Override
248 public Object get() {
249 return null;
250 }
251 }, new BiFunction<Object, Emitter<Object>, Object>() {
252 @Override
253 public Object apply(Object s, Emitter<Object> o) { o.onComplete(); return s; }
254 }).blockingSubscribe();
255 }
256
257 public void intervalSchedulerNull() {
258 Observable.interval(1, TimeUnit.SECONDS, null);
259 }
260
261 @Test
262 public void justNull() throws Exception {
263 @SuppressWarnings("rawtypes")
264 Class<Observable> clazz = Observable.class;
265 for (int argCount = 1; argCount < 10; argCount++) {
266 for (int argNull = 1; argNull <= argCount; argNull++) {
267 Class<?>[] params = new Class[argCount];
268 Arrays.fill(params, Object.class);
269
270 Object[] values = new Object[argCount];
271 Arrays.fill(values, 1);
272 values[argNull - 1] = null;
273
274 Method m = clazz.getMethod("just", params);
275
276 try {
277 m.invoke(null, values);
278 Assert.fail("No exception for argCount " + argCount + " / argNull " + argNull);
279 } catch (InvocationTargetException ex) {
280 if (!(ex.getCause() instanceof NullPointerException)) {
281 Assert.fail("Unexpected exception for argCount " + argCount + " / argNull " + argNull + ": " + ex);
282 }
283 }
284 }
285 }
286 }
287
288 @Test(expected = NullPointerException.class)
289 public void mergeIterableIteratorNull() {
290 Observable.merge(new Iterable<Observable<Object>>() {
291 @Override
292 public Iterator<Observable<Object>> iterator() {
293 return null;
294 }
295 }, 128, 128).blockingLast();
296 }
297
298 @Test(expected = NullPointerException.class)
299 public void mergeIterableOneIsNull() {
300 Observable.merge(Arrays.asList(just1, null), 128, 128).blockingLast();
301 }
302
303 @Test(expected = NullPointerException.class)
304 public void mergeDelayErrorIterableIteratorNull() {
305 Observable.mergeDelayError(new Iterable<Observable<Object>>() {
306 @Override
307 public Iterator<Observable<Object>> iterator() {
308 return null;
309 }
310 }, 128, 128).blockingLast();
311 }
312
313 @Test(expected = NullPointerException.class)
314 public void mergeDelayErrorIterableOneIsNull() {
315 Observable.mergeDelayError(Arrays.asList(just1, null), 128, 128).blockingLast();
316 }
317
318 @Test(expected = NullPointerException.class)
319 public void usingObservableSupplierReturnsNull() {
320 Observable.using(new Supplier<Object>() {
321 @Override
322 public Object get() {
323 return 1;
324 }
325 }, new Function<Object, Observable<Object>>() {
326 @Override
327 public Observable<Object> apply(Object d) {
328 return null;
329 }
330 }, new Consumer<Object>() {
331 @Override
332 public void accept(Object d) { }
333 }).blockingLast();
334 }
335
336 @Test(expected = NullPointerException.class)
337 public void zipIterableIteratorNull() {
338 Observable.zip(new Iterable<Observable<Object>>() {
339 @Override
340 public Iterator<Observable<Object>> iterator() {
341 return null;
342 }
343 }, new Function<Object[], Object>() {
344 @Override
345 public Object apply(Object[] v) {
346 return 1;
347 }
348 }).blockingLast();
349 }
350
351 @Test(expected = NullPointerException.class)
352 public void zipIterableFunctionReturnsNull() {
353 Observable.zip(Arrays.asList(just1, just1), new Function<Object[], Object>() {
354 @Override
355 public Object apply(Object[] a) {
356 return null;
357 }
358 }).blockingLast();
359 }
360
361 @Test(expected = NullPointerException.class)
362 public void zipIterable2IteratorNull() {
363 Observable.zip(new Iterable<Observable<Object>>() {
364 @Override
365 public Iterator<Observable<Object>> iterator() {
366 return null;
367 }
368 }, new Function<Object[], Object>() {
369 @Override
370 public Object apply(Object[] a) {
371 return 1;
372 }
373 }, true, 128).blockingLast();
374 }
375
376 @Test(expected = NullPointerException.class)
377 public void zipIterable2FunctionReturnsNull() {
378 Observable.zip(Arrays.asList(just1, just1), new Function<Object[], Object>() {
379 @Override
380 public Object apply(Object[] a) {
381 return null;
382 }
383 }, true, 128).blockingLast();
384 }
385
386 //*************************************************************
387 // Instance methods
388 //*************************************************************
389
390 @Test(expected = NullPointerException.class)
391 public void bufferSupplierReturnsNull() {
392 just1.buffer(1, 1, new Supplier<Collection<Integer>>() {
393 @Override
394 public Collection<Integer> get() {
395 return null;
396 }
397 }).blockingSubscribe();
398 }
399
400 @Test(expected = NullPointerException.class)
401 public void bufferTimedSupplierReturnsNull() {
402 just1.buffer(1L, 1L, TimeUnit.SECONDS, Schedulers.single(), new Supplier<Collection<Integer>>() {
403 @Override
404 public Collection<Integer> get() {
405 return null;
406 }
407 }).blockingSubscribe();
408 }
409
410 @Test(expected = NullPointerException.class)
411 public void bufferOpenCloseCloseReturnsNull() {
412 just1.buffer(just1, new Function<Integer, Observable<Object>>() {
413 @Override
414 public Observable<Object> apply(Integer v) {
415 return null;
416 }
417 }).blockingSubscribe();
418 }
419
420 @Test(expected = NullPointerException.class)
421 public void bufferBoundarySupplierReturnsNull() {
422 just1.buffer(just1, new Supplier<Collection<Integer>>() {
423 @Override
424 public Collection<Integer> get() {
425 return null;
426 }
427 }).blockingSubscribe();
428 }
429
430 @Test(expected = NullPointerException.class)
431 public void collectInitialSupplierReturnsNull() {
432 just1.collect(new Supplier<Object>() {
433 @Override
434 public Object get() {
435 return null;
436 }
437 }, new BiConsumer<Object, Integer>() {
438 @Override
439 public void accept(Object a, Integer b) { }
440 }).blockingGet();
441 }
442
443 @Test(expected = NullPointerException.class)
444 public void collectInitialCollectorNull() {
445 just1.collect(new Supplier<Object>() {
446 @Override
447 public Object get() {
448 return 1;
449 }
450 }, null);
451 }
452
453 @Test(expected = NullPointerException.class)
454 public void concatMapReturnsNull() {
455 just1.concatMap(new Function<Integer, Observable<Object>>() {
456 @Override
457 public Observable<Object> apply(Integer v) {
458 return null;
459 }
460 }).blockingSubscribe();
461 }
462
463 @Test(expected = NullPointerException.class)
464 public void concatMapIterableReturnNull() {
465 just1.concatMapIterable(new Function<Integer, Iterable<Object>>() {
466 @Override
467 public Iterable<Object> apply(Integer v) {
468 return null;
469 }
470 }).blockingSubscribe();
471 }
472
473 @Test(expected = NullPointerException.class)
474 public void concatMapIterableIteratorNull() {
475 just1.concatMapIterable(new Function<Integer, Iterable<Object>>() {
476 @Override
477 public Iterable<Object> apply(Integer v) {
478 return new Iterable<Object>() {
479 @Override
480 public Iterator<Object> iterator() {
481 return null;
482 }
483 };
484 }
485 }).blockingSubscribe();
486 }
487
488 @Test(expected = NullPointerException.class)
489 public void debounceFunctionReturnsNull() {
490 just1.debounce(new Function<Integer, Observable<Object>>() {
491 @Override
492 public Observable<Object> apply(Integer v) {
493 return null;
494 }
495 }).blockingSubscribe();
496 }
497
498 @Test(expected = NullPointerException.class)
499 public void delayWithFunctionReturnsNull() {
500 just1.delay(new Function<Integer, Observable<Object>>() {
501 @Override
502 public Observable<Object> apply(Integer v) {
503 return null;
504 }
505 }).blockingSubscribe();
506 }
507
508 @Test(expected = NullPointerException.class)
509 public void delayBothItemSupplierReturnsNull() {
510 just1.delay(just1
511 , new Function<Integer, Observable<Object>>() {
512 @Override
513 public Observable<Object> apply(Integer v) {
514 return null;
515 }
516 }).blockingSubscribe();
517 }
518
519 @Test(expected = NullPointerException.class)
520 public void distinctSupplierReturnsNull() {
521 just1.distinct(new Function<Integer, Object>() {
522 @Override
523 public Object apply(Integer v) {
524 return v;
525 }
526 }, new Supplier<Collection<Object>>() {
527 @Override
528 public Collection<Object> get() {
529 return null;
530 }
531 }).blockingSubscribe();
532 }
533
534 @Test(expected = NullPointerException.class)
535 public void distinctFunctionReturnsNull() {
536 just1.distinct(new Function<Integer, Object>() {
537 @Override
538 public Object apply(Integer v) {
539 return null;
540 }
541 }).blockingSubscribe();
542 }
543
544 @Test
545 public void distinctUntilChangedFunctionReturnsNull() {
546 Observable.range(1, 2).distinctUntilChanged(new Function<Integer, Object>() {
547 @Override
548 public Object apply(Integer v) {
549 return null;
550 }
551 }).test().assertResult(1);
552 }
553
554 @Test(expected = NullPointerException.class)
555 public void flatMapFunctionReturnsNull() {
556 just1.flatMap(new Function<Integer, Observable<Object>>() {
557 @Override
558 public Observable<Object> apply(Integer v) {
559 return null;
560 }
561 }).blockingSubscribe();
562 }
563
564 @Test(expected = NullPointerException.class)
565 public void flatMapNotificationOnNextReturnsNull() {
566 just1.flatMap(new Function<Integer, Observable<Integer>>() {
567 @Override
568 public Observable<Integer> apply(Integer v) {
569 return null;
570 }
571 }, new Function<Throwable, Observable<Integer>>() {
572 @Override
573 public Observable<Integer> apply(Throwable e) {
574 return just1;
575 }
576 }, new Supplier<Observable<Integer>>() {
577 @Override
578 public Observable<Integer> get() {
579 return just1;
580 }
581 }).blockingSubscribe();
582 }
583
584 @Test(expected = NullPointerException.class)
585 public void flatMapNotificationOnCompleteReturnsNull() {
586 just1.flatMap(new Function<Integer, Observable<Integer>>() {
587 @Override
588 public Observable<Integer> apply(Integer v) {
589 return just1;
590 }
591 }, new Function<Throwable, Observable<Integer>>() {
592 @Override
593 public Observable<Integer> apply(Throwable e) {
594 return just1;
595 }
596 }, new Supplier<Observable<Integer>>() {
597 @Override
598 public Observable<Integer> get() {
599 return null;
600 }
601 }).blockingSubscribe();
602 }
603
604 @Test(expected = NullPointerException.class)
605 public void flatMapCombinerMapperReturnsNull() {
606 just1.flatMap(new Function<Integer, Observable<Object>>() {
607 @Override
608 public Observable<Object> apply(Integer v) {
609 return null;
610 }
611 }, new BiFunction<Integer, Object, Object>() {
612 @Override
613 public Object apply(Integer a, Object b) {
614 return 1;
615 }
616 }).blockingSubscribe();
617 }
618
619 @Test(expected = NullPointerException.class)
620 public void flatMapCombinerCombinerReturnsNull() {
621 just1.flatMap(new Function<Integer, Observable<Integer>>() {
622 @Override
623 public Observable<Integer> apply(Integer v) {
624 return just1;
625 }
626 }, new BiFunction<Integer, Integer, Object>() {
627 @Override
628 public Object apply(Integer a, Integer b) {
629 return null;
630 }
631 }).blockingSubscribe();
632 }
633
634 @Test(expected = NullPointerException.class)
635 public void flatMapIterableMapperReturnsNull() {
636 just1.flatMapIterable(new Function<Integer, Iterable<Integer>>() {
637 @Override
638 public Iterable<Integer> apply(Integer v) {
639 return null;
640 }
641 }).blockingSubscribe();
642 }
643
644 @Test(expected = NullPointerException.class)
645 public void flatMapIterableMapperIteratorNull() {
646 just1.flatMapIterable(new Function<Integer, Iterable<Object>>() {
647 @Override
648 public Iterable<Object> apply(Integer v) {
649 return new Iterable<Object>() {
650 @Override
651 public Iterator<Object> iterator() {
652 return null;
653 }
654 };
655 }
656 }).blockingSubscribe();
657 }
658
659 @Test(expected = NullPointerException.class)
660 public void flatMapIterableMapperIterableOneNull() {
661 just1.flatMapIterable(new Function<Integer, Iterable<Integer>>() {
662 @Override
663 public Iterable<Integer> apply(Integer v) {
664 return Arrays.asList(1, null);
665 }
666 }).blockingSubscribe();
667 }
668
669 @Test(expected = NullPointerException.class)
670 public void flatMapIterableCombinerReturnsNull() {
671 just1.flatMapIterable(new Function<Integer, Iterable<Integer>>() {
672 @Override
673 public Iterable<Integer> apply(Integer v) {
674 return Arrays.asList(1);
675 }
676 }, new BiFunction<Integer, Integer, Object>() {
677 @Override
678 public Object apply(Integer a, Integer b) {
679 return null;
680 }
681 }).blockingSubscribe();
682 }
683
684 public void groupByKeyNull() {
685 just1.groupBy(new Function<Integer, Object>() {
686 @Override
687 public Object apply(Integer v) {
688 return null;
689 }
690 }).blockingSubscribe();
691 }
692
693 @Test(expected = NullPointerException.class)
694 public void groupByValueReturnsNull() {
695 just1.groupBy(new Function<Integer, Object>() {
696 @Override
697 public Object apply(Integer v) {
698 return v;
699 }
700 }, new Function<Integer, Object>() {
701 @Override
702 public Object apply(Integer v) {
703 return null;
704 }
705 }).blockingSubscribe();
706 }
707
708 @Test(expected = NullPointerException.class)
709 public void liftReturnsNull() {
710 just1.lift(new ObservableOperator<Object, Integer>() {
711 @Override
712 public Observer<? super Integer> apply(Observer<? super Object> observer) {
713 return null;
714 }
715 }).blockingSubscribe();
716 }
717
718 @Test(expected = NullPointerException.class)
719 public void mapReturnsNull() {
720 just1.map(new Function<Integer, Object>() {
721 @Override
722 public Object apply(Integer v) {
723 return null;
724 }
725 }).blockingSubscribe();
726 }
727
728 @Test(expected = NullPointerException.class)
729 public void onErrorResumeNextFunctionReturnsNull() {
730 Observable.error(new TestException()).onErrorResumeNext(new Function<Throwable, Observable<Object>>() {
731 @Override
732 public Observable<Object> apply(Throwable e) {
733 return null;
734 }
735 }).blockingSubscribe();
736 }
737
738 @Test(expected = NullPointerException.class)
739 public void onErrorReturnFunctionReturnsNull() {
740 Observable.error(new TestException()).onErrorReturn(new Function<Throwable, Object>() {
741 @Override
742 public Object apply(Throwable e) {
743 return null;
744 }
745 }).blockingSubscribe();
746 }
747
748 @Test(expected = NullPointerException.class)
749 public void publishFunctionReturnsNull() {
750 just1.publish(new Function<Observable<Integer>, Observable<Object>>() {
751 @Override
752 public Observable<Object> apply(Observable<Integer> v) {
753 return null;
754 }
755 }).blockingSubscribe();
756 }
757
758 @Test(expected = NullPointerException.class)
759 public void reduceFunctionReturnsNull() {
760 Observable.just(1, 1).reduce(new BiFunction<Integer, Integer, Integer>() {
761 @Override
762 public Integer apply(Integer a, Integer b) {
763 return null;
764 }
765 }).blockingGet();
766 }
767
768 @Test(expected = NullPointerException.class)
769 public void reduceSeedFunctionReturnsNull() {
770 just1.reduce(1, new BiFunction<Integer, Integer, Integer>() {
771 @Override
772 public Integer apply(Integer a, Integer b) {
773 return null;
774 }
775 }).blockingGet();
776 }
777
778 @Test(expected = NullPointerException.class)
779 public void reduceWithSeedReturnsNull() {
780 just1.reduceWith(new Supplier<Object>() {
781 @Override
782 public Object get() {
783 return null;
784 }
785 }, new BiFunction<Object, Integer, Object>() {
786 @Override
787 public Object apply(Object a, Integer b) {
788 return 1;
789 }
790 }).blockingGet();
791 }
792
793 @Test(expected = NullPointerException.class)
794 public void repeatWhenFunctionReturnsNull() {
795 just1.repeatWhen(new Function<Observable<Object>, Observable<Object>>() {
796 @Override
797 public Observable<Object> apply(Observable<Object> v) {
798 return null;
799 }
800 }).blockingSubscribe();
801 }
802
803 @Test(expected = NullPointerException.class)
804 public void replaySelectorReturnsNull() {
805 just1.replay(new Function<Observable<Integer>, Observable<Object>>() {
806 @Override
807 public Observable<Object> apply(Observable<Integer> o) {
808 return null;
809 }
810 }).blockingSubscribe();
811 }
812
813 @Test(expected = NullPointerException.class)
814 public void replayBoundedSelectorReturnsNull() {
815 just1.replay(new Function<Observable<Integer>, Observable<Object>>() {
816 @Override
817 public Observable<Object> apply(Observable<Integer> v) {
818 return null;
819 }
820 }, 1, 1, TimeUnit.SECONDS).blockingSubscribe();
821 }
822
823 @Test(expected = NullPointerException.class)
824 public void replayTimeBoundedSelectorReturnsNull() {
825 just1.replay(new Function<Observable<Integer>, Observable<Object>>() {
826 @Override
827 public Observable<Object> apply(Observable<Integer> v) {
828 return null;
829 }
830 }, 1, TimeUnit.SECONDS, Schedulers.single()).blockingSubscribe();
831 }
832
833 @Test(expected = NullPointerException.class)
834 public void retryWhenFunctionReturnsNull() {
835 Observable.error(new TestException()).retryWhen(new Function<Observable<? extends Throwable>, Observable<Object>>() {
836 @Override
837 public Observable<Object> apply(Observable<? extends Throwable> f) {
838 return null;
839 }
840 }).blockingSubscribe();
841 }
842
843 @Test(expected = NullPointerException.class)
844 public void scanFunctionReturnsNull() {
845 Observable.just(1, 1).scan(new BiFunction<Integer, Integer, Integer>() {
846 @Override
847 public Integer apply(Integer a, Integer b) {
848 return null;
849 }
850 }).blockingSubscribe();
851 }
852
853 @Test(expected = NullPointerException.class)
854 public void scanSeedFunctionReturnsNull() {
855 just1.scan(1, new BiFunction<Integer, Integer, Integer>() {
856 @Override
857 public Integer apply(Integer a, Integer b) {
858 return null;
859 }
860 }).blockingSubscribe();
861 }
862
863 @Test(expected = NullPointerException.class)
864 public void scanSeedSupplierReturnsNull() {
865 just1.scanWith(new Supplier<Object>() {
866 @Override
867 public Object get() {
868 return null;
869 }
870 }, new BiFunction<Object, Integer, Object>() {
871 @Override
872 public Object apply(Object a, Integer b) {
873 return 1;
874 }
875 }).blockingSubscribe();
876 }
877
878 @Test(expected = NullPointerException.class)
879 public void scanSeedSupplierFunctionReturnsNull() {
880 just1.scanWith(new Supplier<Object>() {
881 @Override
882 public Object get() {
883 return 1;
884 }
885 }, new BiFunction<Object, Integer, Object>() {
886 @Override
887 public Object apply(Object a, Integer b) {
888 return null;
889 }
890 }).blockingSubscribe();
891 }
892
893 @Test(expected = NullPointerException.class)
894 public void startWithIterableIteratorNull() {
895 just1.startWithIterable(new Iterable<Integer>() {
896 @Override
897 public Iterator<Integer> iterator() {
898 return null;
899 }
900 }).blockingSubscribe();
901 }
902
903 @Test(expected = NullPointerException.class)
904 public void startWithIterableOneNull() {
905 just1.startWithIterable(Arrays.asList(1, null)).blockingSubscribe();
906 }
907
908 @Test(expected = NullPointerException.class)
909 public void switchMapFunctionReturnsNull() {
910 just1.switchMap(new Function<Integer, Observable<Object>>() {
911 @Override
912 public Observable<Object> apply(Integer v) {
913 return null;
914 }
915 }).blockingSubscribe();
916 }
917
918 @Test(expected = NullPointerException.class)
919 public void timeoutSelectorReturnsNull() {
920 just1.timeout(new Function<Integer, Observable<Object>>() {
921 @Override
922 public Observable<Object> apply(Integer v) {
923 return null;
924 }
925 }).blockingSubscribe();
926 }
927
928 @Test(expected = NullPointerException.class)
929 public void timeoutFirstItemReturnsNull() {
930 Observable.just(1, 1).timeout(Observable.never(), new Function<Integer, Observable<Object>>() {
931 @Override
932 public Observable<Object> apply(Integer v) {
933 return null;
934 }
935 }).blockingSubscribe();
936 }
937
938 @Test(expected = NullPointerException.class)
939 public void toListSupplierReturnsNull() {
940 just1.toList(new Supplier<Collection<Integer>>() {
941 @Override
942 public Collection<Integer> get() {
943 return null;
944 }
945 }).blockingGet();
946 }
947
948 @Test
949 public void toMapValueSelectorReturnsNull() {
950 just1.toMap(new Function<Integer, Object>() {
951 @Override
952 public Object apply(Integer v) {
953 return v;
954 }
955 }, new Function<Integer, Object>() {
956 @Override
957 public Object apply(Integer v) {
958 return null;
959 }
960 }).blockingGet();
961 }
962
963 @Test(expected = NullPointerException.class)
964 public void toMapMapSupplierReturnsNull() {
965 just1.toMap(new Function<Integer, Object>() {
966 @Override
967 public Object apply(Integer v) {
968 return v;
969 }
970 }, new Function<Integer, Object>() {
971 @Override
972 public Object apply(Integer v) {
973 return v;
974 }
975 }, new Supplier<Map<Object, Object>>() {
976 @Override
977 public Map<Object, Object> get() {
978 return null;
979 }
980 }).blockingGet();
981 }
982
983 @Test
984 public void toMultiMapValueSelectorReturnsNullAllowed() {
985 just1.toMap(new Function<Integer, Object>() {
986 @Override
987 public Object apply(Integer v) {
988 return v;
989 }
990 }, new Function<Integer, Object>() {
991 @Override
992 public Object apply(Integer v) {
993 return null;
994 }
995 }).blockingGet();
996 }
997
998 @Test(expected = NullPointerException.class)
999 public void toMultimapMapSupplierReturnsNull() {
1000 just1.toMultimap(new Function<Integer, Object>() {
1001 @Override
1002 public Object apply(Integer v) {
1003 return v;
1004 }
1005 }, new Function<Integer, Object>() {
1006 @Override
1007 public Object apply(Integer v) {
1008 return v;
1009 }
1010 }, new Supplier<Map<Object, Collection<Object>>>() {
1011 @Override
1012 public Map<Object, Collection<Object>> get() {
1013 return null;
1014 }
1015 }).blockingGet();
1016 }
1017
1018 @Test(expected = NullPointerException.class)
1019 public void toMultimapMapCollectionSupplierReturnsNull() {
1020 just1.toMultimap(new Function<Integer, Integer>() {
1021 @Override
1022 public Integer apply(Integer v) {
1023 return v;
1024 }
1025 }, new Function<Integer, Integer>() {
1026 @Override
1027 public Integer apply(Integer v) {
1028 return v;
1029 }
1030 }, new Supplier<Map<Integer, Collection<Integer>>>() {
1031 @Override
1032 public Map<Integer, Collection<Integer>> get() {
1033 return new HashMap<>();
1034 }
1035 }, new Function<Integer, Collection<Integer>>() {
1036 @Override
1037 public Collection<Integer> apply(Integer v) {
1038 return null;
1039 }
1040 }).blockingGet();
1041 }
1042
1043 @Test(expected = NullPointerException.class)
1044 public void windowOpenCloseCloseReturnsNull() {
1045 Observable.never().window(just1, new Function<Integer, Observable<Object>>() {
1046 @Override
1047 public Observable<Object> apply(Integer v) {
1048 return null;
1049 }
1050 }).blockingSubscribe();
1051 }
1052
1053 @Test(expected = NullPointerException.class)
1054 public void withLatestFromCombinerReturnsNull() {
1055 just1.withLatestFrom(just1, new BiFunction<Integer, Integer, Object>() {
1056 @Override
1057 public Object apply(Integer a, Integer b) {
1058 return null;
1059 }
1060 }).blockingSubscribe();
1061 }
1062
1063 @Test(expected = NullPointerException.class)
1064 public void zipWithIterableCombinerReturnsNull() {
1065 just1.zipWith(Arrays.asList(1), new BiFunction<Integer, Integer, Object>() {
1066 @Override
1067 public Object apply(Integer a, Integer b) {
1068 return null;
1069 }
1070 }).blockingSubscribe();
1071 }
1072
1073 @Test(expected = NullPointerException.class)
1074 public void zipWithIterableIteratorNull() {
1075 just1.zipWith(new Iterable<Object>() {
1076 @Override
1077 public Iterator<Object> iterator() {
1078 return null;
1079 }
1080 }, new BiFunction<Integer, Object, Object>() {
1081 @Override
1082 public Object apply(Integer a, Object b) {
1083 return 1;
1084 }
1085 }).blockingSubscribe();
1086 }
1087
1088 @Test(expected = NullPointerException.class)
1089 public void zipWithIterableOneIsNull() {
1090 Observable.just(1, 2).zipWith(Arrays.asList(1, null), new BiFunction<Integer, Integer, Object>() {
1091 @Override
1092 public Object apply(Integer a, Integer b) {
1093 return 1;
1094 }
1095 }).blockingSubscribe();
1096 }
1097
1098 @Test(expected = NullPointerException.class)
1099 public void zipWithCombinerReturnsNull() {
1100 just1.zipWith(just1, new BiFunction<Integer, Integer, Object>() {
1101 @Override
1102 public Object apply(Integer a, Integer b) {
1103 return null;
1104 }
1105 }).blockingSubscribe();
1106 }
1107
1108 }