Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableRangeTest.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 static org.junit.Assert.*;
17 import static org.mockito.ArgumentMatchers.any;
18 import static org.mockito.Mockito.*;
19
20 import java.util.*;
21 import java.util.concurrent.atomic.*;
22
23 import org.junit.Test;
24 import org.reactivestreams.Subscriber;
25
26 import io.reactivex.rxjava3.core.*;
27 import io.reactivex.rxjava3.functions.*;
28 import io.reactivex.rxjava3.internal.functions.Functions;
29 import io.reactivex.rxjava3.operators.QueueFuseable;
30 import io.reactivex.rxjava3.subscribers.*;
31 import io.reactivex.rxjava3.testsupport.*;
32
33 public class FlowableRangeTest extends RxJavaTest {
34
35 @Test
36 public void rangeStartAt2Count3() {
37 Subscriber<Integer> subscriber = TestHelper.mockSubscriber();
38
39 Flowable.range(2, 3).subscribe(subscriber);
40
41 verify(subscriber, times(1)).onNext(2);
42 verify(subscriber, times(1)).onNext(3);
43 verify(subscriber, times(1)).onNext(4);
44 verify(subscriber, never()).onNext(5);
45 verify(subscriber, never()).onError(any(Throwable.class));
46 verify(subscriber, times(1)).onComplete();
47 }
48
49 @Test
50 public void rangeUnsubscribe() {
51 Subscriber<Integer> subscriber = TestHelper.mockSubscriber();
52
53 final AtomicInteger count = new AtomicInteger();
54
55 Flowable.range(1, 1000).doOnNext(new Consumer<Integer>() {
56 @Override
57 public void accept(Integer t1) {
58 count.incrementAndGet();
59 }
60 })
61 .take(3).subscribe(subscriber);
62
63 verify(subscriber, times(1)).onNext(1);
64 verify(subscriber, times(1)).onNext(2);
65 verify(subscriber, times(1)).onNext(3);
66 verify(subscriber, never()).onNext(4);
67 verify(subscriber, never()).onError(any(Throwable.class));
68 verify(subscriber, times(1)).onComplete();
69 assertEquals(3, count.get());
70 }
71
72 @Test
73 public void rangeWithZero() {
74 Flowable.range(1, 0);
75 }
76
77 @Test
78 public void rangeWithOverflow2() {
79 Flowable.range(Integer.MAX_VALUE, 0);
80 }
81
82 @Test
83 public void rangeWithOverflow3() {
84 Flowable.range(1, Integer.MAX_VALUE);
85 }
86
87 @Test(expected = IllegalArgumentException.class)
88 public void rangeWithOverflow4() {
89 Flowable.range(2, Integer.MAX_VALUE);
90 }
91
92 @Test
93 public void rangeWithOverflow5() {
94 assertFalse(Flowable.range(Integer.MIN_VALUE, 0).blockingIterable().iterator().hasNext());
95 }
96
97 @Test
98 public void backpressureViaRequest() {
99 Flowable<Integer> f = Flowable.range(1, Flowable.bufferSize());
100
101 TestSubscriberEx<Integer> ts = new TestSubscriberEx<>(0L);
102
103 ts.assertNoValues();
104 ts.request(1);
105
106 f.subscribe(ts);
107
108 ts.assertValue(1);
109
110 ts.request(2);
111 ts.assertValues(1, 2, 3);
112
113 ts.request(3);
114 ts.assertValues(1, 2, 3, 4, 5, 6);
115
116 ts.request(Flowable.bufferSize());
117 ts.assertTerminated();
118 }
119
120 @Test
121 public void noBackpressure() {
122 ArrayList<Integer> list = new ArrayList<>(Flowable.bufferSize() * 2);
123 for (int i = 1; i <= Flowable.bufferSize() * 2 + 1; i++) {
124 list.add(i);
125 }
126
127 Flowable<Integer> f = Flowable.range(1, list.size());
128
129 TestSubscriberEx<Integer> ts = new TestSubscriberEx<>(0L);
130
131 ts.assertNoValues();
132 ts.request(Long.MAX_VALUE); // infinite
133
134 f.subscribe(ts);
135
136 ts.assertValueSequence(list);
137 ts.assertTerminated();
138 }
139 void withBackpressureOneByOne(int start) {
140 Flowable<Integer> source = Flowable.range(start, 100);
141
142 TestSubscriberEx<Integer> ts = new TestSubscriberEx<>(0L);
143 ts.request(1);
144 source.subscribe(ts);
145
146 List<Integer> list = new ArrayList<>(100);
147 for (int i = 0; i < 100; i++) {
148 list.add(i + start);
149 ts.request(1);
150 }
151 ts.assertValueSequence(list);
152 ts.assertTerminated();
153 }
154 void withBackpressureAllAtOnce(int start) {
155 Flowable<Integer> source = Flowable.range(start, 100);
156
157 TestSubscriberEx<Integer> ts = new TestSubscriberEx<>(0L);
158 ts.request(100);
159 source.subscribe(ts);
160
161 List<Integer> list = new ArrayList<>(100);
162 for (int i = 0; i < 100; i++) {
163 list.add(i + start);
164 }
165 ts.assertValueSequence(list);
166 ts.assertTerminated();
167 }
168
169 @Test
170 public void withBackpressure1() {
171 for (int i = 0; i < 100; i++) {
172 withBackpressureOneByOne(i);
173 }
174 }
175
176 @Test
177 public void withBackpressureAllAtOnce() {
178 for (int i = 0; i < 100; i++) {
179 withBackpressureAllAtOnce(i);
180 }
181 }
182
183 @Test
184 public void withBackpressureRequestWayMore() {
185 Flowable<Integer> source = Flowable.range(50, 100);
186
187 TestSubscriberEx<Integer> ts = new TestSubscriberEx<>(0L);
188 ts.request(150);
189 source.subscribe(ts);
190
191 List<Integer> list = new ArrayList<>(100);
192 for (int i = 0; i < 100; i++) {
193 list.add(i + 50);
194 }
195
196 ts.request(50); // and then some
197
198 ts.assertValueSequence(list);
199 ts.assertTerminated();
200 }
201
202 @Test
203 public void requestOverflow() {
204 final AtomicInteger count = new AtomicInteger();
205 int n = 10;
206 Flowable.range(1, n).subscribe(new DefaultSubscriber<Integer>() {
207
208 @Override
209 public void onStart() {
210 request(2);
211 }
212
213 @Override
214 public void onComplete() {
215 //do nothing
216 }
217
218 @Override
219 public void onError(Throwable e) {
220 throw new RuntimeException(e);
221 }
222
223 @Override
224 public void onNext(Integer t) {
225 count.incrementAndGet();
226 request(Long.MAX_VALUE - 1);
227 }});
228 assertEquals(n, count.get());
229 }
230
231 @Test
232 public void emptyRangeSendsOnCompleteEagerlyWithRequestZero() {
233 final AtomicBoolean completed = new AtomicBoolean(false);
234 Flowable.range(1, 0).subscribe(new DefaultSubscriber<Integer>() {
235
236 @Override
237 public void onStart() {
238 // request(0);
239 }
240
241 @Override
242 public void onComplete() {
243 completed.set(true);
244 }
245
246 @Override
247 public void onError(Throwable e) {
248
249 }
250
251 @Override
252 public void onNext(Integer t) {
253
254 }});
255 assertTrue(completed.get());
256 }
257
258 @Test
259 public void nearMaxValueWithoutBackpressure() {
260 TestSubscriber<Integer> ts = new TestSubscriber<>();
261 Flowable.range(Integer.MAX_VALUE - 1, 2).subscribe(ts);
262
263 ts.assertComplete();
264 ts.assertNoErrors();
265 ts.assertValues(Integer.MAX_VALUE - 1, Integer.MAX_VALUE);
266 }
267
268 @Test
269 public void nearMaxValueWithBackpressure() {
270 TestSubscriber<Integer> ts = new TestSubscriber<>(3L);
271 Flowable.range(Integer.MAX_VALUE - 1, 2).subscribe(ts);
272
273 ts.assertComplete();
274 ts.assertNoErrors();
275 ts.assertValues(Integer.MAX_VALUE - 1, Integer.MAX_VALUE);
276 }
277
278 @Test
279 public void negativeCount() {
280 try {
281 Flowable.range(1, -1);
282 fail("Should have thrown IllegalArgumentException");
283 } catch (IllegalArgumentException ex) {
284 assertEquals("count >= 0 required but it was -1", ex.getMessage());
285 }
286 }
287
288 @Test
289 public void requestWrongFusion() {
290 TestSubscriberEx<Integer> ts = new TestSubscriberEx<Integer>().setInitialFusionMode(QueueFuseable.ASYNC);
291
292 Flowable.range(1, 5)
293 .subscribe(ts);
294
295 ts.assertFusionMode(QueueFuseable.NONE)
296 .assertResult(1, 2, 3, 4, 5);
297 }
298
299 @Test
300 public void countOne() {
301 Flowable.range(5495454, 1)
302 .test()
303 .assertResult(5495454);
304 }
305
306 @Test
307 public void fused() {
308 TestSubscriberEx<Integer> ts = new TestSubscriberEx<Integer>().setInitialFusionMode(QueueFuseable.ANY);
309
310 Flowable.range(1, 2).subscribe(ts);
311
312 ts.assertFusionMode(QueueFuseable.SYNC)
313 .assertResult(1, 2);
314 }
315
316 @Test
317 public void fusedReject() {
318 TestSubscriberEx<Integer> ts = new TestSubscriberEx<Integer>().setInitialFusionMode(QueueFuseable.ASYNC);
319
320 Flowable.range(1, 2).subscribe(ts);
321
322 ts.assertFusionMode(QueueFuseable.NONE)
323 .assertResult(1, 2);
324 }
325
326 @Test
327 public void disposed() {
328 TestHelper.checkDisposed(Flowable.range(1, 2));
329 }
330
331 @Test
332 public void fusedClearIsEmpty() {
333 TestHelper.checkFusedIsEmptyClear(Flowable.range(1, 2));
334 }
335
336 @Test
337 public void noOverflow() {
338 Flowable.range(Integer.MAX_VALUE - 1, 2);
339 Flowable.range(Integer.MIN_VALUE, 2);
340 Flowable.range(Integer.MIN_VALUE, Integer.MAX_VALUE);
341 }
342
343 @Test
344 public void conditionalNormal() {
345 Flowable.range(1, 5)
346 .filter(Functions.alwaysTrue())
347 .test()
348 .assertResult(1, 2, 3, 4, 5);
349 }
350
351 @Test
352 public void badRequest() {
353 TestHelper.assertBadRequestReported(Flowable.range(1, 5));
354
355 TestHelper.assertBadRequestReported(Flowable.range(1, 5).filter(Functions.alwaysTrue()));
356 }
357
358 @Test
359 public void conditionalNormalSlowpath() {
360 Flowable.range(1, 5)
361 .filter(Functions.alwaysTrue())
362 .test(5)
363 .assertResult(1, 2, 3, 4, 5);
364 }
365
366 @Test
367 public void conditionalSlowPathTakeExact() {
368 Flowable.range(1, 5)
369 .filter(Functions.alwaysTrue())
370 .take(5)
371 .test()
372 .assertResult(1, 2, 3, 4, 5);
373 }
374
375 @Test
376 public void slowPathTakeExact() {
377 Flowable.range(1, 5)
378 .filter(Functions.alwaysTrue())
379 .take(5)
380 .test()
381 .assertResult(1, 2, 3, 4, 5);
382 }
383
384 @Test
385 public void conditionalSlowPathRebatch() {
386 Flowable.range(1, 5)
387 .filter(Functions.alwaysTrue())
388 .rebatchRequests(1)
389 .test()
390 .assertResult(1, 2, 3, 4, 5);
391 }
392
393 @Test
394 public void slowPathRebatch() {
395 Flowable.range(1, 5)
396 .rebatchRequests(1)
397 .test()
398 .assertResult(1, 2, 3, 4, 5);
399 }
400
401 @Test
402 public void slowPathCancel() {
403 TestSubscriber<Integer> ts = new TestSubscriber<Integer>(2L) {
404 @Override
405 public void onNext(Integer t) {
406 super.onNext(t);
407 cancel();
408 onComplete();
409 }
410 };
411
412 Flowable.range(1, 5)
413 .subscribe(ts);
414
415 ts.assertResult(1);
416 }
417
418 @Test
419 public void fastPathCancel() {
420 TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
421 @Override
422 public void onNext(Integer t) {
423 super.onNext(t);
424 cancel();
425 onComplete();
426 }
427 };
428
429 Flowable.range(1, 5)
430 .subscribe(ts);
431
432 ts.assertResult(1);
433 }
434
435 @Test
436 public void conditionalSlowPathCancel() {
437 TestSubscriber<Integer> ts = new TestSubscriber<Integer>(1L) {
438 @Override
439 public void onNext(Integer t) {
440 super.onNext(t);
441 cancel();
442 onComplete();
443 }
444 };
445
446 Flowable.range(1, 5)
447 .filter(Functions.alwaysTrue())
448 .subscribe(ts);
449
450 ts.assertResult(1);
451 }
452
453 @Test
454 public void conditionalFastPathCancel() {
455 TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
456 @Override
457 public void onNext(Integer t) {
458 super.onNext(t);
459 cancel();
460 onComplete();
461 }
462 };
463
464 Flowable.range(1, 5)
465 .filter(Functions.alwaysTrue())
466 .subscribe(ts);
467
468 ts.assertResult(1);
469 }
470
471 @Test
472 public void conditionalRequestOneByOne() {
473 TestSubscriber<Integer> ts = new TestSubscriber<Integer>(1L) {
474 @Override
475 public void onNext(Integer t) {
476 super.onNext(t);
477 request(1);
478 }
479 };
480
481 Flowable.range(1, 5)
482 .filter(new Predicate<Integer>() {
483 @Override
484 public boolean test(Integer v) throws Exception {
485 return v % 2 == 0;
486 }
487 })
488 .subscribe(ts);
489
490 ts.assertResult(2, 4);
491 }
492
493 @Test
494 public void conditionalRequestOneByOne2() {
495 TestSubscriber<Integer> ts = new TestSubscriber<Integer>(1L) {
496 @Override
497 public void onNext(Integer t) {
498 super.onNext(t);
499 request(1);
500 }
501 };
502
503 Flowable.range(1, 5)
504 .filter(Functions.alwaysTrue())
505 .subscribe(ts);
506
507 ts.assertResult(1, 2, 3, 4, 5);
508 }
509
510 @Test
511 public void fastPathCancelExact() {
512 TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
513 @Override
514 public void onNext(Integer t) {
515 super.onNext(t);
516 if (t == 5L) {
517 cancel();
518 onComplete();
519 }
520 }
521 };
522
523 Flowable.range(1, 5)
524 .subscribe(ts);
525
526 ts.assertResult(1, 2, 3, 4, 5);
527 }
528
529 @Test
530 public void conditionalFastPathCancelExact() {
531 TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
532 @Override
533 public void onNext(Integer t) {
534 super.onNext(t);
535 if (t == 5L) {
536 cancel();
537 onComplete();
538 }
539 }
540 };
541
542 Flowable.range(1, 5)
543 .filter(new Predicate<Integer>() {
544 @Override
545 public boolean test(Integer v) throws Exception {
546 return v % 2 == 0;
547 }
548 })
549 .subscribe(ts);
550
551 ts.assertResult(2, 4);
552 }
553
554 @Test
555 public void conditionalCancel1() {
556 TestSubscriber<Integer> ts = new TestSubscriber<Integer>(2L) {
557 @Override
558 public void onNext(Integer t) {
559 super.onNext(t);
560 if (t == 1) {
561 cancel();
562 onComplete();
563 }
564 }
565 };
566
567 Flowable.range(1, 2)
568 .filter(Functions.alwaysTrue())
569 .subscribe(ts);
570
571 ts.assertResult(1);
572 }
573
574 @Test
575 public void conditionalCancel2() {
576 TestSubscriber<Integer> ts = new TestSubscriber<Integer>(2L) {
577 @Override
578 public void onNext(Integer t) {
579 super.onNext(t);
580 if (t == 2) {
581 cancel();
582 onComplete();
583 }
584 }
585 };
586
587 Flowable.range(1, 2)
588 .filter(Functions.alwaysTrue())
589 .subscribe(ts);
590
591 ts.assertResult(1, 2);
592 }
593
594 @Test
595 public void slowPathCancelBeforeComplete() {
596 Flowable.range(1, 2)
597 .take(2)
598 .test()
599 .assertResult(1, 2);
600 }
601
602 @Test
603 public void conditionalFastPatchCancelBeforeComplete() {
604 TestSubscriber<Integer> ts = new TestSubscriber<>();
605
606 Flowable.range(1, 2)
607 .compose(TestHelper.conditional())
608 .doOnNext(v -> {
609 if (v == 2) {
610 ts.cancel();
611 }
612 })
613 .subscribe(ts);
614
615 ts.assertValuesOnly(1, 2);
616 }
617 }