Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableCreateTest.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
18 import java.io.IOException;
19 import java.util.List;
20 import java.util.concurrent.CountDownLatch;
21 import java.util.concurrent.atomic.AtomicReference;
22
23 import org.junit.Test;
24
25 import io.reactivex.rxjava3.core.*;
26 import io.reactivex.rxjava3.disposables.Disposable;
27 import io.reactivex.rxjava3.exceptions.TestException;
28 import io.reactivex.rxjava3.functions.Cancellable;
29 import io.reactivex.rxjava3.observers.TestObserver;
30 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
31 import io.reactivex.rxjava3.testsupport.*;
32
33 public class ObservableCreateTest extends RxJavaTest {
34
35 @Test
36 @SuppressUndeliverable
37 public void basic() {
38 final Disposable d = Disposable.empty();
39
40 Observable.<Integer>create(new ObservableOnSubscribe<Integer>() {
41 @Override
42 public void subscribe(ObservableEmitter<Integer> e) throws Exception {
43 e.setDisposable(d);
44
45 e.onNext(1);
46 e.onNext(2);
47 e.onNext(3);
48 e.onComplete();
49 e.onError(new TestException());
50 e.onNext(4);
51 e.onError(new TestException());
52 e.onComplete();
53 }
54 })
55 .test()
56 .assertResult(1, 2, 3);
57
58 assertTrue(d.isDisposed());
59 }
60
61 @Test
62 @SuppressUndeliverable
63 public void basicWithCancellable() {
64 final Disposable d1 = Disposable.empty();
65 final Disposable d2 = Disposable.empty();
66
67 Observable.<Integer>create(new ObservableOnSubscribe<Integer>() {
68 @Override
69 public void subscribe(ObservableEmitter<Integer> e) throws Exception {
70 e.setDisposable(d1);
71 e.setCancellable(new Cancellable() {
72 @Override
73 public void cancel() throws Exception {
74 d2.dispose();
75 }
76 });
77
78 e.onNext(1);
79 e.onNext(2);
80 e.onNext(3);
81 e.onComplete();
82 e.onError(new TestException());
83 e.onNext(4);
84 e.onError(new TestException());
85 e.onComplete();
86 }
87 })
88 .test()
89 .assertResult(1, 2, 3);
90
91 assertTrue(d1.isDisposed());
92 assertTrue(d2.isDisposed());
93 }
94
95 @Test
96 @SuppressUndeliverable
97 public void basicWithError() {
98 final Disposable d = Disposable.empty();
99
100 Observable.<Integer>create(new ObservableOnSubscribe<Integer>() {
101 @Override
102 public void subscribe(ObservableEmitter<Integer> e) throws Exception {
103 e.setDisposable(d);
104
105 e.onNext(1);
106 e.onNext(2);
107 e.onNext(3);
108 e.onError(new TestException());
109 e.onComplete();
110 e.onNext(4);
111 e.onError(new TestException());
112 }
113 })
114 .test()
115 .assertFailure(TestException.class, 1, 2, 3);
116
117 assertTrue(d.isDisposed());
118 }
119
120 @Test
121 @SuppressUndeliverable
122 public void basicSerialized() {
123 final Disposable d = Disposable.empty();
124
125 Observable.<Integer>create(new ObservableOnSubscribe<Integer>() {
126 @Override
127 public void subscribe(ObservableEmitter<Integer> e) throws Exception {
128 e = e.serialize();
129
130 e.setDisposable(d);
131
132 e.onNext(1);
133 e.onNext(2);
134 e.onNext(3);
135 e.onComplete();
136 e.onError(new TestException());
137 e.onNext(4);
138 e.onError(new TestException());
139 e.onComplete();
140 }
141 })
142 .test()
143 .assertResult(1, 2, 3);
144
145 assertTrue(d.isDisposed());
146 }
147
148 @Test
149 @SuppressUndeliverable
150 public void basicWithErrorSerialized() {
151 final Disposable d = Disposable.empty();
152
153 Observable.<Integer>create(new ObservableOnSubscribe<Integer>() {
154 @Override
155 public void subscribe(ObservableEmitter<Integer> e) throws Exception {
156 e = e.serialize();
157
158 e.setDisposable(d);
159
160 e.onNext(1);
161 e.onNext(2);
162 e.onNext(3);
163 e.onError(new TestException());
164 e.onComplete();
165 e.onNext(4);
166 e.onError(new TestException());
167 }
168 })
169 .test()
170 .assertFailure(TestException.class, 1, 2, 3);
171
172 assertTrue(d.isDisposed());
173 }
174
175 @Test
176 public void wrap() {
177 Observable.wrap(new ObservableSource<Integer>() {
178 @Override
179 public void subscribe(Observer<? super Integer> observer) {
180 observer.onSubscribe(Disposable.empty());
181 observer.onNext(1);
182 observer.onNext(2);
183 observer.onNext(3);
184 observer.onNext(4);
185 observer.onNext(5);
186 observer.onComplete();
187 }
188 })
189 .test()
190 .assertResult(1, 2, 3, 4, 5);
191 }
192
193 @Test
194 public void unsafe() {
195 Observable.unsafeCreate(new ObservableSource<Integer>() {
196 @Override
197 public void subscribe(Observer<? super Integer> observer) {
198 observer.onSubscribe(Disposable.empty());
199 observer.onNext(1);
200 observer.onNext(2);
201 observer.onNext(3);
202 observer.onNext(4);
203 observer.onNext(5);
204 observer.onComplete();
205 }
206 })
207 .test()
208 .assertResult(1, 2, 3, 4, 5);
209 }
210
211 @Test(expected = IllegalArgumentException.class)
212 public void unsafeWithObservable() {
213 Observable.unsafeCreate(Observable.just(1));
214 }
215
216 @Test
217 @SuppressUndeliverable
218 public void createNullValue() {
219 final Throwable[] error = { null };
220
221 Observable.create(new ObservableOnSubscribe<Integer>() {
222 @Override
223 public void subscribe(ObservableEmitter<Integer> e) throws Exception {
224 try {
225 e.onNext(null);
226 e.onNext(1);
227 e.onError(new TestException());
228 e.onComplete();
229 } catch (Throwable ex) {
230 error[0] = ex;
231 }
232 }
233 })
234 .test()
235 .assertFailure(NullPointerException.class);
236
237 assertNull(error[0]);
238 }
239
240 @Test
241 @SuppressUndeliverable
242 public void createNullValueSerialized() {
243 final Throwable[] error = { null };
244
245 Observable.create(new ObservableOnSubscribe<Integer>() {
246 @Override
247 public void subscribe(ObservableEmitter<Integer> e) throws Exception {
248 e = e.serialize();
249 try {
250 e.onNext(null);
251 e.onNext(1);
252 e.onError(new TestException());
253 e.onComplete();
254 } catch (Throwable ex) {
255 error[0] = ex;
256 }
257 }
258 })
259 .test()
260 .assertFailure(NullPointerException.class);
261
262 assertNull(error[0]);
263 }
264
265 @Test
266 public void callbackThrows() {
267 Observable.create(new ObservableOnSubscribe<Object>() {
268 @Override
269 public void subscribe(ObservableEmitter<Object> e) throws Exception {
270 throw new TestException();
271 }
272 })
273 .test()
274 .assertFailure(TestException.class);
275 }
276
277 @Test
278 public void nullValue() {
279 Observable.create(new ObservableOnSubscribe<Object>() {
280 @Override
281 public void subscribe(ObservableEmitter<Object> e) throws Exception {
282 e.onNext(null);
283 }
284 })
285 .test()
286 .assertFailure(NullPointerException.class);
287 }
288
289 @Test
290 public void nullThrowable() {
291 Observable.create(new ObservableOnSubscribe<Object>() {
292 @Override
293 public void subscribe(ObservableEmitter<Object> e) throws Exception {
294 e.onError(null);
295 }
296 })
297 .test()
298 .assertFailure(NullPointerException.class);
299 }
300
301 @Test
302 public void nullValueSync() {
303 Observable.create(new ObservableOnSubscribe<Object>() {
304 @Override
305 public void subscribe(ObservableEmitter<Object> e) throws Exception {
306 e.serialize().onNext(null);
307 }
308 })
309 .test()
310 .assertFailure(NullPointerException.class);
311 }
312
313 @Test
314 public void nullThrowableSync() {
315 Observable.create(new ObservableOnSubscribe<Object>() {
316 @Override
317 public void subscribe(ObservableEmitter<Object> e) throws Exception {
318 e.serialize().onError(null);
319 }
320 })
321 .test()
322 .assertFailure(NullPointerException.class);
323 }
324
325 @Test
326 public void onErrorCrash() {
327 Observable.create(new ObservableOnSubscribe<Object>() {
328 @Override
329 public void subscribe(ObservableEmitter<Object> e) throws Exception {
330 Disposable d = Disposable.empty();
331 e.setDisposable(d);
332 try {
333 e.onError(new IOException());
334 fail("Should have thrown");
335 } catch (TestException ex) {
336 // expected
337 }
338 assertTrue(d.isDisposed());
339 }
340 })
341 .subscribe(new Observer<Object>() {
342 @Override
343 public void onSubscribe(Disposable d) {
344 }
345
346 @Override
347 public void onNext(Object value) {
348 }
349
350 @Override
351 public void onError(Throwable e) {
352 throw new TestException();
353 }
354
355 @Override
356 public void onComplete() {
357 }
358 });
359 }
360
361 @Test
362 public void onCompleteCrash() {
363 Observable.create(new ObservableOnSubscribe<Object>() {
364 @Override
365 public void subscribe(ObservableEmitter<Object> e) throws Exception {
366 Disposable d = Disposable.empty();
367 e.setDisposable(d);
368 try {
369 e.onComplete();
370 fail("Should have thrown");
371 } catch (TestException ex) {
372 // expected
373 }
374 assertTrue(d.isDisposed());
375 }
376 })
377 .subscribe(new Observer<Object>() {
378 @Override
379 public void onSubscribe(Disposable d) {
380 }
381
382 @Override
383 public void onNext(Object value) {
384 }
385
386 @Override
387 public void onError(Throwable e) {
388 }
389
390 @Override
391 public void onComplete() {
392 throw new TestException();
393 }
394 });
395 }
396
397 @Test
398 public void serialized() {
399 List<Throwable> errors = TestHelper.trackPluginErrors();
400 try {
401 Observable.create(new ObservableOnSubscribe<Object>() {
402 @Override
403 public void subscribe(ObservableEmitter<Object> e) throws Exception {
404 ObservableEmitter<Object> f = e.serialize();
405
406 assertSame(f, f.serialize());
407
408 assertFalse(f.isDisposed());
409
410 final int[] calls = { 0 };
411
412 f.setCancellable(new Cancellable() {
413 @Override
414 public void cancel() throws Exception {
415 calls[0]++;
416 }
417 });
418
419 e.onComplete();
420
421 assertTrue(f.isDisposed());
422
423 assertEquals(1, calls[0]);
424 }
425 })
426 .test()
427 .assertResult();
428
429 assertTrue(errors.toString(), errors.isEmpty());
430 } finally {
431 RxJavaPlugins.reset();
432 }
433 }
434
435 @Test
436 public void serializedConcurrentOnNext() {
437 Observable.create(new ObservableOnSubscribe<Object>() {
438 @Override
439 public void subscribe(ObservableEmitter<Object> e) throws Exception {
440 final ObservableEmitter<Object> f = e.serialize();
441
442 Runnable r1 = new Runnable() {
443 @Override
444 public void run() {
445 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
446 f.onNext(1);
447 }
448 }
449 };
450
451 TestHelper.race(r1, r1);
452 }
453 })
454 .take(TestHelper.RACE_DEFAULT_LOOPS)
455 .to(TestHelper.<Object>testConsumer())
456 .assertSubscribed()
457 .assertValueCount(TestHelper.RACE_DEFAULT_LOOPS)
458 .assertComplete()
459 .assertNoErrors();
460 }
461
462 @Test
463 public void serializedConcurrentOnNextOnError() {
464 Observable.create(new ObservableOnSubscribe<Object>() {
465 @Override
466 public void subscribe(ObservableEmitter<Object> e) throws Exception {
467 final ObservableEmitter<Object> f = e.serialize();
468
469 Runnable r1 = new Runnable() {
470 @Override
471 public void run() {
472 for (int i = 0; i < 1000; i++) {
473 f.onNext(1);
474 }
475 }
476 };
477
478 Runnable r2 = new Runnable() {
479 @Override
480 public void run() {
481 for (int i = 0; i < 100; i++) {
482 f.onNext(1);
483 }
484 f.onError(new TestException());
485 }
486 };
487
488 TestHelper.race(r1, r2);
489 }
490 })
491 .to(TestHelper.<Object>testConsumer())
492 .assertSubscribed()
493 .assertNotComplete()
494 .assertError(TestException.class);
495 }
496
497 @Test
498 public void serializedConcurrentOnNextOnComplete() {
499 TestObserverEx<Object> to = Observable.create(new ObservableOnSubscribe<Object>() {
500 @Override
501 public void subscribe(ObservableEmitter<Object> e) throws Exception {
502 final ObservableEmitter<Object> f = e.serialize();
503
504 Runnable r1 = new Runnable() {
505 @Override
506 public void run() {
507 for (int i = 0; i < 1000; i++) {
508 f.onNext(1);
509 }
510 }
511 };
512
513 Runnable r2 = new Runnable() {
514 @Override
515 public void run() {
516 for (int i = 0; i < 100; i++) {
517 f.onNext(1);
518 }
519 f.onComplete();
520 }
521 };
522
523 TestHelper.race(r1, r2);
524 }
525 })
526 .to(TestHelper.<Object>testConsumer())
527 .assertSubscribed()
528 .assertComplete()
529 .assertNoErrors();
530
531 int c = to.values().size();
532 assertTrue("" + c, c >= 100);
533 }
534
535 @Test
536 public void onErrorRace() {
537 Observable<Object> source = Observable.create(new ObservableOnSubscribe<Object>() {
538 @Override
539 public void subscribe(ObservableEmitter<Object> e) throws Exception {
540 final ObservableEmitter<Object> f = e.serialize();
541
542 final TestException ex = new TestException();
543
544 Runnable r1 = new Runnable() {
545 @Override
546 public void run() {
547 f.onError(null);
548 }
549 };
550
551 Runnable r2 = new Runnable() {
552 @Override
553 public void run() {
554 f.onError(ex);
555 }
556 };
557
558 TestHelper.race(r1, r2);
559 }
560 });
561
562 List<Throwable> errors = TestHelper.trackPluginErrors();
563
564 try {
565 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
566 source
567 .test()
568 .assertFailure(Throwable.class);
569 }
570 } finally {
571 RxJavaPlugins.reset();
572 }
573 assertFalse(errors.isEmpty());
574 }
575
576 @Test
577 public void onCompleteRace() {
578 Observable<Object> source = Observable.create(new ObservableOnSubscribe<Object>() {
579 @Override
580 public void subscribe(ObservableEmitter<Object> e) throws Exception {
581 final ObservableEmitter<Object> f = e.serialize();
582
583 Runnable r1 = new Runnable() {
584 @Override
585 public void run() {
586 f.onComplete();
587 }
588 };
589
590 Runnable r2 = new Runnable() {
591 @Override
592 public void run() {
593 f.onComplete();
594 }
595 };
596
597 TestHelper.race(r1, r2);
598 }
599 });
600
601 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
602 source
603 .test()
604 .assertResult();
605 }
606 }
607
608 @Test
609 public void tryOnError() {
610 List<Throwable> errors = TestHelper.trackPluginErrors();
611 try {
612 final Boolean[] response = { null };
613 Observable.create(new ObservableOnSubscribe<Object>() {
614 @Override
615 public void subscribe(ObservableEmitter<Object> e) throws Exception {
616 e.onNext(1);
617 response[0] = e.tryOnError(new TestException());
618 }
619 })
620 .take(1)
621 .test()
622 .assertResult(1);
623
624 assertFalse(response[0]);
625
626 assertTrue(errors.toString(), errors.isEmpty());
627 } finally {
628 RxJavaPlugins.reset();
629 }
630 }
631
632 @Test
633 public void tryOnErrorSerialized() {
634 List<Throwable> errors = TestHelper.trackPluginErrors();
635 try {
636 final Boolean[] response = { null };
637 Observable.create(new ObservableOnSubscribe<Object>() {
638 @Override
639 public void subscribe(ObservableEmitter<Object> e) throws Exception {
640 e = e.serialize();
641 e.onNext(1);
642 response[0] = e.tryOnError(new TestException());
643 }
644 })
645 .take(1)
646 .test()
647 .assertResult(1);
648
649 assertFalse(response[0]);
650
651 assertTrue(errors.toString(), errors.isEmpty());
652 } finally {
653 RxJavaPlugins.reset();
654 }
655 }
656
657 @Test
658 public void emitterHasToString() {
659 Observable.create(new ObservableOnSubscribe<Object>() {
660 @Override
661 public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
662 assertTrue(emitter.toString().contains(ObservableCreate.CreateEmitter.class.getSimpleName()));
663 assertTrue(emitter.serialize().toString().contains(ObservableCreate.CreateEmitter.class.getSimpleName()));
664 }
665 }).test().assertEmpty();
666 }
667
668 @Test
669 public void emptySerialized() {
670 Observable.create(emitter -> emitter.serialize().onComplete())
671 .test()
672 .assertResult();
673 }
674
675 @Test
676 public void serializedDisposedBeforeOnNext() {
677 TestObserver<Object> to = new TestObserver<>();
678
679 Observable.create(emitter -> {
680 to.dispose();
681 emitter.serialize().onNext(1);
682 })
683 .subscribe(to);
684
685 to.assertEmpty();
686 }
687
688 @Test
689 public void serializedOnNextAfterComplete() {
690 TestObserver<Object> to = new TestObserver<>();
691
692 Observable.create(emitter -> {
693 emitter = emitter.serialize();
694
695 emitter.onComplete();
696 emitter.onNext(1);
697 })
698 .subscribe(to);
699
700 to.assertResult();
701 }
702
703 @Test
704 public void serializedEnqueueAndDrainRace() throws Throwable {
705 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
706 TestObserver<Integer> to = new TestObserver<>();
707 AtomicReference<ObservableEmitter<Integer>> ref = new AtomicReference<>();
708
709 CountDownLatch cdl = new CountDownLatch(1);
710
711 Observable.<Integer>create(emitter -> {
712 emitter = emitter.serialize();
713 ref.set(emitter);
714 emitter.onNext(1);
715 })
716 .doOnNext(v -> {
717 if (v == 1) {
718 TestHelper.raceOther(() -> {
719 ref.get().onNext(2);
720 }, cdl);
721 ref.get().onNext(3);
722 }
723 })
724 .subscribe(to);
725
726 cdl.await();
727
728 to.assertValueCount(3);
729 }
730 }
731
732 @Test
733 public void serializedDrainDoneButNotEmpty() throws Throwable {
734 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
735 TestObserver<Integer> to = new TestObserver<>();
736 AtomicReference<ObservableEmitter<Integer>> ref = new AtomicReference<>();
737
738 CountDownLatch cdl = new CountDownLatch(1);
739
740 Observable.<Integer>create(emitter -> {
741 emitter = emitter.serialize();
742 ref.set(emitter);
743 emitter.onNext(1);
744 })
745 .doOnNext(v -> {
746 if (v == 1) {
747 TestHelper.raceOther(() -> {
748 ref.get().onNext(2);
749 ref.get().onComplete();
750 }, cdl);
751 ref.get().onNext(3);
752 }
753 })
754 .subscribe(to);
755
756 cdl.await();
757 }
758 }
759 }