Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableBufferTest.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.io.IOException;
21 import java.util.*;
22 import java.util.concurrent.*;
23 import java.util.concurrent.atomic.*;
24
25 import org.junit.*;
26 import org.mockito.*;
27 import org.reactivestreams.*;
28
29 import io.reactivex.rxjava3.core.*;
30 import io.reactivex.rxjava3.disposables.Disposable;
31 import io.reactivex.rxjava3.exceptions.*;
32 import io.reactivex.rxjava3.functions.*;
33 import io.reactivex.rxjava3.internal.functions.Functions;
34 import io.reactivex.rxjava3.internal.operators.flowable.FlowableBufferTimed.*;
35 import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
36 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
37 import io.reactivex.rxjava3.processors.*;
38 import io.reactivex.rxjava3.schedulers.*;
39 import io.reactivex.rxjava3.subscribers.*;
40 import io.reactivex.rxjava3.testsupport.TestHelper;
41
42 public class FlowableBufferTest extends RxJavaTest {
43
44 private Subscriber<List<String>> subscriber;
45 private TestScheduler scheduler;
46 private Scheduler.Worker innerScheduler;
47
48 @Before
49 public void before() {
50 subscriber = TestHelper.mockSubscriber();
51 scheduler = new TestScheduler();
52 innerScheduler = scheduler.createWorker();
53 }
54
55 @Test
56 public void complete() {
57 Flowable<String> source = Flowable.empty();
58
59 Flowable<List<String>> buffered = source.buffer(3, 3);
60 buffered.subscribe(subscriber);
61
62 Mockito.verify(subscriber, Mockito.never()).onNext(Mockito.<String>anyList());
63 Mockito.verify(subscriber, Mockito.never()).onError(Mockito.any(Throwable.class));
64 Mockito.verify(subscriber, Mockito.times(1)).onComplete();
65 }
66
67 @Test
68 public void skipAndCountOverlappingBuffers() {
69 Flowable<String> source = Flowable.unsafeCreate(new Publisher<String>() {
70 @Override
71 public void subscribe(Subscriber<? super String> subscriber) {
72 subscriber.onSubscribe(new BooleanSubscription());
73 subscriber.onNext("one");
74 subscriber.onNext("two");
75 subscriber.onNext("three");
76 subscriber.onNext("four");
77 subscriber.onNext("five");
78 }
79 });
80
81 Flowable<List<String>> buffered = source.buffer(3, 1);
82 buffered.subscribe(subscriber);
83
84 InOrder inOrder = Mockito.inOrder(subscriber);
85 inOrder.verify(subscriber, Mockito.times(1)).onNext(list("one", "two", "three"));
86 inOrder.verify(subscriber, Mockito.times(1)).onNext(list("two", "three", "four"));
87 inOrder.verify(subscriber, Mockito.times(1)).onNext(list("three", "four", "five"));
88 inOrder.verify(subscriber, Mockito.never()).onNext(Mockito.<String>anyList());
89 inOrder.verify(subscriber, Mockito.never()).onError(Mockito.any(Throwable.class));
90 inOrder.verify(subscriber, Mockito.never()).onComplete();
91 }
92
93 @Test
94 public void skipAndCountGaplessBuffers() {
95 Flowable<String> source = Flowable.just("one", "two", "three", "four", "five");
96
97 Flowable<List<String>> buffered = source.buffer(3, 3);
98 buffered.subscribe(subscriber);
99
100 InOrder inOrder = Mockito.inOrder(subscriber);
101 inOrder.verify(subscriber, Mockito.times(1)).onNext(list("one", "two", "three"));
102 inOrder.verify(subscriber, Mockito.times(1)).onNext(list("four", "five"));
103 inOrder.verify(subscriber, Mockito.never()).onNext(Mockito.<String>anyList());
104 inOrder.verify(subscriber, Mockito.never()).onError(Mockito.any(Throwable.class));
105 inOrder.verify(subscriber, Mockito.times(1)).onComplete();
106 }
107
108 @Test
109 public void skipAndCountBuffersWithGaps() {
110 Flowable<String> source = Flowable.just("one", "two", "three", "four", "five");
111
112 Flowable<List<String>> buffered = source.buffer(2, 3);
113 buffered.subscribe(subscriber);
114
115 InOrder inOrder = Mockito.inOrder(subscriber);
116 inOrder.verify(subscriber, Mockito.times(1)).onNext(list("one", "two"));
117 inOrder.verify(subscriber, Mockito.times(1)).onNext(list("four", "five"));
118 inOrder.verify(subscriber, Mockito.never()).onNext(Mockito.<String>anyList());
119 inOrder.verify(subscriber, Mockito.never()).onError(Mockito.any(Throwable.class));
120 inOrder.verify(subscriber, Mockito.times(1)).onComplete();
121 }
122
123 @Test
124 public void timedAndCount() {
125 Flowable<String> source = Flowable.unsafeCreate(new Publisher<String>() {
126 @Override
127 public void subscribe(Subscriber<? super String> subscriber) {
128 subscriber.onSubscribe(new BooleanSubscription());
129 push(subscriber, "one", 10);
130 push(subscriber, "two", 90);
131 push(subscriber, "three", 110);
132 push(subscriber, "four", 190);
133 push(subscriber, "five", 210);
134 complete(subscriber, 250);
135 }
136 });
137
138 Flowable<List<String>> buffered = source.buffer(100, TimeUnit.MILLISECONDS, scheduler, 2);
139 buffered.subscribe(subscriber);
140
141 InOrder inOrder = Mockito.inOrder(subscriber);
142 scheduler.advanceTimeTo(100, TimeUnit.MILLISECONDS);
143 inOrder.verify(subscriber, Mockito.times(1)).onNext(list("one", "two"));
144
145 scheduler.advanceTimeTo(200, TimeUnit.MILLISECONDS);
146 inOrder.verify(subscriber, Mockito.times(1)).onNext(list("three", "four"));
147
148 scheduler.advanceTimeTo(300, TimeUnit.MILLISECONDS);
149 inOrder.verify(subscriber, Mockito.times(1)).onNext(list("five"));
150 inOrder.verify(subscriber, Mockito.never()).onNext(Mockito.<String>anyList());
151 inOrder.verify(subscriber, Mockito.never()).onError(Mockito.any(Throwable.class));
152 inOrder.verify(subscriber, Mockito.times(1)).onComplete();
153 }
154
155 @Test
156 public void timed() {
157 Flowable<String> source = Flowable.unsafeCreate(new Publisher<String>() {
158 @Override
159 public void subscribe(Subscriber<? super String> subscriber) {
160 subscriber.onSubscribe(new BooleanSubscription());
161 push(subscriber, "one", 97);
162 push(subscriber, "two", 98);
163 /**
164 * Changed from 100. Because scheduling the cut to 100ms happens before this
165 * Flowable even runs due how lift works, pushing at 100ms would execute after the
166 * buffer cut.
167 */
168 push(subscriber, "three", 99);
169 push(subscriber, "four", 101);
170 push(subscriber, "five", 102);
171 complete(subscriber, 150);
172 }
173 });
174
175 Flowable<List<String>> buffered = source.buffer(100, TimeUnit.MILLISECONDS, scheduler);
176 buffered.subscribe(subscriber);
177
178 InOrder inOrder = Mockito.inOrder(subscriber);
179 scheduler.advanceTimeTo(101, TimeUnit.MILLISECONDS);
180 inOrder.verify(subscriber, Mockito.times(1)).onNext(list("one", "two", "three"));
181
182 scheduler.advanceTimeTo(201, TimeUnit.MILLISECONDS);
183 inOrder.verify(subscriber, Mockito.times(1)).onNext(list("four", "five"));
184 inOrder.verify(subscriber, Mockito.never()).onNext(Mockito.<String>anyList());
185 inOrder.verify(subscriber, Mockito.never()).onError(Mockito.any(Throwable.class));
186 inOrder.verify(subscriber, Mockito.times(1)).onComplete();
187 }
188
189 @Test
190 public void flowableBasedOpenerAndCloser() {
191 Flowable<String> source = Flowable.unsafeCreate(new Publisher<String>() {
192 @Override
193 public void subscribe(Subscriber<? super String> subscriber) {
194 subscriber.onSubscribe(new BooleanSubscription());
195 push(subscriber, "one", 10);
196 push(subscriber, "two", 60);
197 push(subscriber, "three", 110);
198 push(subscriber, "four", 160);
199 push(subscriber, "five", 210);
200 complete(subscriber, 500);
201 }
202 });
203
204 Flowable<Object> openings = Flowable.unsafeCreate(new Publisher<Object>() {
205 @Override
206 public void subscribe(Subscriber<Object> subscriber) {
207 subscriber.onSubscribe(new BooleanSubscription());
208 push(subscriber, new Object(), 50);
209 push(subscriber, new Object(), 200);
210 complete(subscriber, 250);
211 }
212 });
213
214 Function<Object, Flowable<Object>> closer = new Function<Object, Flowable<Object>>() {
215 @Override
216 public Flowable<Object> apply(Object opening) {
217 return Flowable.unsafeCreate(new Publisher<Object>() {
218 @Override
219 public void subscribe(Subscriber<? super Object> subscriber) {
220 subscriber.onSubscribe(new BooleanSubscription());
221 push(subscriber, new Object(), 100);
222 complete(subscriber, 101);
223 }
224 });
225 }
226 };
227
228 Flowable<List<String>> buffered = source.buffer(openings, closer);
229 buffered.subscribe(subscriber);
230
231 InOrder inOrder = Mockito.inOrder(subscriber);
232 scheduler.advanceTimeTo(500, TimeUnit.MILLISECONDS);
233 inOrder.verify(subscriber, Mockito.times(1)).onNext(list("two", "three"));
234 inOrder.verify(subscriber, Mockito.times(1)).onNext(list("five"));
235 inOrder.verify(subscriber, Mockito.never()).onNext(Mockito.<String>anyList());
236 inOrder.verify(subscriber, Mockito.never()).onError(Mockito.any(Throwable.class));
237 inOrder.verify(subscriber, Mockito.times(1)).onComplete();
238 }
239
240 @Test
241 public void longTimeAction() throws InterruptedException {
242 final CountDownLatch latch = new CountDownLatch(1);
243 LongTimeAction action = new LongTimeAction(latch);
244 Flowable.just(1).buffer(10, TimeUnit.MILLISECONDS, 10)
245 .subscribe(action);
246 latch.await();
247 assertFalse(action.fail);
248 }
249
250 static final class LongTimeAction implements Consumer<List<Integer>> {
251
252 CountDownLatch latch;
253 boolean fail;
254
255 LongTimeAction(CountDownLatch latch) {
256 this.latch = latch;
257 }
258
259 @Override
260 public void accept(List<Integer> t1) {
261 try {
262 if (fail) {
263 return;
264 }
265 Thread.sleep(200);
266 } catch (InterruptedException e) {
267 fail = true;
268 } finally {
269 latch.countDown();
270 }
271 }
272 }
273
274 private List<String> list(String... args) {
275 List<String> list = new ArrayList<>();
276 for (String arg : args) {
277 list.add(arg);
278 }
279 return list;
280 }
281
282 private <T> void push(final Subscriber<T> subscriber, final T value, int delay) {
283 innerScheduler.schedule(new Runnable() {
284 @Override
285 public void run() {
286 subscriber.onNext(value);
287 }
288 }, delay, TimeUnit.MILLISECONDS);
289 }
290
291 private void complete(final Subscriber<?> subscriber, int delay) {
292 innerScheduler.schedule(new Runnable() {
293 @Override
294 public void run() {
295 subscriber.onComplete();
296 }
297 }, delay, TimeUnit.MILLISECONDS);
298 }
299
300 @Test
301 public void bufferStopsWhenUnsubscribed1() {
302 Flowable<Integer> source = Flowable.never();
303
304 Subscriber<List<Integer>> subscriber = TestHelper.mockSubscriber();
305 TestSubscriber<List<Integer>> ts = new TestSubscriber<>(subscriber, 0L);
306
307 source.buffer(100, 200, TimeUnit.MILLISECONDS, scheduler)
308 .doOnNext(new Consumer<List<Integer>>() {
309 @Override
310 public void accept(List<Integer> pv) {
311 System.out.println(pv);
312 }
313 })
314 .subscribe(ts);
315
316 InOrder inOrder = Mockito.inOrder(subscriber);
317
318 scheduler.advanceTimeBy(1001, TimeUnit.MILLISECONDS);
319
320 inOrder.verify(subscriber, times(5)).onNext(Arrays.<Integer> asList());
321
322 ts.cancel();
323
324 scheduler.advanceTimeBy(999, TimeUnit.MILLISECONDS);
325
326 inOrder.verifyNoMoreInteractions();
327 }
328
329 @Test
330 public void bufferWithBONormal1() {
331 PublishProcessor<Integer> source = PublishProcessor.create();
332 PublishProcessor<Integer> boundary = PublishProcessor.create();
333
334 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
335 InOrder inOrder = Mockito.inOrder(subscriber);
336
337 source.buffer(boundary).subscribe(subscriber);
338
339 source.onNext(1);
340 source.onNext(2);
341 source.onNext(3);
342
343 boundary.onNext(1);
344
345 inOrder.verify(subscriber, times(1)).onNext(Arrays.asList(1, 2, 3));
346
347 source.onNext(4);
348 source.onNext(5);
349
350 boundary.onNext(2);
351
352 inOrder.verify(subscriber, times(1)).onNext(Arrays.asList(4, 5));
353
354 source.onNext(6);
355 boundary.onComplete();
356
357 inOrder.verify(subscriber, times(1)).onNext(Arrays.asList(6));
358
359 inOrder.verify(subscriber).onComplete();
360
361 verify(subscriber, never()).onError(any(Throwable.class));
362 }
363
364 @Test
365 public void bufferWithBOEmptyLastViaBoundary() {
366 PublishProcessor<Integer> source = PublishProcessor.create();
367 PublishProcessor<Integer> boundary = PublishProcessor.create();
368
369 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
370 InOrder inOrder = Mockito.inOrder(subscriber);
371
372 source.buffer(boundary).subscribe(subscriber);
373
374 boundary.onComplete();
375
376 inOrder.verify(subscriber, times(1)).onNext(Arrays.asList());
377
378 inOrder.verify(subscriber).onComplete();
379
380 verify(subscriber, never()).onError(any(Throwable.class));
381 }
382
383 @Test
384 public void bufferWithBOEmptyLastViaSource() {
385 PublishProcessor<Integer> source = PublishProcessor.create();
386 PublishProcessor<Integer> boundary = PublishProcessor.create();
387
388 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
389 InOrder inOrder = Mockito.inOrder(subscriber);
390
391 source.buffer(boundary).subscribe(subscriber);
392
393 source.onComplete();
394
395 inOrder.verify(subscriber, times(1)).onNext(Arrays.asList());
396
397 inOrder.verify(subscriber).onComplete();
398
399 verify(subscriber, never()).onError(any(Throwable.class));
400 }
401
402 @Test
403 public void bufferWithBOEmptyLastViaBoth() {
404 PublishProcessor<Integer> source = PublishProcessor.create();
405 PublishProcessor<Integer> boundary = PublishProcessor.create();
406
407 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
408 InOrder inOrder = Mockito.inOrder(subscriber);
409
410 source.buffer(boundary).subscribe(subscriber);
411
412 source.onComplete();
413 boundary.onComplete();
414
415 inOrder.verify(subscriber, times(1)).onNext(Arrays.asList());
416
417 inOrder.verify(subscriber).onComplete();
418
419 verify(subscriber, never()).onError(any(Throwable.class));
420 }
421
422 @Test
423 public void bufferWithBOSourceThrows() {
424 PublishProcessor<Integer> source = PublishProcessor.create();
425 PublishProcessor<Integer> boundary = PublishProcessor.create();
426
427 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
428
429 source.buffer(boundary).subscribe(subscriber);
430 source.onNext(1);
431 source.onError(new TestException());
432
433 verify(subscriber).onError(any(TestException.class));
434 verify(subscriber, never()).onComplete();
435 verify(subscriber, never()).onNext(any());
436 }
437
438 @Test
439 public void bufferWithBOBoundaryThrows() {
440 PublishProcessor<Integer> source = PublishProcessor.create();
441 PublishProcessor<Integer> boundary = PublishProcessor.create();
442
443 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
444
445 source.buffer(boundary).subscribe(subscriber);
446
447 source.onNext(1);
448 boundary.onError(new TestException());
449
450 verify(subscriber).onError(any(TestException.class));
451 verify(subscriber, never()).onComplete();
452 verify(subscriber, never()).onNext(any());
453 }
454
455 @Test
456 public void bufferWithSizeTake1() {
457 Flowable<Integer> source = Flowable.just(1).repeat();
458
459 Flowable<List<Integer>> result = source.buffer(2).take(1);
460
461 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
462
463 result.subscribe(subscriber);
464
465 verify(subscriber).onNext(Arrays.asList(1, 1));
466 verify(subscriber).onComplete();
467 verify(subscriber, never()).onError(any(Throwable.class));
468 }
469
470 @Test
471 public void bufferWithSizeSkipTake1() {
472 Flowable<Integer> source = Flowable.just(1).repeat();
473
474 Flowable<List<Integer>> result = source.buffer(2, 3).take(1);
475
476 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
477
478 result.subscribe(subscriber);
479
480 verify(subscriber).onNext(Arrays.asList(1, 1));
481 verify(subscriber).onComplete();
482 verify(subscriber, never()).onError(any(Throwable.class));
483 }
484
485 @Test
486 public void bufferWithTimeTake1() {
487 Flowable<Long> source = Flowable.interval(40, 40, TimeUnit.MILLISECONDS, scheduler);
488
489 Flowable<List<Long>> result = source.buffer(100, TimeUnit.MILLISECONDS, scheduler).take(1);
490
491 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
492
493 result.subscribe(subscriber);
494
495 scheduler.advanceTimeBy(5, TimeUnit.SECONDS);
496
497 verify(subscriber).onNext(Arrays.asList(0L, 1L));
498 verify(subscriber).onComplete();
499 verify(subscriber, never()).onError(any(Throwable.class));
500 }
501
502 @Test
503 public void bufferWithTimeSkipTake2() {
504 Flowable<Long> source = Flowable.interval(40, 40, TimeUnit.MILLISECONDS, scheduler);
505
506 Flowable<List<Long>> result = source.buffer(100, 60, TimeUnit.MILLISECONDS, scheduler).take(2);
507
508 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
509 InOrder inOrder = inOrder(subscriber);
510
511 result.subscribe(subscriber);
512
513 scheduler.advanceTimeBy(5, TimeUnit.SECONDS);
514
515 inOrder.verify(subscriber).onNext(Arrays.asList(0L, 1L));
516 inOrder.verify(subscriber).onNext(Arrays.asList(1L, 2L));
517 inOrder.verify(subscriber).onComplete();
518 verify(subscriber, never()).onError(any(Throwable.class));
519 }
520
521 @Test
522 public void bufferWithBoundaryTake2() {
523 Flowable<Long> boundary = Flowable.interval(60, 60, TimeUnit.MILLISECONDS, scheduler);
524 Flowable<Long> source = Flowable.interval(40, 40, TimeUnit.MILLISECONDS, scheduler);
525
526 Flowable<List<Long>> result = source.buffer(boundary).take(2);
527
528 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
529 InOrder inOrder = inOrder(subscriber);
530
531 result.subscribe(subscriber);
532
533 scheduler.advanceTimeBy(5, TimeUnit.SECONDS);
534
535 inOrder.verify(subscriber).onNext(Arrays.asList(0L));
536 inOrder.verify(subscriber).onNext(Arrays.asList(1L));
537 inOrder.verify(subscriber).onComplete();
538 verify(subscriber, never()).onError(any(Throwable.class));
539
540 }
541
542 @Test
543 public void bufferWithStartEndBoundaryTake2() {
544 Flowable<Long> start = Flowable.interval(61, 61, TimeUnit.MILLISECONDS, scheduler);
545 Function<Long, Flowable<Long>> end = new Function<Long, Flowable<Long>>() {
546 @Override
547 public Flowable<Long> apply(Long t1) {
548 return Flowable.interval(100, 100, TimeUnit.MILLISECONDS, scheduler);
549 }
550 };
551
552 Flowable<Long> source = Flowable.interval(40, 40, TimeUnit.MILLISECONDS, scheduler);
553
554 Flowable<List<Long>> result = source.buffer(start, end).take(2);
555
556 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
557 InOrder inOrder = inOrder(subscriber);
558
559 result
560 .doOnNext(new Consumer<List<Long>>() {
561 @Override
562 public void accept(List<Long> pv) {
563 System.out.println(pv);
564 }
565 })
566 .subscribe(subscriber);
567
568 scheduler.advanceTimeBy(5, TimeUnit.SECONDS);
569
570 inOrder.verify(subscriber).onNext(Arrays.asList(1L, 2L, 3L));
571 inOrder.verify(subscriber).onNext(Arrays.asList(3L, 4L));
572 inOrder.verify(subscriber).onComplete();
573 verify(subscriber, never()).onError(any(Throwable.class));
574 }
575
576 @Test
577 public void bufferWithSizeThrows() {
578 PublishProcessor<Integer> source = PublishProcessor.create();
579
580 Flowable<List<Integer>> result = source.buffer(2);
581
582 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
583
584 InOrder inOrder = inOrder(subscriber);
585
586 result.subscribe(subscriber);
587
588 source.onNext(1);
589 source.onNext(2);
590 source.onNext(3);
591 source.onError(new TestException());
592
593 inOrder.verify(subscriber).onNext(Arrays.asList(1, 2));
594 inOrder.verify(subscriber).onError(any(TestException.class));
595 inOrder.verifyNoMoreInteractions();
596 verify(subscriber, never()).onNext(Arrays.asList(3));
597 verify(subscriber, never()).onComplete();
598
599 }
600
601 @Test
602 public void bufferWithTimeThrows() {
603 PublishProcessor<Integer> source = PublishProcessor.create();
604
605 Flowable<List<Integer>> result = source.buffer(100, TimeUnit.MILLISECONDS, scheduler);
606
607 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
608 InOrder inOrder = inOrder(subscriber);
609
610 result.subscribe(subscriber);
611
612 source.onNext(1);
613 source.onNext(2);
614 scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
615 source.onNext(3);
616 source.onError(new TestException());
617 scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
618
619 inOrder.verify(subscriber).onNext(Arrays.asList(1, 2));
620 inOrder.verify(subscriber).onError(any(TestException.class));
621 inOrder.verifyNoMoreInteractions();
622 verify(subscriber, never()).onNext(Arrays.asList(3));
623 verify(subscriber, never()).onComplete();
624
625 }
626
627 @Test
628 public void bufferWithTimeAndSize() {
629 Flowable<Long> source = Flowable.interval(30, 30, TimeUnit.MILLISECONDS, scheduler);
630
631 Flowable<List<Long>> result = source.buffer(100, TimeUnit.MILLISECONDS, scheduler, 2).take(3);
632
633 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
634 InOrder inOrder = inOrder(subscriber);
635
636 result.subscribe(subscriber);
637
638 scheduler.advanceTimeBy(5, TimeUnit.SECONDS);
639
640 inOrder.verify(subscriber).onNext(Arrays.asList(0L, 1L));
641 inOrder.verify(subscriber).onNext(Arrays.asList(2L));
642 inOrder.verify(subscriber).onComplete();
643 verify(subscriber, never()).onError(any(Throwable.class));
644 }
645
646 @Test
647 public void bufferWithStartEndStartThrows() {
648 PublishProcessor<Integer> start = PublishProcessor.create();
649
650 Function<Integer, Flowable<Integer>> end = new Function<Integer, Flowable<Integer>>() {
651 @Override
652 public Flowable<Integer> apply(Integer t1) {
653 return Flowable.never();
654 }
655 };
656
657 PublishProcessor<Integer> source = PublishProcessor.create();
658
659 Flowable<List<Integer>> result = source.buffer(start, end);
660
661 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
662
663 result.subscribe(subscriber);
664
665 start.onNext(1);
666 source.onNext(1);
667 source.onNext(2);
668 start.onError(new TestException());
669
670 verify(subscriber, never()).onNext(any());
671 verify(subscriber, never()).onComplete();
672 verify(subscriber).onError(any(TestException.class));
673 }
674
675 @Test
676 public void bufferWithStartEndEndFunctionThrows() {
677 PublishProcessor<Integer> start = PublishProcessor.create();
678
679 Function<Integer, Flowable<Integer>> end = new Function<Integer, Flowable<Integer>>() {
680 @Override
681 public Flowable<Integer> apply(Integer t1) {
682 throw new TestException();
683 }
684 };
685
686 PublishProcessor<Integer> source = PublishProcessor.create();
687
688 Flowable<List<Integer>> result = source.buffer(start, end);
689
690 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
691
692 result.subscribe(subscriber);
693
694 start.onNext(1);
695 source.onNext(1);
696 source.onNext(2);
697
698 verify(subscriber, never()).onNext(any());
699 verify(subscriber, never()).onComplete();
700 verify(subscriber).onError(any(TestException.class));
701 }
702
703 @Test
704 public void bufferWithStartEndEndThrows() {
705 PublishProcessor<Integer> start = PublishProcessor.create();
706
707 Function<Integer, Flowable<Integer>> end = new Function<Integer, Flowable<Integer>>() {
708 @Override
709 public Flowable<Integer> apply(Integer t1) {
710 return Flowable.error(new TestException());
711 }
712 };
713
714 PublishProcessor<Integer> source = PublishProcessor.create();
715
716 Flowable<List<Integer>> result = source.buffer(start, end);
717
718 Subscriber<Object> subscriber = TestHelper.mockSubscriber();
719
720 result.subscribe(subscriber);
721
722 start.onNext(1);
723 source.onNext(1);
724 source.onNext(2);
725
726 verify(subscriber, never()).onNext(any());
727 verify(subscriber, never()).onComplete();
728 verify(subscriber).onError(any(TestException.class));
729 }
730
731 @Test
732 public void producerRequestThroughBufferWithSize1() {
733 TestSubscriber<List<Integer>> ts = new TestSubscriber<>(3L);
734
735 final AtomicLong requested = new AtomicLong();
736 Flowable.unsafeCreate(new Publisher<Integer>() {
737
738 @Override
739 public void subscribe(Subscriber<? super Integer> s) {
740 s.onSubscribe(new Subscription() {
741
742 @Override
743 public void request(long n) {
744 requested.set(n);
745 }
746
747 @Override
748 public void cancel() {
749
750 }
751
752 });
753 }
754
755 }).buffer(5, 5).subscribe(ts);
756 assertEquals(15, requested.get());
757
758 ts.request(4);
759 assertEquals(20, requested.get());
760 }
761
762 @Test
763 public void producerRequestThroughBufferWithSize2() {
764 TestSubscriber<List<Integer>> ts = new TestSubscriber<>();
765 final AtomicLong requested = new AtomicLong();
766
767 Flowable.unsafeCreate(new Publisher<Integer>() {
768
769 @Override
770 public void subscribe(Subscriber<? super Integer> s) {
771 s.onSubscribe(new Subscription() {
772
773 @Override
774 public void request(long n) {
775 requested.set(n);
776 }
777
778 @Override
779 public void cancel() {
780
781 }
782
783 });
784 }
785
786 }).buffer(5, 5).subscribe(ts);
787 assertEquals(Long.MAX_VALUE, requested.get());
788 }
789
790 @Test
791 public void producerRequestThroughBufferWithSize3() {
792 TestSubscriber<List<Integer>> ts = new TestSubscriber<>(3L);
793 final AtomicLong requested = new AtomicLong();
794 Flowable.unsafeCreate(new Publisher<Integer>() {
795
796 @Override
797 public void subscribe(Subscriber<? super Integer> s) {
798 s.onSubscribe(new Subscription() {
799
800 @Override
801 public void request(long n) {
802 requested.set(n);
803 }
804
805 @Override
806 public void cancel() {
807
808 }
809
810 });
811 }
812
813 }).buffer(5, 2).subscribe(ts);
814 assertEquals(9, requested.get());
815 ts.request(3);
816 assertEquals(6, requested.get());
817 }
818
819 @Test
820 public void producerRequestThroughBufferWithSize4() {
821 TestSubscriber<List<Integer>> ts = new TestSubscriber<>();
822 final AtomicLong requested = new AtomicLong();
823 Flowable.unsafeCreate(new Publisher<Integer>() {
824
825 @Override
826 public void subscribe(Subscriber<? super Integer> s) {
827 s.onSubscribe(new Subscription() {
828
829 @Override
830 public void request(long n) {
831 requested.set(n);
832 }
833
834 @Override
835 public void cancel() {
836
837 }
838
839 });
840 }
841
842 }).buffer(5, 2).subscribe(ts);
843 assertEquals(Long.MAX_VALUE, requested.get());
844 }
845
846 @Test
847 public void producerRequestOverflowThroughBufferWithSize1() {
848 TestSubscriber<List<Integer>> ts = new TestSubscriber<>(Long.MAX_VALUE >> 1);
849
850 final AtomicLong requested = new AtomicLong();
851
852 Flowable.unsafeCreate(new Publisher<Integer>() {
853
854 @Override
855 public void subscribe(Subscriber<? super Integer> s) {
856 s.onSubscribe(new Subscription() {
857
858 @Override
859 public void request(long n) {
860 requested.set(n);
861 }
862
863 @Override
864 public void cancel() {
865
866 }
867
868 });
869 }
870
871 }).buffer(3, 3).subscribe(ts);
872 assertEquals(Long.MAX_VALUE, requested.get());
873 }
874
875 @Test
876 public void producerRequestOverflowThroughBufferWithSize2() {
877 TestSubscriber<List<Integer>> ts = new TestSubscriber<>(Long.MAX_VALUE >> 1);
878
879 final AtomicLong requested = new AtomicLong();
880
881 Flowable.unsafeCreate(new Publisher<Integer>() {
882
883 @Override
884 public void subscribe(Subscriber<? super Integer> s) {
885 s.onSubscribe(new Subscription() {
886
887 @Override
888 public void request(long n) {
889 requested.set(n);
890 }
891
892 @Override
893 public void cancel() {
894
895 }
896
897 });
898 }
899
900 }).buffer(3, 2).subscribe(ts);
901 assertEquals(Long.MAX_VALUE, requested.get());
902 }
903
904 @Test
905 public void producerRequestOverflowThroughBufferWithSize3() {
906 final AtomicLong requested = new AtomicLong();
907 Flowable.unsafeCreate(new Publisher<Integer>() {
908
909 @Override
910 public void subscribe(final Subscriber<? super Integer> s) {
911 s.onSubscribe(new Subscription() {
912 AtomicBoolean once = new AtomicBoolean();
913 @Override
914 public void request(long n) {
915 requested.set(n);
916 if (once.compareAndSet(false, true)) {
917 s.onNext(1);
918 s.onNext(2);
919 s.onNext(3);
920 }
921 }
922
923 @Override
924 public void cancel() {
925
926 }
927
928 });
929 }
930
931 }).buffer(3, 2).subscribe(new DefaultSubscriber<List<Integer>>() {
932
933 @Override
934 public void onStart() {
935 request(Long.MAX_VALUE / 2 - 4);
936 }
937
938 @Override
939 public void onComplete() {
940 }
941
942 @Override
943 public void onError(Throwable e) {
944 }
945
946 @Override
947 public void onNext(List<Integer> t) {
948 request(Long.MAX_VALUE / 2);
949 }
950
951 });
952 // FIXME I'm not sure why this is MAX_VALUE in 1.x because MAX_VALUE/2 is even and thus can't overflow when multiplied by 2
953 assertEquals(Long.MAX_VALUE - 1, requested.get());
954 }
955
956 @Test
957 public void bufferWithTimeDoesntUnsubscribeDownstream() throws InterruptedException {
958 final Subscriber<Object> subscriber = TestHelper.mockSubscriber();
959
960 final CountDownLatch cdl = new CountDownLatch(1);
961 ResourceSubscriber<Object> s = new ResourceSubscriber<Object>() {
962 @Override
963 public void onNext(Object t) {
964 subscriber.onNext(t);
965 }
966
967 @Override
968 public void onError(Throwable e) {
969 subscriber.onError(e);
970 cdl.countDown();
971 }
972
973 @Override
974 public void onComplete() {
975 subscriber.onComplete();
976 cdl.countDown();
977 }
978 };
979
980 Flowable.range(1, 1).delay(1, TimeUnit.SECONDS).buffer(2, TimeUnit.SECONDS).subscribe(s);
981
982 cdl.await();
983
984 verify(subscriber).onNext(Arrays.asList(1));
985 verify(subscriber).onComplete();
986 verify(subscriber, never()).onError(any(Throwable.class));
987
988 assertFalse(s.isDisposed());
989 }
990
991 @Test
992 public void postCompleteBackpressure() {
993 Flowable<List<Integer>> source = Flowable.range(1, 10).buffer(3, 1);
994
995 TestSubscriber<List<Integer>> ts = TestSubscriber.create(0L);
996
997 source.subscribe(ts);
998
999 ts.assertNoValues();
1000 ts.assertNotComplete();
1001 ts.assertNoErrors();
1002
1003 ts.request(7);
1004
1005 ts.assertValues(
1006 Arrays.asList(1, 2, 3),
1007 Arrays.asList(2, 3, 4),
1008 Arrays.asList(3, 4, 5),
1009 Arrays.asList(4, 5, 6),
1010 Arrays.asList(5, 6, 7),
1011 Arrays.asList(6, 7, 8),
1012 Arrays.asList(7, 8, 9)
1013 );
1014 ts.assertNotComplete();
1015 ts.assertNoErrors();
1016
1017 ts.request(1);
1018
1019 ts.assertValues(
1020 Arrays.asList(1, 2, 3),
1021 Arrays.asList(2, 3, 4),
1022 Arrays.asList(3, 4, 5),
1023 Arrays.asList(4, 5, 6),
1024 Arrays.asList(5, 6, 7),
1025 Arrays.asList(6, 7, 8),
1026 Arrays.asList(7, 8, 9),
1027 Arrays.asList(8, 9, 10)
1028 );
1029 ts.assertNotComplete();
1030 ts.assertNoErrors();
1031
1032 ts.request(1);
1033
1034 ts.assertValues(
1035 Arrays.asList(1, 2, 3),
1036 Arrays.asList(2, 3, 4),
1037 Arrays.asList(3, 4, 5),
1038 Arrays.asList(4, 5, 6),
1039 Arrays.asList(5, 6, 7),
1040 Arrays.asList(6, 7, 8),
1041 Arrays.asList(7, 8, 9),
1042 Arrays.asList(8, 9, 10),
1043 Arrays.asList(9, 10)
1044 );
1045 ts.assertNotComplete();
1046 ts.assertNoErrors();
1047
1048 ts.request(1);
1049
1050 ts.assertValues(
1051 Arrays.asList(1, 2, 3),
1052 Arrays.asList(2, 3, 4),
1053 Arrays.asList(3, 4, 5),
1054 Arrays.asList(4, 5, 6),
1055 Arrays.asList(5, 6, 7),
1056 Arrays.asList(6, 7, 8),
1057 Arrays.asList(7, 8, 9),
1058 Arrays.asList(8, 9, 10),
1059 Arrays.asList(9, 10),
1060 Arrays.asList(10)
1061 );
1062 ts.assertComplete();
1063 ts.assertNoErrors();
1064 }
1065
1066 @Test
1067 public void timeAndSkipOverlap() {
1068
1069 PublishProcessor<Integer> pp = PublishProcessor.create();
1070
1071 TestSubscriber<List<Integer>> ts = TestSubscriber.create();
1072
1073 pp.buffer(2, 1, TimeUnit.SECONDS, scheduler).subscribe(ts);
1074
1075 pp.onNext(1);
1076
1077 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
1078
1079 pp.onNext(2);
1080
1081 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
1082
1083 pp.onNext(3);
1084
1085 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
1086
1087 pp.onNext(4);
1088
1089 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
1090
1091 pp.onComplete();
1092
1093 ts.assertValues(
1094 Arrays.asList(1, 2),
1095 Arrays.asList(2, 3),
1096 Arrays.asList(3, 4),
1097 Arrays.asList(4),
1098 Collections.<Integer>emptyList()
1099 );
1100
1101 ts.assertNoErrors();
1102 ts.assertComplete();
1103 }
1104
1105 @Test
1106 public void timeAndSkipSkip() {
1107
1108 PublishProcessor<Integer> pp = PublishProcessor.create();
1109
1110 TestSubscriber<List<Integer>> ts = TestSubscriber.create();
1111
1112 pp.buffer(2, 3, TimeUnit.SECONDS, scheduler).subscribe(ts);
1113
1114 pp.onNext(1);
1115
1116 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
1117
1118 pp.onNext(2);
1119
1120 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
1121
1122 pp.onNext(3);
1123
1124 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
1125
1126 pp.onNext(4);
1127
1128 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
1129
1130 pp.onComplete();
1131
1132 ts.assertValues(
1133 Arrays.asList(1, 2),
1134 Arrays.asList(4)
1135 );
1136
1137 ts.assertNoErrors();
1138 ts.assertComplete();
1139 }
1140
1141 @Test
1142 public void timeAndSkipOverlapScheduler() {
1143
1144 RxJavaPlugins.setComputationSchedulerHandler(new Function<Scheduler, Scheduler>() {
1145 @Override
1146 public Scheduler apply(Scheduler t) {
1147 return scheduler;
1148 }
1149 });
1150
1151 try {
1152 PublishProcessor<Integer> pp = PublishProcessor.create();
1153
1154 TestSubscriber<List<Integer>> ts = TestSubscriber.create();
1155
1156 pp.buffer(2, 1, TimeUnit.SECONDS).subscribe(ts);
1157
1158 pp.onNext(1);
1159
1160 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
1161
1162 pp.onNext(2);
1163
1164 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
1165
1166 pp.onNext(3);
1167
1168 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
1169
1170 pp.onNext(4);
1171
1172 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
1173
1174 pp.onComplete();
1175
1176 ts.assertValues(
1177 Arrays.asList(1, 2),
1178 Arrays.asList(2, 3),
1179 Arrays.asList(3, 4),
1180 Arrays.asList(4),
1181 Collections.<Integer>emptyList()
1182 );
1183
1184 ts.assertNoErrors();
1185 ts.assertComplete();
1186 } finally {
1187 RxJavaPlugins.reset();
1188 }
1189 }
1190
1191 @Test
1192 public void timeAndSkipSkipDefaultScheduler() {
1193 RxJavaPlugins.setComputationSchedulerHandler(new Function<Scheduler, Scheduler>() {
1194 @Override
1195 public Scheduler apply(Scheduler t) {
1196 return scheduler;
1197 }
1198 });
1199
1200 try {
1201
1202 PublishProcessor<Integer> pp = PublishProcessor.create();
1203
1204 TestSubscriber<List<Integer>> ts = TestSubscriber.create();
1205
1206 pp.buffer(2, 3, TimeUnit.SECONDS).subscribe(ts);
1207
1208 pp.onNext(1);
1209
1210 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
1211
1212 pp.onNext(2);
1213
1214 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
1215
1216 pp.onNext(3);
1217
1218 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
1219
1220 pp.onNext(4);
1221
1222 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
1223
1224 pp.onComplete();
1225
1226 ts.assertValues(
1227 Arrays.asList(1, 2),
1228 Arrays.asList(4)
1229 );
1230
1231 ts.assertNoErrors();
1232 ts.assertComplete();
1233 } finally {
1234 RxJavaPlugins.reset();
1235 }
1236 }
1237
1238 @Test
1239 public void bufferBoundaryHint() {
1240 Flowable.range(1, 5).buffer(Flowable.timer(1, TimeUnit.MINUTES), 2)
1241 .test()
1242 .assertResult(Arrays.asList(1, 2, 3, 4, 5));
1243 }
1244
1245 static HashSet<Integer> set(Integer... values) {
1246 return new HashSet<>(Arrays.asList(values));
1247 }
1248
1249 @Test
1250 public void bufferIntoCustomCollection() {
1251 Flowable.just(1, 1, 2, 2, 3, 3, 4, 4)
1252 .buffer(3, new Supplier<Collection<Integer>>() {
1253 @Override
1254 public Collection<Integer> get() throws Exception {
1255 return new HashSet<>();
1256 }
1257 })
1258 .test()
1259 .assertResult(set(1, 2), set(2, 3), set(4));
1260 }
1261
1262 @Test
1263 public void bufferSkipIntoCustomCollection() {
1264 Flowable.just(1, 1, 2, 2, 3, 3, 4, 4)
1265 .buffer(3, 3, new Supplier<Collection<Integer>>() {
1266 @Override
1267 public Collection<Integer> get() throws Exception {
1268 return new HashSet<>();
1269 }
1270 })
1271 .test()
1272 .assertResult(set(1, 2), set(2, 3), set(4));
1273 }
1274
1275 @Test
1276 public void bufferTimeSkipDefault() {
1277 Flowable.range(1, 5).buffer(1, 1, TimeUnit.MINUTES)
1278 .test()
1279 .assertResult(Arrays.asList(1, 2, 3, 4, 5));
1280 }
1281
1282 @Test
1283 public void dispose() {
1284 TestHelper.checkDisposed(Flowable.range(1, 5).buffer(1, TimeUnit.DAYS, Schedulers.single()));
1285
1286 TestHelper.checkDisposed(Flowable.range(1, 5).buffer(2, 1, TimeUnit.DAYS, Schedulers.single()));
1287
1288 TestHelper.checkDisposed(Flowable.range(1, 5).buffer(1, 2, TimeUnit.DAYS, Schedulers.single()));
1289
1290 TestHelper.checkDisposed(Flowable.range(1, 5)
1291 .buffer(1, TimeUnit.DAYS, Schedulers.single(), 2, Functions.<Integer>createArrayList(16), true));
1292
1293 TestHelper.checkDisposed(Flowable.range(1, 5).buffer(1));
1294
1295 TestHelper.checkDisposed(Flowable.range(1, 5).buffer(2, 1));
1296
1297 TestHelper.checkDisposed(Flowable.range(1, 5).buffer(1, 2));
1298 }
1299
1300 @Test
1301 public void supplierReturnsNull() {
1302 Flowable.<Integer>never()
1303 .buffer(1, TimeUnit.MILLISECONDS, Schedulers.single(), Integer.MAX_VALUE, new Supplier<Collection<Integer>>() {
1304 int count;
1305 @Override
1306 public Collection<Integer> get() throws Exception {
1307 if (count++ == 1) {
1308 return null;
1309 } else {
1310 return new ArrayList<>();
1311 }
1312 }
1313 }, false)
1314 .test()
1315 .awaitDone(5, TimeUnit.SECONDS)
1316 .assertFailure(NullPointerException.class);
1317 }
1318
1319 @Test
1320 public void supplierReturnsNull2() {
1321 Flowable.<Integer>never()
1322 .buffer(1, TimeUnit.MILLISECONDS, Schedulers.single(), 10, new Supplier<Collection<Integer>>() {
1323 int count;
1324 @Override
1325 public Collection<Integer> get() throws Exception {
1326 if (count++ == 1) {
1327 return null;
1328 } else {
1329 return new ArrayList<>();
1330 }
1331 }
1332 }, false)
1333 .test()
1334 .awaitDone(5, TimeUnit.SECONDS)
1335 .assertFailure(NullPointerException.class);
1336 }
1337
1338 @Test
1339 public void supplierReturnsNull3() {
1340 Flowable.<Integer>never()
1341 .buffer(2, 1, TimeUnit.MILLISECONDS, Schedulers.single(), new Supplier<Collection<Integer>>() {
1342 int count;
1343 @Override
1344 public Collection<Integer> get() throws Exception {
1345 if (count++ == 1) {
1346 return null;
1347 } else {
1348 return new ArrayList<>();
1349 }
1350 }
1351 })
1352 .test()
1353 .awaitDone(5, TimeUnit.SECONDS)
1354 .assertFailure(NullPointerException.class);
1355 }
1356
1357 @Test
1358 public void supplierThrows() {
1359 Flowable.just(1)
1360 .buffer(1, TimeUnit.SECONDS, Schedulers.single(), Integer.MAX_VALUE, new Supplier<Collection<Integer>>() {
1361 @Override
1362 public Collection<Integer> get() throws Exception {
1363 throw new TestException();
1364 }
1365 }, false)
1366 .test()
1367 .assertFailure(TestException.class);
1368 }
1369
1370 @Test
1371 public void supplierThrows2() {
1372 Flowable.just(1)
1373 .buffer(1, TimeUnit.SECONDS, Schedulers.single(), 10, new Supplier<Collection<Integer>>() {
1374 @Override
1375 public Collection<Integer> get() throws Exception {
1376 throw new TestException();
1377 }
1378 }, false)
1379 .test()
1380 .assertFailure(TestException.class);
1381 }
1382
1383 @Test
1384 public void supplierThrows3() {
1385 Flowable.just(1)
1386 .buffer(2, 1, TimeUnit.SECONDS, Schedulers.single(), new Supplier<Collection<Integer>>() {
1387 @Override
1388 public Collection<Integer> get() throws Exception {
1389 throw new TestException();
1390 }
1391 })
1392 .test()
1393 .assertFailure(TestException.class);
1394 }
1395
1396 @Test
1397 public void supplierThrows4() {
1398 Flowable.<Integer>never()
1399 .buffer(1, TimeUnit.MILLISECONDS, Schedulers.single(), Integer.MAX_VALUE, new Supplier<Collection<Integer>>() {
1400 int count;
1401 @Override
1402 public Collection<Integer> get() throws Exception {
1403 if (count++ == 1) {
1404 throw new TestException();
1405 } else {
1406 return new ArrayList<>();
1407 }
1408 }
1409 }, false)
1410 .test()
1411 .awaitDone(5, TimeUnit.SECONDS)
1412 .assertFailure(TestException.class);
1413 }
1414
1415 @Test
1416 public void supplierThrows5() {
1417 Flowable.<Integer>never()
1418 .buffer(1, TimeUnit.MILLISECONDS, Schedulers.single(), 10, new Supplier<Collection<Integer>>() {
1419 int count;
1420 @Override
1421 public Collection<Integer> get() throws Exception {
1422 if (count++ == 1) {
1423 throw new TestException();
1424 } else {
1425 return new ArrayList<>();
1426 }
1427 }
1428 }, false)
1429 .test()
1430 .awaitDone(5, TimeUnit.SECONDS)
1431 .assertFailure(TestException.class);
1432 }
1433
1434 @Test
1435 public void supplierThrows6() {
1436 Flowable.<Integer>never()
1437 .buffer(2, 1, TimeUnit.MILLISECONDS, Schedulers.single(), new Supplier<Collection<Integer>>() {
1438 int count;
1439 @Override
1440 public Collection<Integer> get() throws Exception {
1441 if (count++ == 1) {
1442 throw new TestException();
1443 } else {
1444 return new ArrayList<>();
1445 }
1446 }
1447 })
1448 .test()
1449 .awaitDone(5, TimeUnit.SECONDS)
1450 .assertFailure(TestException.class);
1451 }
1452
1453 @Test
1454 public void restartTimer() {
1455 Flowable.range(1, 5)
1456 .buffer(1, TimeUnit.DAYS, Schedulers.single(), 2, Functions.<Integer>createArrayList(16), true)
1457 .test()
1458 .assertResult(Arrays.asList(1, 2), Arrays.asList(3, 4), Arrays.asList(5));
1459 }
1460
1461 @Test
1462 public void bufferSkipError() {
1463 Flowable.<Integer>error(new TestException())
1464 .buffer(2, 1)
1465 .test()
1466 .assertFailure(TestException.class);
1467 }
1468
1469 @Test
1470 public void bufferSupplierCrash2() {
1471 Flowable.range(1, 2)
1472 .buffer(1, new Supplier<List<Integer>>() {
1473 int calls;
1474 @Override
1475 public List<Integer> get() throws Exception {
1476 if (++calls == 2) {
1477 throw new TestException();
1478 }
1479 return new ArrayList<>();
1480 }
1481 })
1482 .test()
1483 .assertFailure(TestException.class, Arrays.asList(1));
1484 }
1485
1486 @Test
1487 public void bufferSkipSupplierCrash2() {
1488 Flowable.range(1, 2)
1489 .buffer(1, 2, new Supplier<List<Integer>>() {
1490 int calls;
1491 @Override
1492 public List<Integer> get() throws Exception {
1493 if (++calls == 1) {
1494 throw new TestException();
1495 }
1496 return new ArrayList<>();
1497 }
1498 })
1499 .test()
1500 .assertFailure(TestException.class);
1501 }
1502
1503 @Test
1504 public void bufferOverlapSupplierCrash2() {
1505 Flowable.range(1, 2)
1506 .buffer(2, 1, new Supplier<List<Integer>>() {
1507 int calls;
1508 @Override
1509 public List<Integer> get() throws Exception {
1510 if (++calls == 2) {
1511 throw new TestException();
1512 }
1513 return new ArrayList<>();
1514 }
1515 })
1516 .test()
1517 .assertFailure(TestException.class);
1518 }
1519
1520 @Test
1521 public void bufferSkipOverlap() {
1522 Flowable.range(1, 5)
1523 .buffer(5, 1)
1524 .test()
1525 .assertResult(
1526 Arrays.asList(1, 2, 3, 4, 5),
1527 Arrays.asList(2, 3, 4, 5),
1528 Arrays.asList(3, 4, 5),
1529 Arrays.asList(4, 5),
1530 Arrays.asList(5)
1531 );
1532 }
1533
1534 @Test
1535 public void bufferTimedExactError() {
1536 Flowable.error(new TestException())
1537 .buffer(1, TimeUnit.DAYS)
1538 .test()
1539 .assertFailure(TestException.class);
1540 }
1541
1542 @Test
1543 public void bufferTimedSkipError() {
1544 Flowable.error(new TestException())
1545 .buffer(1, 2, TimeUnit.DAYS)
1546 .test()
1547 .assertFailure(TestException.class);
1548 }
1549
1550 @Test
1551 public void bufferTimedOverlapError() {
1552 Flowable.error(new TestException())
1553 .buffer(2, 1, TimeUnit.DAYS)
1554 .test()
1555 .assertFailure(TestException.class);
1556 }
1557
1558 @Test
1559 public void bufferTimedExactEmpty() {
1560 Flowable.empty()
1561 .buffer(1, TimeUnit.DAYS)
1562 .test()
1563 .assertResult(Collections.emptyList());
1564 }
1565
1566 @Test
1567 public void bufferTimedSkipEmpty() {
1568 Flowable.empty()
1569 .buffer(1, 2, TimeUnit.DAYS)
1570 .test()
1571 .assertResult(Collections.emptyList());
1572 }
1573
1574 @Test
1575 public void bufferTimedOverlapEmpty() {
1576 Flowable.empty()
1577 .buffer(2, 1, TimeUnit.DAYS)
1578 .test()
1579 .assertResult(Collections.emptyList());
1580 }
1581
1582 @Test
1583 public void bufferTimedExactSupplierCrash() {
1584 TestScheduler scheduler = new TestScheduler();
1585
1586 PublishProcessor<Integer> pp = PublishProcessor.create();
1587
1588 TestSubscriber<List<Integer>> ts = pp
1589 .buffer(1, TimeUnit.MILLISECONDS, scheduler, 1, new Supplier<List<Integer>>() {
1590 int calls;
1591 @Override
1592 public List<Integer> get() throws Exception {
1593 if (++calls == 2) {
1594 throw new TestException();
1595 }
1596 return new ArrayList<>();
1597 }
1598 }, true)
1599 .test();
1600
1601 pp.onNext(1);
1602
1603 scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS);
1604
1605 pp.onNext(2);
1606
1607 ts
1608 .assertFailure(TestException.class, Arrays.asList(1));
1609 }
1610
1611 @Test
1612 public void bufferTimedExactBoundedError() {
1613 TestScheduler scheduler = new TestScheduler();
1614
1615 PublishProcessor<Integer> pp = PublishProcessor.create();
1616
1617 TestSubscriber<List<Integer>> ts = pp
1618 .buffer(1, TimeUnit.MILLISECONDS, scheduler, 1, Functions.<Integer>createArrayList(16), true)
1619 .test();
1620
1621 pp.onError(new TestException());
1622
1623 ts
1624 .assertFailure(TestException.class);
1625 }
1626
1627 @Test
1628 public void badSource() {
1629 TestHelper.checkBadSourceFlowable(new Function<Flowable<Integer>, Object>() {
1630 @Override
1631 public Object apply(Flowable<Integer> f) throws Exception {
1632 return f.buffer(1);
1633 }
1634 }, false, 1, 1, Arrays.asList(1));
1635
1636 TestHelper.checkBadSourceFlowable(new Function<Flowable<Integer>, Object>() {
1637 @Override
1638 public Object apply(Flowable<Integer> f) throws Exception {
1639 return f.buffer(1, 2);
1640 }
1641 }, false, 1, 1, Arrays.asList(1));
1642
1643 TestHelper.checkBadSourceFlowable(new Function<Flowable<Integer>, Object>() {
1644 @Override
1645 public Object apply(Flowable<Integer> f) throws Exception {
1646 return f.buffer(2, 1);
1647 }
1648 }, false, 1, 1, Arrays.asList(1));
1649 }
1650
1651 @Test
1652 public void doubleOnSubscribe() {
1653 TestHelper.checkDoubleOnSubscribeFlowable(new Function<Flowable<Object>, Publisher<List<Object>>>() {
1654 @Override
1655 public Publisher<List<Object>> apply(Flowable<Object> f) throws Exception {
1656 return f.buffer(1);
1657 }
1658 });
1659
1660 TestHelper.checkDoubleOnSubscribeFlowable(new Function<Flowable<Object>, Publisher<List<Object>>>() {
1661 @Override
1662 public Publisher<List<Object>> apply(Flowable<Object> f) throws Exception {
1663 return f.buffer(1, 2);
1664 }
1665 });
1666
1667 TestHelper.checkDoubleOnSubscribeFlowable(new Function<Flowable<Object>, Publisher<List<Object>>>() {
1668 @Override
1669 public Publisher<List<Object>> apply(Flowable<Object> f) throws Exception {
1670 return f.buffer(2, 1);
1671 }
1672 });
1673 }
1674
1675 @Test
1676 public void badRequest() {
1677 TestHelper.assertBadRequestReported(PublishProcessor.create().buffer(1));
1678
1679 TestHelper.assertBadRequestReported(PublishProcessor.create().buffer(1, 2));
1680
1681 TestHelper.assertBadRequestReported(PublishProcessor.create().buffer(2, 1));
1682 }
1683
1684 @Test
1685 public void skipError() {
1686 Flowable.error(new TestException())
1687 .buffer(1, 2)
1688 .test()
1689 .assertFailure(TestException.class);
1690 }
1691
1692 @Test
1693 public void skipSingleResult() {
1694 Flowable.just(1)
1695 .buffer(2, 3)
1696 .test()
1697 .assertResult(Arrays.asList(1));
1698 }
1699
1700 @Test
1701 public void skipBackpressure() {
1702 Flowable.range(1, 10)
1703 .buffer(2, 3)
1704 .rebatchRequests(1)
1705 .test()
1706 .assertResult(Arrays.asList(1, 2), Arrays.asList(4, 5), Arrays.asList(7, 8), Arrays.asList(10));
1707 }
1708
1709 @Test
1710 public void withTimeAndSizeCapacityRace() {
1711 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
1712 final TestScheduler scheduler = new TestScheduler();
1713
1714 final PublishProcessor<Object> pp = PublishProcessor.create();
1715
1716 TestSubscriber<List<Object>> ts = pp.buffer(1, TimeUnit.SECONDS, scheduler, 5).test();
1717
1718 pp.onNext(1);
1719 pp.onNext(2);
1720 pp.onNext(3);
1721 pp.onNext(4);
1722
1723 Runnable r1 = new Runnable() {
1724 @Override
1725 public void run() {
1726 pp.onNext(5);
1727 }
1728 };
1729
1730 Runnable r2 = new Runnable() {
1731 @Override
1732 public void run() {
1733 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
1734 }
1735 };
1736
1737 TestHelper.race(r1, r2);
1738
1739 pp.onComplete();
1740
1741 int items = 0;
1742 for (List<Object> o : ts.values()) {
1743 items += o.size();
1744 }
1745
1746 assertEquals("Round: " + i, 5, items);
1747 }
1748 }
1749
1750 @Test
1751 public void noCompletionCancelExact() {
1752 final AtomicInteger counter = new AtomicInteger();
1753
1754 Flowable.<Integer>empty()
1755 .doOnCancel(new Action() {
1756 @Override
1757 public void run() throws Exception {
1758 counter.getAndIncrement();
1759 }
1760 })
1761 .buffer(5, TimeUnit.SECONDS)
1762 .test()
1763 .awaitDone(5, TimeUnit.SECONDS)
1764 .assertResult(Collections.<Integer>emptyList());
1765
1766 assertEquals(0, counter.get());
1767 }
1768
1769 @Test
1770 public void noCompletionCancelSkip() {
1771 final AtomicInteger counter = new AtomicInteger();
1772
1773 Flowable.<Integer>empty()
1774 .doOnCancel(new Action() {
1775 @Override
1776 public void run() throws Exception {
1777 counter.getAndIncrement();
1778 }
1779 })
1780 .buffer(5, 10, TimeUnit.SECONDS)
1781 .test()
1782 .awaitDone(5, TimeUnit.SECONDS)
1783 .assertResult(Collections.<Integer>emptyList());
1784
1785 assertEquals(0, counter.get());
1786 }
1787
1788 @Test
1789 public void noCompletionCancelOverlap() {
1790 final AtomicInteger counter = new AtomicInteger();
1791
1792 Flowable.<Integer>empty()
1793 .doOnCancel(new Action() {
1794 @Override
1795 public void run() throws Exception {
1796 counter.getAndIncrement();
1797 }
1798 })
1799 .buffer(10, 5, TimeUnit.SECONDS)
1800 .test()
1801 .awaitDone(5, TimeUnit.SECONDS)
1802 .assertResult(Collections.<Integer>emptyList());
1803
1804 assertEquals(0, counter.get());
1805 }
1806
1807 @Test
1808 public void boundaryOpenCloseDisposedOnComplete() {
1809 PublishProcessor<Integer> source = PublishProcessor.create();
1810
1811 PublishProcessor<Integer> openIndicator = PublishProcessor.create();
1812
1813 PublishProcessor<Integer> closeIndicator = PublishProcessor.create();
1814
1815 TestSubscriber<List<Integer>> ts = source
1816 .buffer(openIndicator, Functions.justFunction(closeIndicator))
1817 .test();
1818
1819 assertTrue(source.hasSubscribers());
1820 assertTrue(openIndicator.hasSubscribers());
1821 assertFalse(closeIndicator.hasSubscribers());
1822
1823 openIndicator.onNext(1);
1824
1825 assertTrue(openIndicator.hasSubscribers());
1826 assertTrue(closeIndicator.hasSubscribers());
1827
1828 source.onComplete();
1829
1830 ts.assertResult(Collections.<Integer>emptyList());
1831
1832 assertFalse(openIndicator.hasSubscribers());
1833 assertFalse(closeIndicator.hasSubscribers());
1834 }
1835
1836 @Test
1837 public void bufferedCanCompleteIfOpenNeverCompletesDropping() {
1838 Flowable.range(1, 50)
1839 .zipWith(Flowable.interval(5, TimeUnit.MILLISECONDS),
1840 new BiFunction<Integer, Long, Integer>() {
1841 @Override
1842 public Integer apply(Integer integer, Long aLong) {
1843 return integer;
1844 }
1845 })
1846 .buffer(Flowable.interval(0, 200, TimeUnit.MILLISECONDS),
1847 new Function<Long, Publisher<?>>() {
1848 @Override
1849 public Publisher<?> apply(Long a) {
1850 return Flowable.just(a).delay(100, TimeUnit.MILLISECONDS);
1851 }
1852 })
1853 .to(TestHelper.<List<Integer>>testConsumer())
1854 .assertSubscribed()
1855 .awaitDone(3, TimeUnit.SECONDS)
1856 .assertComplete();
1857 }
1858
1859 @Test
1860 public void bufferedCanCompleteIfOpenNeverCompletesOverlapping() {
1861 Flowable.range(1, 50)
1862 .zipWith(Flowable.interval(5, TimeUnit.MILLISECONDS),
1863 new BiFunction<Integer, Long, Integer>() {
1864 @Override
1865 public Integer apply(Integer integer, Long aLong) {
1866 return integer;
1867 }
1868 })
1869 .buffer(Flowable.interval(0, 100, TimeUnit.MILLISECONDS),
1870 new Function<Long, Publisher<?>>() {
1871 @Override
1872 public Publisher<?> apply(Long a) {
1873 return Flowable.just(a).delay(200, TimeUnit.MILLISECONDS);
1874 }
1875 })
1876 .to(TestHelper.<List<Integer>>testConsumer())
1877 .assertSubscribed()
1878 .awaitDone(3, TimeUnit.SECONDS)
1879 .assertComplete();
1880 }
1881
1882 @Test
1883 public void openClosemainError() {
1884 Flowable.error(new TestException())
1885 .buffer(Flowable.never(), Functions.justFunction(Flowable.never()))
1886 .test()
1887 .assertFailure(TestException.class);
1888 }
1889
1890 @Test
1891 public void openClosebadSource() {
1892 List<Throwable> errors = TestHelper.trackPluginErrors();
1893 try {
1894 new Flowable<Object>() {
1895 @Override
1896 protected void subscribeActual(Subscriber<? super Object> s) {
1897 BooleanSubscription bs1 = new BooleanSubscription();
1898 BooleanSubscription bs2 = new BooleanSubscription();
1899
1900 s.onSubscribe(bs1);
1901
1902 assertFalse(bs1.isCancelled());
1903 assertFalse(bs2.isCancelled());
1904
1905 s.onSubscribe(bs2);
1906
1907 assertFalse(bs1.isCancelled());
1908 assertTrue(bs2.isCancelled());
1909
1910 s.onError(new IOException());
1911 s.onComplete();
1912 s.onNext(1);
1913 s.onError(new TestException());
1914 }
1915 }
1916 .buffer(Flowable.never(), Functions.justFunction(Flowable.never()))
1917 .test()
1918 .assertFailure(IOException.class);
1919
1920 TestHelper.assertError(errors, 0, ProtocolViolationException.class);
1921 TestHelper.assertUndeliverable(errors, 1, TestException.class);
1922 } finally {
1923 RxJavaPlugins.reset();
1924 }
1925 }
1926
1927 @Test
1928 public void openCloseOpenCompletes() {
1929 PublishProcessor<Integer> source = PublishProcessor.create();
1930
1931 PublishProcessor<Integer> openIndicator = PublishProcessor.create();
1932
1933 PublishProcessor<Integer> closeIndicator = PublishProcessor.create();
1934
1935 TestSubscriber<List<Integer>> ts = source
1936 .buffer(openIndicator, Functions.justFunction(closeIndicator))
1937 .test();
1938
1939 openIndicator.onNext(1);
1940
1941 assertTrue(closeIndicator.hasSubscribers());
1942
1943 openIndicator.onComplete();
1944
1945 assertTrue(source.hasSubscribers());
1946 assertTrue(closeIndicator.hasSubscribers());
1947
1948 closeIndicator.onComplete();
1949
1950 assertFalse(source.hasSubscribers());
1951
1952 ts.assertResult(Collections.<Integer>emptyList());
1953 }
1954
1955 @Test
1956 public void openCloseOpenCompletesNoBuffers() {
1957 PublishProcessor<Integer> source = PublishProcessor.create();
1958
1959 PublishProcessor<Integer> openIndicator = PublishProcessor.create();
1960
1961 PublishProcessor<Integer> closeIndicator = PublishProcessor.create();
1962
1963 TestSubscriber<List<Integer>> ts = source
1964 .buffer(openIndicator, Functions.justFunction(closeIndicator))
1965 .test();
1966
1967 openIndicator.onNext(1);
1968
1969 assertTrue(closeIndicator.hasSubscribers());
1970
1971 closeIndicator.onComplete();
1972
1973 assertTrue(source.hasSubscribers());
1974 assertTrue(openIndicator.hasSubscribers());
1975
1976 openIndicator.onComplete();
1977
1978 assertFalse(source.hasSubscribers());
1979
1980 ts.assertResult(Collections.<Integer>emptyList());
1981 }
1982
1983 @Test
1984 public void openCloseTake() {
1985 PublishProcessor<Integer> source = PublishProcessor.create();
1986
1987 PublishProcessor<Integer> openIndicator = PublishProcessor.create();
1988
1989 PublishProcessor<Integer> closeIndicator = PublishProcessor.create();
1990
1991 TestSubscriber<List<Integer>> ts = source
1992 .buffer(openIndicator, Functions.justFunction(closeIndicator))
1993 .take(1)
1994 .test(2);
1995
1996 openIndicator.onNext(1);
1997 closeIndicator.onComplete();
1998
1999 assertFalse(source.hasSubscribers());
2000 assertFalse(openIndicator.hasSubscribers());
2001 assertFalse(closeIndicator.hasSubscribers());
2002
2003 ts.assertResult(Collections.<Integer>emptyList());
2004 }
2005
2006 @Test
2007 public void openCloseEmptyBackpressure() {
2008 PublishProcessor<Integer> source = PublishProcessor.create();
2009
2010 PublishProcessor<Integer> openIndicator = PublishProcessor.create();
2011
2012 PublishProcessor<Integer> closeIndicator = PublishProcessor.create();
2013
2014 TestSubscriber<List<Integer>> ts = source
2015 .buffer(openIndicator, Functions.justFunction(closeIndicator))
2016 .test(0);
2017
2018 source.onComplete();
2019
2020 assertFalse(openIndicator.hasSubscribers());
2021 assertFalse(closeIndicator.hasSubscribers());
2022
2023 ts.assertResult();
2024 }
2025
2026 @Test
2027 public void openCloseErrorBackpressure() {
2028 PublishProcessor<Integer> source = PublishProcessor.create();
2029
2030 PublishProcessor<Integer> openIndicator = PublishProcessor.create();
2031
2032 PublishProcessor<Integer> closeIndicator = PublishProcessor.create();
2033
2034 TestSubscriber<List<Integer>> ts = source
2035 .buffer(openIndicator, Functions.justFunction(closeIndicator))
2036 .test(0);
2037
2038 source.onError(new TestException());
2039
2040 assertFalse(openIndicator.hasSubscribers());
2041 assertFalse(closeIndicator.hasSubscribers());
2042
2043 ts.assertFailure(TestException.class);
2044 }
2045
2046 @Test
2047 public void openCloseBadOpen() {
2048 List<Throwable> errors = TestHelper.trackPluginErrors();
2049 try {
2050 Flowable.never()
2051 .buffer(new Flowable<Object>() {
2052 @Override
2053 protected void subscribeActual(Subscriber<? super Object> s) {
2054
2055 assertFalse(((Disposable)s).isDisposed());
2056
2057 BooleanSubscription bs1 = new BooleanSubscription();
2058 BooleanSubscription bs2 = new BooleanSubscription();
2059
2060 s.onSubscribe(bs1);
2061
2062 assertFalse(bs1.isCancelled());
2063 assertFalse(bs2.isCancelled());
2064
2065 s.onSubscribe(bs2);
2066
2067 assertFalse(bs1.isCancelled());
2068 assertTrue(bs2.isCancelled());
2069
2070 s.onError(new IOException());
2071
2072 assertTrue(((Disposable)s).isDisposed());
2073
2074 s.onComplete();
2075 s.onNext(1);
2076 s.onError(new TestException());
2077 }
2078 }, Functions.justFunction(Flowable.never()))
2079 .test()
2080 .assertFailure(IOException.class);
2081
2082 TestHelper.assertError(errors, 0, ProtocolViolationException.class);
2083 TestHelper.assertUndeliverable(errors, 1, TestException.class);
2084 } finally {
2085 RxJavaPlugins.reset();
2086 }
2087 }
2088
2089 @Test
2090 public void openCloseBadClose() {
2091 List<Throwable> errors = TestHelper.trackPluginErrors();
2092 try {
2093 Flowable.never()
2094 .buffer(Flowable.just(1).concatWith(Flowable.<Integer>never()),
2095 Functions.justFunction(new Flowable<Object>() {
2096 @Override
2097 protected void subscribeActual(Subscriber<? super Object> s) {
2098
2099 assertFalse(((Disposable)s).isDisposed());
2100
2101 BooleanSubscription bs1 = new BooleanSubscription();
2102 BooleanSubscription bs2 = new BooleanSubscription();
2103
2104 s.onSubscribe(bs1);
2105
2106 assertFalse(bs1.isCancelled());
2107 assertFalse(bs2.isCancelled());
2108
2109 s.onSubscribe(bs2);
2110
2111 assertFalse(bs1.isCancelled());
2112 assertTrue(bs2.isCancelled());
2113
2114 s.onError(new IOException());
2115
2116 assertTrue(((Disposable)s).isDisposed());
2117
2118 s.onComplete();
2119 s.onNext(1);
2120 s.onError(new TestException());
2121 }
2122 }))
2123 .test()
2124 .assertFailure(IOException.class);
2125
2126 TestHelper.assertError(errors, 0, ProtocolViolationException.class);
2127 TestHelper.assertUndeliverable(errors, 1, TestException.class);
2128 } finally {
2129 RxJavaPlugins.reset();
2130 }
2131 }
2132
2133 @Test
2134 public void bufferExactBoundaryDoubleOnSubscribe() {
2135 TestHelper.checkDoubleOnSubscribeFlowable(
2136 new Function<Flowable<Object>, Flowable<List<Object>>>() {
2137 @Override
2138 public Flowable<List<Object>> apply(Flowable<Object> f)
2139 throws Exception {
2140 return f.buffer(Flowable.never());
2141 }
2142 }
2143 );
2144 }
2145
2146 @Test
2147 public void bufferExactBoundarySecondBufferCrash() {
2148 PublishProcessor<Integer> pp = PublishProcessor.create();
2149 PublishProcessor<Integer> b = PublishProcessor.create();
2150
2151 TestSubscriber<List<Integer>> ts = pp.buffer(b, new Supplier<List<Integer>>() {
2152 int calls;
2153 @Override
2154 public List<Integer> get() throws Exception {
2155 if (++calls == 2) {
2156 throw new TestException();
2157 }
2158 return new ArrayList<>();
2159 }
2160 }).test();
2161
2162 b.onNext(1);
2163
2164 ts.assertFailure(TestException.class);
2165 }
2166
2167 @Test
2168 public void bufferExactBoundaryBadSource() {
2169 Flowable<Integer> pp = new Flowable<Integer>() {
2170 @Override
2171 protected void subscribeActual(Subscriber<? super Integer> subscriber) {
2172 subscriber.onSubscribe(new BooleanSubscription());
2173 subscriber.onComplete();
2174 subscriber.onNext(1);
2175 subscriber.onComplete();
2176 }
2177 };
2178
2179 final AtomicReference<Subscriber<? super Integer>> ref = new AtomicReference<>();
2180 Flowable<Integer> b = new Flowable<Integer>() {
2181 @Override
2182 protected void subscribeActual(Subscriber<? super Integer> subscriber) {
2183 subscriber.onSubscribe(new BooleanSubscription());
2184 ref.set(subscriber);
2185 }
2186 };
2187
2188 TestSubscriber<List<Integer>> ts = pp.buffer(b).test();
2189
2190 ref.get().onNext(1);
2191
2192 ts.assertResult(Collections.<Integer>emptyList());
2193 }
2194
2195 @Test
2196 public void bufferExactBoundaryCancelUpfront() {
2197 PublishProcessor<Integer> pp = PublishProcessor.create();
2198 PublishProcessor<Integer> b = PublishProcessor.create();
2199
2200 pp.buffer(b).test(0L, true)
2201 .assertEmpty();
2202
2203 assertFalse(pp.hasSubscribers());
2204 assertFalse(b.hasSubscribers());
2205 }
2206
2207 @Test
2208 public void bufferExactBoundaryDisposed() {
2209 Flowable<Integer> pp = new Flowable<Integer>() {
2210 @Override
2211 protected void subscribeActual(Subscriber<? super Integer> s) {
2212 s.onSubscribe(new BooleanSubscription());
2213
2214 Disposable d = (Disposable)s;
2215
2216 assertFalse(d.isDisposed());
2217
2218 d.dispose();
2219
2220 assertTrue(d.isDisposed());
2221 }
2222 };
2223 PublishProcessor<Integer> b = PublishProcessor.create();
2224
2225 pp.buffer(b).test();
2226 }
2227
2228 @Test
2229 public void timedDoubleOnSubscribe() {
2230 TestHelper.checkDoubleOnSubscribeFlowable(new Function<Flowable<Object>, Publisher<List<Object>>>() {
2231 @Override
2232 public Publisher<List<Object>> apply(Flowable<Object> f)
2233 throws Exception {
2234 return f.buffer(1, TimeUnit.SECONDS);
2235 }
2236 });
2237 }
2238
2239 @Test
2240 public void timedCancelledUpfront() {
2241 TestScheduler sch = new TestScheduler();
2242
2243 TestSubscriber<List<Object>> ts = Flowable.never()
2244 .buffer(1, TimeUnit.MILLISECONDS, sch)
2245 .test(1L, true);
2246
2247 sch.advanceTimeBy(1, TimeUnit.MILLISECONDS);
2248
2249 ts.assertEmpty();
2250 }
2251
2252 @Test
2253 public void timedInternalState() {
2254 TestScheduler sch = new TestScheduler();
2255
2256 TestSubscriber<List<Integer>> ts = new TestSubscriber<>();
2257
2258 BufferExactUnboundedSubscriber<Integer, List<Integer>> sub = new BufferExactUnboundedSubscriber<>(
2259 ts, Functions.justSupplier((List<Integer>) new ArrayList<Integer>()), 1, TimeUnit.SECONDS, sch);
2260
2261 sub.onSubscribe(new BooleanSubscription());
2262
2263 assertFalse(sub.isDisposed());
2264
2265 sub.onError(new TestException());
2266 sub.onNext(1);
2267 sub.onComplete();
2268
2269 sub.run();
2270
2271 sub.dispose();
2272
2273 assertTrue(sub.isDisposed());
2274
2275 sub.buffer = new ArrayList<>();
2276 sub.enter();
2277 sub.onComplete();
2278 }
2279
2280 @Test
2281 public void timedSkipDoubleOnSubscribe() {
2282 TestHelper.checkDoubleOnSubscribeFlowable(new Function<Flowable<Object>, Publisher<List<Object>>>() {
2283 @Override
2284 public Publisher<List<Object>> apply(Flowable<Object> f)
2285 throws Exception {
2286 return f.buffer(2, 1, TimeUnit.SECONDS);
2287 }
2288 });
2289 }
2290
2291 @Test
2292 public void timedSizedDoubleOnSubscribe() {
2293 TestHelper.checkDoubleOnSubscribeFlowable(new Function<Flowable<Object>, Publisher<List<Object>>>() {
2294 @Override
2295 public Publisher<List<Object>> apply(Flowable<Object> f)
2296 throws Exception {
2297 return f.buffer(2, TimeUnit.SECONDS, 10);
2298 }
2299 });
2300 }
2301
2302 @Test
2303 public void timedSkipInternalState() {
2304 TestScheduler sch = new TestScheduler();
2305
2306 TestSubscriber<List<Integer>> ts = new TestSubscriber<>();
2307
2308 BufferSkipBoundedSubscriber<Integer, List<Integer>> sub = new BufferSkipBoundedSubscriber<>(
2309 ts, Functions.justSupplier((List<Integer>) new ArrayList<Integer>()), 1, 1, TimeUnit.SECONDS, sch.createWorker());
2310
2311 sub.onSubscribe(new BooleanSubscription());
2312
2313 sub.enter();
2314 sub.onComplete();
2315
2316 sub.cancel();
2317
2318 sub.run();
2319 }
2320
2321 @Test
2322 public void timedSkipCancelWhenSecondBuffer() {
2323 TestScheduler sch = new TestScheduler();
2324
2325 final TestSubscriber<List<Integer>> ts = new TestSubscriber<>();
2326
2327 BufferSkipBoundedSubscriber<Integer, List<Integer>> sub = new BufferSkipBoundedSubscriber<>(
2328 ts, new Supplier<List<Integer>>() {
2329 int calls;
2330
2331 @Override
2332 public List<Integer> get() throws Exception {
2333 if (++calls == 2) {
2334 ts.cancel();
2335 }
2336 return new ArrayList<>();
2337 }
2338 }, 1, 1, TimeUnit.SECONDS, sch.createWorker());
2339
2340 sub.onSubscribe(new BooleanSubscription());
2341
2342 sub.run();
2343
2344 assertTrue(ts.isCancelled());
2345 }
2346
2347 @Test
2348 public void timedSizeBufferAlreadyCleared() {
2349 TestScheduler sch = new TestScheduler();
2350
2351 TestSubscriber<List<Integer>> ts = new TestSubscriber<>();
2352
2353 BufferExactBoundedSubscriber<Integer, List<Integer>> sub =
2354 new BufferExactBoundedSubscriber<>(
2355 ts, Functions.justSupplier((List<Integer>) new ArrayList<Integer>()),
2356 1, TimeUnit.SECONDS, 1, false, sch.createWorker())
2357 ;
2358
2359 BooleanSubscription bs = new BooleanSubscription();
2360
2361 sub.onSubscribe(bs);
2362
2363 sub.producerIndex++;
2364
2365 sub.run();
2366
2367 assertFalse(sub.isDisposed());
2368
2369 sub.enter();
2370 sub.onComplete();
2371
2372 assertTrue(sub.isDisposed());
2373
2374 sub.run();
2375 }
2376
2377 @Test
2378 public void bufferExactFailingSupplier() {
2379 Flowable.empty()
2380 .buffer(1, TimeUnit.SECONDS, Schedulers.computation(), 10, new Supplier<List<Object>>() {
2381 @Override
2382 public List<Object> get() throws Exception {
2383 throw new TestException();
2384 }
2385 }, false)
2386 .test()
2387 .awaitDone(1, TimeUnit.SECONDS)
2388 .assertFailure(TestException.class)
2389 ;
2390 }
2391
2392 @Test
2393 public void exactBadRequest() {
2394 TestHelper.assertBadRequestReported(Flowable.never().buffer(1));
2395 }
2396
2397 @Test
2398 public void skipBadRequest() {
2399 TestHelper.assertBadRequestReported(Flowable.never().buffer(1, 2));
2400 }
2401
2402 @Test
2403 public void overlapBadRequest() {
2404 TestHelper.assertBadRequestReported(Flowable.never().buffer(2, 1));
2405 }
2406
2407 @Test
2408 public void bufferExactBoundedOnNextAfterDispose() {
2409 TestSubscriber<Object> ts = new TestSubscriber<>();
2410
2411 Flowable.unsafeCreate(s -> {
2412 s.onSubscribe(new BooleanSubscription());
2413 ts.cancel();
2414 s.onNext(1);
2415 })
2416 .buffer(1, TimeUnit.MINUTES, 2)
2417 .subscribe(ts);
2418
2419 ts.assertEmpty();
2420 }
2421
2422 @Test
2423 public void boundaryCloseCompleteRace() {
2424 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
2425 BehaviorProcessor<Integer> bp = BehaviorProcessor.createDefault(1);
2426 PublishProcessor<Integer> pp = PublishProcessor.create();
2427
2428 TestSubscriber<List<Integer>> ts = bp
2429 .buffer(BehaviorProcessor.createDefault(0), v -> pp)
2430 .test();
2431
2432 TestHelper.race(
2433 () -> bp.onComplete(),
2434 () -> pp.onComplete()
2435 );
2436
2437 ts.assertResult(Arrays.asList(1));
2438 }
2439 }
2440
2441 @Test
2442 public void doubleOnSubscribeStartEnd() {
2443 TestHelper.checkDoubleOnSubscribeFlowable(f -> f.buffer(Flowable.never(), v -> Flowable.never()));
2444 }
2445
2446 @Test
2447 public void cancel() {
2448 TestHelper.checkDisposed(Flowable.never().buffer(Flowable.never(), v -> Flowable.never()));
2449 }
2450
2451 @Test
2452 public void startEndCancelAfterOneBuffer() {
2453 BehaviorProcessor.createDefault(1)
2454 .buffer(BehaviorProcessor.createDefault(2), v -> Flowable.just(1))
2455 .takeUntil(v -> true)
2456 .test()
2457 .assertResult(Arrays.asList());
2458 }
2459
2460 @Test
2461 public void startEndCompleteOnBoundary() {
2462 Flowable.empty()
2463 .buffer(Flowable.never(), v -> Flowable.just(1))
2464 .take(1)
2465 .test()
2466 .assertResult();
2467 }
2468
2469 @Test
2470 public void startEndBackpressure() {
2471 BehaviorProcessor.createDefault(1)
2472 .buffer(BehaviorProcessor.createDefault(2), v -> Flowable.just(1))
2473 .test(1L)
2474 .assertValuesOnly(Arrays.asList());
2475 }
2476
2477 @Test
2478 public void startEndBackpressureMoreWork() {
2479 PublishProcessor<Integer> bp = PublishProcessor.create();
2480 PublishProcessor<Integer> pp = PublishProcessor.create();
2481 AtomicInteger counter = new AtomicInteger();
2482
2483 TestSubscriber<List<Integer>> ts = bp
2484 .buffer(pp, v -> Flowable.just(1))
2485 .doOnNext(v -> {
2486 if (counter.getAndIncrement() == 0) {
2487 pp.onNext(2);
2488 pp.onComplete();
2489 }
2490 })
2491 .test(1L);
2492
2493 pp.onNext(1);
2494 bp.onNext(1);
2495
2496 ts
2497 .assertValuesOnly(Arrays.asList());
2498 }
2499 }