Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/util/QueueDrainHelperTest.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.util;
15
16 import static org.junit.Assert.*;
17
18 import java.io.IOException;
19 import java.util.*;
20 import java.util.concurrent.atomic.AtomicLong;
21
22 import org.junit.Test;
23 import org.reactivestreams.*;
24
25 import io.reactivex.rxjava3.core.Observer;
26 import io.reactivex.rxjava3.core.RxJavaTest;
27 import io.reactivex.rxjava3.disposables.*;
28 import io.reactivex.rxjava3.exceptions.*;
29 import io.reactivex.rxjava3.functions.BooleanSupplier;
30 import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
31 import io.reactivex.rxjava3.observers.TestObserver;
32 import io.reactivex.rxjava3.operators.SpscArrayQueue;
33 import io.reactivex.rxjava3.subscribers.TestSubscriber;
34 import io.reactivex.rxjava3.testsupport.TestHelper;
35
36 public class QueueDrainHelperTest extends RxJavaTest {
37
38 @Test
39 public void isCancelled() {
40 assertTrue(QueueDrainHelper.isCancelled(new BooleanSupplier() {
41 @Override
42 public boolean getAsBoolean() throws Exception {
43 throw new IOException();
44 }
45 }));
46 }
47
48 @Test
49 public void requestMaxInt() {
50 QueueDrainHelper.request(new Subscription() {
51 @Override
52 public void request(long n) {
53 assertEquals(Integer.MAX_VALUE, n);
54 }
55
56 @Override
57 public void cancel() {
58 }
59 }, Integer.MAX_VALUE);
60 }
61
62 @Test
63 public void requestMinInt() {
64 QueueDrainHelper.request(new Subscription() {
65 @Override
66 public void request(long n) {
67 assertEquals(Long.MAX_VALUE, n);
68 }
69
70 @Override
71 public void cancel() {
72 }
73 }, Integer.MIN_VALUE);
74 }
75
76 @Test
77 public void requestAlmostMaxInt() {
78 QueueDrainHelper.request(new Subscription() {
79 @Override
80 public void request(long n) {
81 assertEquals(Integer.MAX_VALUE - 1, n);
82 }
83
84 @Override
85 public void cancel() {
86 }
87 }, Integer.MAX_VALUE - 1);
88 }
89
90 @Test
91 public void postCompleteEmpty() {
92 TestSubscriber<Integer> ts = new TestSubscriber<>();
93 ArrayDeque<Integer> queue = new ArrayDeque<>();
94 AtomicLong state = new AtomicLong();
95 BooleanSupplier isCancelled = new BooleanSupplier() {
96 @Override
97 public boolean getAsBoolean() throws Exception {
98 return false;
99 }
100 };
101
102 ts.onSubscribe(new BooleanSubscription());
103
104 QueueDrainHelper.postComplete(ts, queue, state, isCancelled);
105
106 ts.assertResult();
107 }
108
109 @Test
110 public void postCompleteWithRequest() {
111 TestSubscriber<Integer> ts = new TestSubscriber<>();
112 ArrayDeque<Integer> queue = new ArrayDeque<>();
113 AtomicLong state = new AtomicLong();
114 BooleanSupplier isCancelled = new BooleanSupplier() {
115 @Override
116 public boolean getAsBoolean() throws Exception {
117 return false;
118 }
119 };
120
121 ts.onSubscribe(new BooleanSubscription());
122 queue.offer(1);
123 state.getAndIncrement();
124
125 QueueDrainHelper.postComplete(ts, queue, state, isCancelled);
126
127 ts.assertResult(1);
128 }
129
130 @Test
131 public void completeRequestRace() {
132 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
133 final TestSubscriber<Integer> ts = new TestSubscriber<>();
134 final ArrayDeque<Integer> queue = new ArrayDeque<>();
135 final AtomicLong state = new AtomicLong();
136 final BooleanSupplier isCancelled = new BooleanSupplier() {
137 @Override
138 public boolean getAsBoolean() throws Exception {
139 return false;
140 }
141 };
142
143 ts.onSubscribe(new BooleanSubscription());
144 queue.offer(1);
145
146 Runnable r1 = new Runnable() {
147 @Override
148 public void run() {
149 QueueDrainHelper.postCompleteRequest(1, ts, queue, state, isCancelled);
150 }
151 };
152
153 Runnable r2 = new Runnable() {
154 @Override
155 public void run() {
156 QueueDrainHelper.postComplete(ts, queue, state, isCancelled);
157 }
158 };
159
160 TestHelper.race(r1, r2);
161
162 ts.assertResult(1);
163 }
164 }
165
166 @Test
167 public void postCompleteCancelled() {
168 final TestSubscriber<Integer> ts = new TestSubscriber<>();
169 ArrayDeque<Integer> queue = new ArrayDeque<>();
170 AtomicLong state = new AtomicLong();
171 BooleanSupplier isCancelled = new BooleanSupplier() {
172 @Override
173 public boolean getAsBoolean() throws Exception {
174 return ts.isCancelled();
175 }
176 };
177
178 ts.onSubscribe(new BooleanSubscription());
179 queue.offer(1);
180 state.getAndIncrement();
181 ts.cancel();
182
183 QueueDrainHelper.postComplete(ts, queue, state, isCancelled);
184
185 ts.assertEmpty();
186 }
187
188 @Test
189 public void postCompleteCancelledAfterOne() {
190 final TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
191 @Override
192 public void onNext(Integer t) {
193 super.onNext(t);
194 cancel();
195 }
196 };
197 ArrayDeque<Integer> queue = new ArrayDeque<>();
198 AtomicLong state = new AtomicLong();
199 BooleanSupplier isCancelled = new BooleanSupplier() {
200 @Override
201 public boolean getAsBoolean() throws Exception {
202 return ts.isCancelled();
203 }
204 };
205
206 ts.onSubscribe(new BooleanSubscription());
207 queue.offer(1);
208 state.getAndIncrement();
209
210 QueueDrainHelper.postComplete(ts, queue, state, isCancelled);
211
212 ts.assertValue(1).assertNoErrors().assertNotComplete();
213 }
214
215 @Test
216 public void drainMaxLoopMissingBackpressure() {
217 TestSubscriber<Integer> ts = new TestSubscriber<>();
218 ts.onSubscribe(new BooleanSubscription());
219
220 QueueDrain<Integer, Integer> qd = new QueueDrain<Integer, Integer>() {
221 @Override
222 public boolean cancelled() {
223 return false;
224 }
225
226 @Override
227 public boolean done() {
228 return false;
229 }
230
231 @Override
232 public Throwable error() {
233 return null;
234 }
235
236 @Override
237 public boolean enter() {
238 return true;
239 }
240
241 @Override
242 public long requested() {
243 return 0;
244 }
245
246 @Override
247 public long produced(long n) {
248 return 0;
249 }
250
251 @Override
252 public int leave(int m) {
253 return 0;
254 }
255
256 @Override
257 public boolean accept(Subscriber<? super Integer> a, Integer v) {
258 return false;
259 }
260 };
261
262 SpscArrayQueue<Integer> q = new SpscArrayQueue<>(32);
263 q.offer(1);
264
265 QueueDrainHelper.drainMaxLoop(q, ts, false, null, qd);
266
267 ts.assertFailure(MissingBackpressureException.class);
268 }
269
270 @Test
271 public void drainMaxLoopMissingBackpressureWithResource() {
272 TestSubscriber<Integer> ts = new TestSubscriber<>();
273 ts.onSubscribe(new BooleanSubscription());
274
275 QueueDrain<Integer, Integer> qd = new QueueDrain<Integer, Integer>() {
276 @Override
277 public boolean cancelled() {
278 return false;
279 }
280
281 @Override
282 public boolean done() {
283 return false;
284 }
285
286 @Override
287 public Throwable error() {
288 return null;
289 }
290
291 @Override
292 public boolean enter() {
293 return true;
294 }
295
296 @Override
297 public long requested() {
298 return 0;
299 }
300
301 @Override
302 public long produced(long n) {
303 return 0;
304 }
305
306 @Override
307 public int leave(int m) {
308 return 0;
309 }
310
311 @Override
312 public boolean accept(Subscriber<? super Integer> a, Integer v) {
313 return false;
314 }
315 };
316
317 SpscArrayQueue<Integer> q = new SpscArrayQueue<>(32);
318 q.offer(1);
319
320 Disposable d = Disposable.empty();
321
322 QueueDrainHelper.drainMaxLoop(q, ts, false, d, qd);
323
324 ts.assertFailure(MissingBackpressureException.class);
325
326 assertTrue(d.isDisposed());
327 }
328
329 @Test
330 public void drainMaxLoopDontAccept() {
331 TestSubscriber<Integer> ts = new TestSubscriber<>();
332 ts.onSubscribe(new BooleanSubscription());
333
334 QueueDrain<Integer, Integer> qd = new QueueDrain<Integer, Integer>() {
335 @Override
336 public boolean cancelled() {
337 return false;
338 }
339
340 @Override
341 public boolean done() {
342 return false;
343 }
344
345 @Override
346 public Throwable error() {
347 return null;
348 }
349
350 @Override
351 public boolean enter() {
352 return true;
353 }
354
355 @Override
356 public long requested() {
357 return 1;
358 }
359
360 @Override
361 public long produced(long n) {
362 return 0;
363 }
364
365 @Override
366 public int leave(int m) {
367 return 0;
368 }
369
370 @Override
371 public boolean accept(Subscriber<? super Integer> a, Integer v) {
372 return false;
373 }
374 };
375
376 SpscArrayQueue<Integer> q = new SpscArrayQueue<>(32);
377 q.offer(1);
378
379 QueueDrainHelper.drainMaxLoop(q, ts, false, null, qd);
380
381 ts.assertEmpty();
382 }
383
384 @Test
385 public void checkTerminatedDelayErrorEmpty() {
386 TestSubscriber<Integer> ts = new TestSubscriber<>();
387 ts.onSubscribe(new BooleanSubscription());
388
389 QueueDrain<Integer, Integer> qd = new QueueDrain<Integer, Integer>() {
390 @Override
391 public boolean cancelled() {
392 return false;
393 }
394
395 @Override
396 public boolean done() {
397 return false;
398 }
399
400 @Override
401 public Throwable error() {
402 return null;
403 }
404
405 @Override
406 public boolean enter() {
407 return true;
408 }
409
410 @Override
411 public long requested() {
412 return 0;
413 }
414
415 @Override
416 public long produced(long n) {
417 return 0;
418 }
419
420 @Override
421 public int leave(int m) {
422 return 0;
423 }
424
425 @Override
426 public boolean accept(Subscriber<? super Integer> a, Integer v) {
427 return false;
428 }
429 };
430
431 SpscArrayQueue<Integer> q = new SpscArrayQueue<>(32);
432
433 QueueDrainHelper.checkTerminated(true, true, ts, true, q, qd);
434
435 ts.assertResult();
436 }
437
438 @Test
439 public void checkTerminatedDelayErrorNonEmpty() {
440 TestSubscriber<Integer> ts = new TestSubscriber<>();
441 ts.onSubscribe(new BooleanSubscription());
442
443 QueueDrain<Integer, Integer> qd = new QueueDrain<Integer, Integer>() {
444 @Override
445 public boolean cancelled() {
446 return false;
447 }
448
449 @Override
450 public boolean done() {
451 return false;
452 }
453
454 @Override
455 public Throwable error() {
456 return null;
457 }
458
459 @Override
460 public boolean enter() {
461 return true;
462 }
463
464 @Override
465 public long requested() {
466 return 0;
467 }
468
469 @Override
470 public long produced(long n) {
471 return 0;
472 }
473
474 @Override
475 public int leave(int m) {
476 return 0;
477 }
478
479 @Override
480 public boolean accept(Subscriber<? super Integer> a, Integer v) {
481 return false;
482 }
483 };
484
485 SpscArrayQueue<Integer> q = new SpscArrayQueue<>(32);
486
487 QueueDrainHelper.checkTerminated(true, false, ts, true, q, qd);
488
489 ts.assertEmpty();
490 }
491
492 @Test
493 public void checkTerminatedDelayErrorEmptyError() {
494 TestSubscriber<Integer> ts = new TestSubscriber<>();
495 ts.onSubscribe(new BooleanSubscription());
496
497 QueueDrain<Integer, Integer> qd = new QueueDrain<Integer, Integer>() {
498 @Override
499 public boolean cancelled() {
500 return false;
501 }
502
503 @Override
504 public boolean done() {
505 return false;
506 }
507
508 @Override
509 public Throwable error() {
510 return new TestException();
511 }
512
513 @Override
514 public boolean enter() {
515 return true;
516 }
517
518 @Override
519 public long requested() {
520 return 0;
521 }
522
523 @Override
524 public long produced(long n) {
525 return 0;
526 }
527
528 @Override
529 public int leave(int m) {
530 return 0;
531 }
532
533 @Override
534 public boolean accept(Subscriber<? super Integer> a, Integer v) {
535 return false;
536 }
537 };
538
539 SpscArrayQueue<Integer> q = new SpscArrayQueue<>(32);
540
541 QueueDrainHelper.checkTerminated(true, true, ts, true, q, qd);
542
543 ts.assertFailure(TestException.class);
544 }
545
546 @Test
547 public void checkTerminatedNonDelayErrorError() {
548 TestSubscriber<Integer> ts = new TestSubscriber<>();
549 ts.onSubscribe(new BooleanSubscription());
550
551 QueueDrain<Integer, Integer> qd = new QueueDrain<Integer, Integer>() {
552 @Override
553 public boolean cancelled() {
554 return false;
555 }
556
557 @Override
558 public boolean done() {
559 return false;
560 }
561
562 @Override
563 public Throwable error() {
564 return new TestException();
565 }
566
567 @Override
568 public boolean enter() {
569 return true;
570 }
571
572 @Override
573 public long requested() {
574 return 0;
575 }
576
577 @Override
578 public long produced(long n) {
579 return 0;
580 }
581
582 @Override
583 public int leave(int m) {
584 return 0;
585 }
586
587 @Override
588 public boolean accept(Subscriber<? super Integer> a, Integer v) {
589 return false;
590 }
591 };
592
593 SpscArrayQueue<Integer> q = new SpscArrayQueue<>(32);
594
595 QueueDrainHelper.checkTerminated(true, false, ts, false, q, qd);
596
597 ts.assertFailure(TestException.class);
598 }
599
600 @Test
601 public void observerCheckTerminatedDelayErrorEmpty() {
602 TestObserver<Integer> to = new TestObserver<>();
603 to.onSubscribe(Disposable.empty());
604
605 ObservableQueueDrain<Integer, Integer> qd = new ObservableQueueDrain<Integer, Integer>() {
606 @Override
607 public boolean cancelled() {
608 return false;
609 }
610
611 @Override
612 public boolean done() {
613 return false;
614 }
615
616 @Override
617 public Throwable error() {
618 return null;
619 }
620
621 @Override
622 public boolean enter() {
623 return true;
624 }
625
626 @Override
627 public int leave(int m) {
628 return 0;
629 }
630
631 @Override
632 public void accept(Observer<? super Integer> a, Integer v) {
633 }
634 };
635
636 SpscArrayQueue<Integer> q = new SpscArrayQueue<>(32);
637
638 QueueDrainHelper.checkTerminated(true, true, to, true, q, null, qd);
639
640 to.assertResult();
641 }
642
643 @Test
644 public void observerCheckTerminatedDelayErrorEmptyResource() {
645 TestObserver<Integer> to = new TestObserver<>();
646 to.onSubscribe(Disposable.empty());
647
648 ObservableQueueDrain<Integer, Integer> qd = new ObservableQueueDrain<Integer, Integer>() {
649 @Override
650 public boolean cancelled() {
651 return false;
652 }
653
654 @Override
655 public boolean done() {
656 return false;
657 }
658
659 @Override
660 public Throwable error() {
661 return null;
662 }
663
664 @Override
665 public boolean enter() {
666 return true;
667 }
668
669 @Override
670 public int leave(int m) {
671 return 0;
672 }
673
674 @Override
675 public void accept(Observer<? super Integer> a, Integer v) {
676 }
677 };
678
679 SpscArrayQueue<Integer> q = new SpscArrayQueue<>(32);
680
681 Disposable d = Disposable.empty();
682
683 QueueDrainHelper.checkTerminated(true, true, to, true, q, d, qd);
684
685 to.assertResult();
686
687 assertTrue(d.isDisposed());
688 }
689
690 @Test
691 public void observerCheckTerminatedDelayErrorNonEmpty() {
692 TestObserver<Integer> to = new TestObserver<>();
693 to.onSubscribe(Disposable.empty());
694
695 ObservableQueueDrain<Integer, Integer> qd = new ObservableQueueDrain<Integer, Integer>() {
696 @Override
697 public boolean cancelled() {
698 return false;
699 }
700
701 @Override
702 public boolean done() {
703 return false;
704 }
705
706 @Override
707 public Throwable error() {
708 return null;
709 }
710
711 @Override
712 public boolean enter() {
713 return true;
714 }
715
716 @Override
717 public int leave(int m) {
718 return 0;
719 }
720
721 @Override
722 public void accept(Observer<? super Integer> a, Integer v) {
723 }
724 };
725
726 SpscArrayQueue<Integer> q = new SpscArrayQueue<>(32);
727
728 QueueDrainHelper.checkTerminated(true, false, to, true, q, null, qd);
729
730 to.assertEmpty();
731 }
732
733 @Test
734 public void observerCheckTerminatedDelayErrorEmptyError() {
735 TestObserver<Integer> to = new TestObserver<>();
736 to.onSubscribe(Disposable.empty());
737
738 ObservableQueueDrain<Integer, Integer> qd = new ObservableQueueDrain<Integer, Integer>() {
739 @Override
740 public boolean cancelled() {
741 return false;
742 }
743
744 @Override
745 public boolean done() {
746 return false;
747 }
748
749 @Override
750 public Throwable error() {
751 return new TestException();
752 }
753
754 @Override
755 public boolean enter() {
756 return true;
757 }
758
759 @Override
760 public int leave(int m) {
761 return 0;
762 }
763
764 @Override
765 public void accept(Observer<? super Integer> a, Integer v) {
766 }
767 };
768
769 SpscArrayQueue<Integer> q = new SpscArrayQueue<>(32);
770
771 QueueDrainHelper.checkTerminated(true, true, to, true, q, null, qd);
772
773 to.assertFailure(TestException.class);
774 }
775
776 @Test
777 public void observerCheckTerminatedNonDelayErrorError() {
778 TestObserver<Integer> to = new TestObserver<>();
779 to.onSubscribe(Disposable.empty());
780
781 ObservableQueueDrain<Integer, Integer> qd = new ObservableQueueDrain<Integer, Integer>() {
782 @Override
783 public boolean cancelled() {
784 return false;
785 }
786
787 @Override
788 public boolean done() {
789 return false;
790 }
791
792 @Override
793 public Throwable error() {
794 return new TestException();
795 }
796
797 @Override
798 public boolean enter() {
799 return true;
800 }
801
802 @Override
803 public int leave(int m) {
804 return 0;
805 }
806
807 @Override
808 public void accept(Observer<? super Integer> a, Integer v) {
809 }
810 };
811
812 SpscArrayQueue<Integer> q = new SpscArrayQueue<>(32);
813
814 QueueDrainHelper.checkTerminated(true, false, to, false, q, null, qd);
815
816 to.assertFailure(TestException.class);
817 }
818
819 @Test
820 public void observerCheckTerminatedNonDelayErrorErrorResource() {
821 TestObserver<Integer> to = new TestObserver<>();
822 to.onSubscribe(Disposable.empty());
823
824 ObservableQueueDrain<Integer, Integer> qd = new ObservableQueueDrain<Integer, Integer>() {
825 @Override
826 public boolean cancelled() {
827 return false;
828 }
829
830 @Override
831 public boolean done() {
832 return false;
833 }
834
835 @Override
836 public Throwable error() {
837 return new TestException();
838 }
839
840 @Override
841 public boolean enter() {
842 return true;
843 }
844
845 @Override
846 public int leave(int m) {
847 return 0;
848 }
849
850 @Override
851 public void accept(Observer<? super Integer> a, Integer v) {
852 }
853 };
854
855 SpscArrayQueue<Integer> q = new SpscArrayQueue<>(32);
856
857 Disposable d = Disposable.empty();
858
859 QueueDrainHelper.checkTerminated(true, false, to, false, q, d, qd);
860
861 to.assertFailure(TestException.class);
862
863 assertTrue(d.isDisposed());
864 }
865
866 @Test
867 public void postCompleteAlreadyComplete() {
868
869 TestSubscriber<Integer> ts = new TestSubscriber<>();
870
871 Queue<Integer> q = new ArrayDeque<>();
872 q.offer(1);
873
874 AtomicLong state = new AtomicLong(QueueDrainHelper.COMPLETED_MASK);
875
876 QueueDrainHelper.postComplete(ts, q, state, new BooleanSupplier() {
877 @Override
878 public boolean getAsBoolean() throws Exception {
879 return false;
880 }
881 });
882 }
883 }