Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableFromSourceTest.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.flowable;
15
16 import java.util.List;
17
18 import org.junit.*;
19 import org.reactivestreams.Subscription;
20
21 import io.reactivex.rxjava3.core.*;
22 import io.reactivex.rxjava3.exceptions.*;
23 import io.reactivex.rxjava3.functions.Cancellable;
24 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
25 import io.reactivex.rxjava3.processors.PublishProcessor;
26 import io.reactivex.rxjava3.subscribers.*;
27 import io.reactivex.rxjava3.testsupport.*;
28
29 public class FlowableFromSourceTest extends RxJavaTest {
30
31 PublishAsyncEmitter source;
32
33 PublishAsyncEmitterNoCancel sourceNoCancel;
34
35 TestSubscriberEx<Integer> ts;
36
37 @Before
38 public void before() {
39 source = new PublishAsyncEmitter();
40 sourceNoCancel = new PublishAsyncEmitterNoCancel();
41 ts = new TestSubscriberEx<>(0L);
42 }
43
44 @Test
45 public void normalBuffered() {
46 Flowable.create(source, BackpressureStrategy.BUFFER).subscribe(ts);
47
48 source.onNext(1);
49 source.onNext(2);
50 source.onComplete();
51
52 ts.request(1);
53
54 ts.assertValue(1);
55
56 Assert.assertEquals(0, source.requested());
57
58 ts.request(1);
59
60 ts.assertValues(1, 2);
61 ts.assertNoErrors();
62 ts.assertComplete();
63 }
64
65 @Test
66 public void normalDrop() {
67 Flowable.create(source, BackpressureStrategy.DROP).subscribe(ts);
68
69 source.onNext(1);
70
71 ts.request(1);
72
73 ts.assertNoValues();
74
75 source.onNext(2);
76 source.onComplete();
77
78 ts.assertValues(2);
79 ts.assertNoErrors();
80 ts.assertComplete();
81 }
82
83 @Test
84 public void normalLatest() {
85 Flowable.create(source, BackpressureStrategy.LATEST).subscribe(ts);
86
87 source.onNext(1);
88
89 source.onNext(2);
90 source.onComplete();
91
92 ts.assertNoValues();
93
94 ts.request(1);
95
96 ts.assertValues(2);
97 ts.assertNoErrors();
98 ts.assertComplete();
99 }
100
101 @Test
102 public void normalMissing() {
103 Flowable.create(source, BackpressureStrategy.MISSING).subscribe(ts);
104
105 source.onNext(1);
106 source.onNext(2);
107 source.onComplete();
108
109 ts.assertValues(1, 2);
110 ts.assertNoErrors();
111 ts.assertComplete();
112 }
113
114 @Test
115 public void normalMissingRequested() {
116 Flowable.create(source, BackpressureStrategy.MISSING).subscribe(ts);
117 ts.request(2);
118
119 source.onNext(1);
120 source.onNext(2);
121 source.onComplete();
122
123 ts.assertValues(1, 2);
124 ts.assertNoErrors();
125 ts.assertComplete();
126 }
127
128 @Test
129 public void normalError() {
130 Flowable.create(source, BackpressureStrategy.ERROR).subscribe(ts);
131
132 source.onNext(1);
133 source.onNext(2);
134 source.onComplete();
135
136 ts.assertNoValues();
137 ts.assertError(MissingBackpressureException.class);
138 ts.assertNotComplete();
139
140 Assert.assertEquals("create: could not emit value due to lack of requests", ts.errors().get(0).getMessage());
141 }
142
143 @Test
144 public void errorBuffered() {
145 Flowable.create(source, BackpressureStrategy.BUFFER).subscribe(ts);
146
147 source.onNext(1);
148 source.onNext(2);
149 source.onError(new TestException());
150
151 ts.request(1);
152
153 ts.assertValue(1);
154
155 ts.request(1);
156
157 ts.assertValues(1, 2);
158 ts.assertError(TestException.class);
159 ts.assertNotComplete();
160 }
161
162 @Test
163 public void errorLatest() {
164 Flowable.create(source, BackpressureStrategy.LATEST).subscribe(ts);
165
166 source.onNext(1);
167 source.onNext(2);
168 source.onError(new TestException());
169
170 ts.assertNoValues();
171
172 ts.request(1);
173
174 ts.assertValues(2);
175 ts.assertError(TestException.class);
176 ts.assertNotComplete();
177 }
178
179 @Test
180 public void errorMissing() {
181 Flowable.create(source, BackpressureStrategy.MISSING).subscribe(ts);
182
183 source.onNext(1);
184 source.onNext(2);
185 source.onError(new TestException());
186
187 ts.request(1);
188
189 ts.assertValues(1, 2);
190 ts.assertError(TestException.class);
191 ts.assertNotComplete();
192 }
193
194 @Test
195 public void unsubscribedBuffer() {
196 Flowable.create(source, BackpressureStrategy.BUFFER).subscribe(ts);
197 ts.cancel();
198
199 source.onNext(1);
200 source.onNext(2);
201 source.onError(new TestException());
202
203 ts.request(1);
204
205 ts.assertNoValues();
206 ts.assertNoErrors();
207 ts.assertNotComplete();
208 }
209
210 @Test
211 public void unsubscribedLatest() {
212 Flowable.create(source, BackpressureStrategy.LATEST).subscribe(ts);
213 ts.cancel();
214
215 source.onNext(1);
216 source.onNext(2);
217 source.onError(new TestException());
218
219 ts.request(1);
220
221 ts.assertNoValues();
222 ts.assertNoErrors();
223 ts.assertNotComplete();
224 }
225
226 @Test
227 public void unsubscribedError() {
228 Flowable.create(source, BackpressureStrategy.ERROR).subscribe(ts);
229 ts.cancel();
230
231 source.onNext(1);
232 source.onNext(2);
233 source.onError(new TestException());
234
235 ts.request(1);
236
237 ts.assertNoValues();
238 ts.assertNoErrors();
239 ts.assertNotComplete();
240 }
241
242 @Test
243 public void unsubscribedDrop() {
244 Flowable.create(source, BackpressureStrategy.DROP).subscribe(ts);
245 ts.cancel();
246
247 source.onNext(1);
248 source.onNext(2);
249 source.onError(new TestException());
250
251 ts.request(1);
252
253 ts.assertNoValues();
254 ts.assertNoErrors();
255 ts.assertNotComplete();
256 }
257
258 @Test
259 public void unsubscribedMissing() {
260 Flowable.create(source, BackpressureStrategy.MISSING).subscribe(ts);
261 ts.cancel();
262
263 source.onNext(1);
264 source.onNext(2);
265 source.onError(new TestException());
266
267 ts.request(1);
268
269 ts.assertNoValues();
270 ts.assertNoErrors();
271 ts.assertNotComplete();
272 }
273
274 @Test
275 public void unsubscribedNoCancelBuffer() {
276 List<Throwable> errors = TestHelper.trackPluginErrors();
277 try {
278 Flowable.create(sourceNoCancel, BackpressureStrategy.BUFFER).subscribe(ts);
279 ts.cancel();
280
281 sourceNoCancel.onNext(1);
282 sourceNoCancel.onNext(2);
283 sourceNoCancel.onError(new TestException());
284
285 ts.request(1);
286
287 ts.assertNoValues();
288 ts.assertNoErrors();
289 ts.assertNotComplete();
290
291 TestHelper.assertUndeliverable(errors, 0, TestException.class);
292 } finally {
293 RxJavaPlugins.reset();
294 }
295 }
296
297 @Test
298 public void unsubscribedNoCancelLatest() {
299 List<Throwable> errors = TestHelper.trackPluginErrors();
300 try {
301 Flowable.create(sourceNoCancel, BackpressureStrategy.LATEST).subscribe(ts);
302 ts.cancel();
303
304 sourceNoCancel.onNext(1);
305 sourceNoCancel.onNext(2);
306 sourceNoCancel.onError(new TestException());
307
308 ts.request(1);
309
310 ts.assertNoValues();
311 ts.assertNoErrors();
312 ts.assertNotComplete();
313 TestHelper.assertUndeliverable(errors, 0, TestException.class);
314 } finally {
315 RxJavaPlugins.reset();
316 }
317 }
318
319 @Test
320 public void unsubscribedNoCancelError() {
321 List<Throwable> errors = TestHelper.trackPluginErrors();
322 try {
323 Flowable.create(sourceNoCancel, BackpressureStrategy.ERROR).subscribe(ts);
324 ts.cancel();
325
326 sourceNoCancel.onNext(1);
327 sourceNoCancel.onNext(2);
328 sourceNoCancel.onError(new TestException());
329
330 ts.request(1);
331
332 ts.assertNoValues();
333 ts.assertNoErrors();
334 ts.assertNotComplete();
335
336 TestHelper.assertUndeliverable(errors, 0, TestException.class);
337 } finally {
338 RxJavaPlugins.reset();
339 }
340 }
341
342 @Test
343 public void unsubscribedNoCancelDrop() {
344 List<Throwable> errors = TestHelper.trackPluginErrors();
345 try {
346 Flowable.create(sourceNoCancel, BackpressureStrategy.DROP).subscribe(ts);
347 ts.cancel();
348
349 sourceNoCancel.onNext(1);
350 sourceNoCancel.onNext(2);
351 sourceNoCancel.onError(new TestException());
352
353 ts.request(1);
354
355 ts.assertNoValues();
356 ts.assertNoErrors();
357 ts.assertNotComplete();
358
359 TestHelper.assertUndeliverable(errors, 0, TestException.class);
360 } finally {
361 RxJavaPlugins.reset();
362 }
363 }
364
365 @Test
366 public void unsubscribedNoCancelMissing() {
367 List<Throwable> errors = TestHelper.trackPluginErrors();
368 try {
369 Flowable.create(sourceNoCancel, BackpressureStrategy.MISSING).subscribe(ts);
370 ts.cancel();
371
372 sourceNoCancel.onNext(1);
373 sourceNoCancel.onNext(2);
374 sourceNoCancel.onError(new TestException());
375
376 ts.request(1);
377
378 ts.assertNoValues();
379 ts.assertNoErrors();
380 ts.assertNotComplete();
381
382 TestHelper.assertUndeliverable(errors, 0, TestException.class);
383 } finally {
384 RxJavaPlugins.reset();
385 }
386 }
387
388 @Test
389 public void deferredRequest() {
390 Flowable.create(source, BackpressureStrategy.BUFFER).subscribe(ts);
391
392 source.onNext(1);
393 source.onNext(2);
394 source.onComplete();
395
396 ts.request(2);
397
398 ts.assertValues(1, 2);
399 ts.assertNoErrors();
400 ts.assertComplete();
401 }
402
403 @Test
404 public void take() {
405 Flowable.create(source, BackpressureStrategy.BUFFER).take(2).subscribe(ts);
406
407 source.onNext(1);
408 source.onNext(2);
409 source.onComplete();
410
411 ts.request(2);
412
413 ts.assertValues(1, 2);
414 ts.assertNoErrors();
415 ts.assertComplete();
416 }
417
418 @Test
419 public void takeOne() {
420 Flowable.create(source, BackpressureStrategy.BUFFER).take(1).subscribe(ts);
421 ts.request(2);
422
423 source.onNext(1);
424 source.onNext(2);
425 source.onComplete();
426
427 ts.assertValues(1);
428 ts.assertNoErrors();
429 ts.assertComplete();
430 }
431
432 @Test
433 public void requestExact() {
434 Flowable.create(source, BackpressureStrategy.BUFFER).subscribe(ts);
435 ts.request(2);
436
437 source.onNext(1);
438 source.onNext(2);
439 source.onComplete();
440
441 ts.assertValues(1, 2);
442 ts.assertNoErrors();
443 ts.assertComplete();
444 }
445
446 @Test
447 public void takeNoCancel() {
448 Flowable.create(sourceNoCancel, BackpressureStrategy.BUFFER).take(2).subscribe(ts);
449
450 sourceNoCancel.onNext(1);
451 sourceNoCancel.onNext(2);
452 sourceNoCancel.onComplete();
453
454 ts.request(2);
455
456 ts.assertValues(1, 2);
457 ts.assertNoErrors();
458 ts.assertComplete();
459 }
460
461 @Test
462 public void takeOneNoCancel() {
463 Flowable.create(sourceNoCancel, BackpressureStrategy.BUFFER).take(1).subscribe(ts);
464 ts.request(2);
465
466 sourceNoCancel.onNext(1);
467 sourceNoCancel.onNext(2);
468 sourceNoCancel.onComplete();
469
470 ts.assertValues(1);
471 ts.assertNoErrors();
472 ts.assertComplete();
473 }
474
475 @Test
476 public void unsubscribeNoCancel() {
477 Flowable.create(sourceNoCancel, BackpressureStrategy.BUFFER).subscribe(ts);
478 ts.request(2);
479
480 sourceNoCancel.onNext(1);
481
482 ts.cancel();
483
484 sourceNoCancel.onNext(2);
485
486 ts.assertValues(1);
487 ts.assertNoErrors();
488 ts.assertNotComplete();
489 }
490
491 @Test
492 public void unsubscribeInline() {
493 TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>() {
494 @Override
495 public void onNext(Integer t) {
496 super.onNext(t);
497 cancel();
498 }
499 };
500
501 Flowable.create(sourceNoCancel, BackpressureStrategy.BUFFER).subscribe(ts1);
502
503 sourceNoCancel.onNext(1);
504
505 ts1.assertValues(1);
506 ts1.assertNoErrors();
507 ts1.assertNotComplete();
508 }
509
510 @Test
511 public void completeInline() {
512 Flowable.create(sourceNoCancel, BackpressureStrategy.BUFFER).subscribe(ts);
513
514 sourceNoCancel.onNext(1);
515 sourceNoCancel.onComplete();
516
517 ts.request(2);
518
519 ts.assertValues(1);
520 ts.assertNoErrors();
521 ts.assertComplete();
522 }
523
524 @Test
525 public void errorInline() {
526 Flowable.create(sourceNoCancel, BackpressureStrategy.BUFFER).subscribe(ts);
527
528 sourceNoCancel.onNext(1);
529 sourceNoCancel.onError(new TestException());
530
531 ts.request(2);
532
533 ts.assertValues(1);
534 ts.assertError(TestException.class);
535 ts.assertNotComplete();
536 }
537
538 @Test
539 public void requestInline() {
540 TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>(1L) {
541 @Override
542 public void onNext(Integer t) {
543 super.onNext(t);
544 request(1);
545 }
546 };
547
548 Flowable.create(sourceNoCancel, BackpressureStrategy.BUFFER).subscribe(ts1);
549
550 sourceNoCancel.onNext(1);
551 sourceNoCancel.onNext(2);
552
553 ts1.assertValues(1, 2);
554 ts1.assertNoErrors();
555 ts1.assertNotComplete();
556 }
557
558 @Test
559 public void unsubscribeInlineLatest() {
560 TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>() {
561 @Override
562 public void onNext(Integer t) {
563 super.onNext(t);
564 cancel();
565 }
566 };
567
568 Flowable.create(sourceNoCancel, BackpressureStrategy.LATEST).subscribe(ts1);
569
570 sourceNoCancel.onNext(1);
571
572 ts1.assertValues(1);
573 ts1.assertNoErrors();
574 ts1.assertNotComplete();
575 }
576
577 @Test
578 public void unsubscribeInlineExactLatest() {
579 TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>(1L) {
580 @Override
581 public void onNext(Integer t) {
582 super.onNext(t);
583 cancel();
584 }
585 };
586
587 Flowable.create(sourceNoCancel, BackpressureStrategy.LATEST).subscribe(ts1);
588
589 sourceNoCancel.onNext(1);
590
591 ts1.assertValues(1);
592 ts1.assertNoErrors();
593 ts1.assertNotComplete();
594 }
595
596 @Test
597 public void completeInlineLatest() {
598 Flowable.create(sourceNoCancel, BackpressureStrategy.LATEST).subscribe(ts);
599
600 sourceNoCancel.onNext(1);
601 sourceNoCancel.onComplete();
602
603 ts.request(2);
604
605 ts.assertValues(1);
606 ts.assertNoErrors();
607 ts.assertComplete();
608 }
609
610 @Test
611 public void completeInlineExactLatest() {
612 Flowable.create(sourceNoCancel, BackpressureStrategy.LATEST).subscribe(ts);
613
614 sourceNoCancel.onNext(1);
615 sourceNoCancel.onComplete();
616
617 ts.request(1);
618
619 ts.assertValues(1);
620 ts.assertNoErrors();
621 ts.assertComplete();
622 }
623
624 @Test
625 public void errorInlineLatest() {
626 Flowable.create(sourceNoCancel, BackpressureStrategy.LATEST).subscribe(ts);
627
628 sourceNoCancel.onNext(1);
629 sourceNoCancel.onError(new TestException());
630
631 ts.request(2);
632
633 ts.assertValues(1);
634 ts.assertError(TestException.class);
635 ts.assertNotComplete();
636 }
637
638 @Test
639 public void requestInlineLatest() {
640 TestSubscriber<Integer> ts1 = new TestSubscriber<Integer>(1L) {
641 @Override
642 public void onNext(Integer t) {
643 super.onNext(t);
644 request(1);
645 }
646 };
647
648 Flowable.create(sourceNoCancel, BackpressureStrategy.LATEST).subscribe(ts1);
649
650 sourceNoCancel.onNext(1);
651 sourceNoCancel.onNext(2);
652
653 ts1.assertValues(1, 2);
654 ts1.assertNoErrors();
655 ts1.assertNotComplete();
656 }
657
658 static final class PublishAsyncEmitter implements FlowableOnSubscribe<Integer>, FlowableSubscriber<Integer> {
659
660 final PublishProcessor<Integer> processor;
661
662 FlowableEmitter<Integer> current;
663
664 PublishAsyncEmitter() {
665 this.processor = PublishProcessor.create();
666 }
667
668 long requested() {
669 return current.requested();
670 }
671
672 @Override
673 public void subscribe(final FlowableEmitter<Integer> t) {
674
675 this.current = t;
676
677 final ResourceSubscriber<Integer> as = new ResourceSubscriber<Integer>() {
678
679 @Override
680 public void onComplete() {
681 t.onComplete();
682 }
683
684 @Override
685 public void onError(Throwable e) {
686 t.onError(e);
687 }
688
689 @Override
690 public void onNext(Integer v) {
691 t.onNext(v);
692 }
693
694 };
695
696 processor.subscribe(as);
697
698 t.setCancellable(new Cancellable() {
699 @Override
700 public void cancel() throws Exception {
701 as.dispose();
702 }
703 });;
704 }
705
706 @Override
707 public void onSubscribe(Subscription s) {
708 s.request(Long.MAX_VALUE);
709 }
710
711 @Override
712 public void onNext(Integer t) {
713 processor.onNext(t);
714 }
715
716 @Override
717 public void onError(Throwable e) {
718 processor.onError(e);
719 }
720
721 @Override
722 public void onComplete() {
723 processor.onComplete();
724 }
725 }
726
727 static final class PublishAsyncEmitterNoCancel implements FlowableOnSubscribe<Integer>, FlowableSubscriber<Integer> {
728
729 final PublishProcessor<Integer> processor;
730
731 PublishAsyncEmitterNoCancel() {
732 this.processor = PublishProcessor.create();
733 }
734
735 @Override
736 public void subscribe(final FlowableEmitter<Integer> t) {
737
738 processor.subscribe(new FlowableSubscriber<Integer>() {
739
740 @Override
741 public void onSubscribe(Subscription s) {
742 s.request(Long.MAX_VALUE);
743 }
744
745 @Override
746 public void onComplete() {
747 t.onComplete();
748 }
749
750 @Override
751 public void onError(Throwable e) {
752 t.onError(e);
753 }
754
755 @Override
756 public void onNext(Integer v) {
757 t.onNext(v);
758 }
759
760 });
761 }
762
763 @Override
764 public void onSubscribe(Subscription s) {
765 s.request(Long.MAX_VALUE);
766 }
767
768 @Override
769 public void onNext(Integer t) {
770 processor.onNext(t);
771 }
772
773 @Override
774 public void onError(Throwable e) {
775 processor.onError(e);
776 }
777
778 @Override
779 public void onComplete() {
780 processor.onComplete();
781 }
782 }
783
784 }