Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableBufferTest.java

raw
1 /*
2 * Copyright (c) 2016-present, RxJava Contributors.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
5 * compliance with the License. You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software distributed under the License is
10 * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
11 * the License for the specific language governing permissions and limitations under the License.
12 */
13
14 package io.reactivex.rxjava3.internal.operators.observable;
15
16 import static org.junit.Assert.*;
17 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
28 import io.reactivex.rxjava3.core.*;
29 import io.reactivex.rxjava3.core.Observable;
30 import io.reactivex.rxjava3.core.Observer;
31 import io.reactivex.rxjava3.disposables.*;
32 import io.reactivex.rxjava3.exceptions.*;
33 import io.reactivex.rxjava3.functions.*;
34 import io.reactivex.rxjava3.internal.functions.Functions;
35 import io.reactivex.rxjava3.internal.operators.observable.ObservableBuffer.BufferExactObserver;
36 import io.reactivex.rxjava3.internal.operators.observable.ObservableBufferTimed.*;
37 import io.reactivex.rxjava3.observers.*;
38 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
39 import io.reactivex.rxjava3.schedulers.*;
40 import io.reactivex.rxjava3.subjects.*;
41 import io.reactivex.rxjava3.testsupport.TestHelper;
42
43 public class ObservableBufferTest extends RxJavaTest {
44
45 private Observer<List<String>> observer;
46 private TestScheduler scheduler;
47 private Scheduler.Worker innerScheduler;
48
49 @Before
50 public void before() {
51 observer = TestHelper.mockObserver();
52 scheduler = new TestScheduler();
53 innerScheduler = scheduler.createWorker();
54 }
55
56 @Test
57 public void complete() {
58 Observable<String> source = Observable.empty();
59
60 Observable<List<String>> buffered = source.buffer(3, 3);
61 buffered.subscribe(observer);
62
63 Mockito.verify(observer, Mockito.never()).onNext(Mockito.<String>anyList());
64 Mockito.verify(observer, Mockito.never()).onError(Mockito.any(Throwable.class));
65 Mockito.verify(observer, Mockito.times(1)).onComplete();
66 }
67
68 @Test
69 public void skipAndCountOverlappingBuffers() {
70 Observable<String> source = Observable.unsafeCreate(new ObservableSource<String>() {
71 @Override
72 public void subscribe(Observer<? super String> observer) {
73 observer.onSubscribe(Disposable.empty());
74 observer.onNext("one");
75 observer.onNext("two");
76 observer.onNext("three");
77 observer.onNext("four");
78 observer.onNext("five");
79 }
80 });
81
82 Observable<List<String>> buffered = source.buffer(3, 1);
83 buffered.subscribe(observer);
84
85 InOrder inOrder = Mockito.inOrder(observer);
86 inOrder.verify(observer, Mockito.times(1)).onNext(list("one", "two", "three"));
87 inOrder.verify(observer, Mockito.times(1)).onNext(list("two", "three", "four"));
88 inOrder.verify(observer, Mockito.times(1)).onNext(list("three", "four", "five"));
89 inOrder.verify(observer, Mockito.never()).onNext(Mockito.<String>anyList());
90 inOrder.verify(observer, Mockito.never()).onError(Mockito.any(Throwable.class));
91 inOrder.verify(observer, Mockito.never()).onComplete();
92 }
93
94 @Test
95 public void skipAndCountGaplessBuffers() {
96 Observable<String> source = Observable.just("one", "two", "three", "four", "five");
97
98 Observable<List<String>> buffered = source.buffer(3, 3);
99 buffered.subscribe(observer);
100
101 InOrder inOrder = Mockito.inOrder(observer);
102 inOrder.verify(observer, Mockito.times(1)).onNext(list("one", "two", "three"));
103 inOrder.verify(observer, Mockito.times(1)).onNext(list("four", "five"));
104 inOrder.verify(observer, Mockito.never()).onNext(Mockito.<String>anyList());
105 inOrder.verify(observer, Mockito.never()).onError(Mockito.any(Throwable.class));
106 inOrder.verify(observer, Mockito.times(1)).onComplete();
107 }
108
109 @Test
110 public void skipAndCountBuffersWithGaps() {
111 Observable<String> source = Observable.just("one", "two", "three", "four", "five");
112
113 Observable<List<String>> buffered = source.buffer(2, 3);
114 buffered.subscribe(observer);
115
116 InOrder inOrder = Mockito.inOrder(observer);
117 inOrder.verify(observer, Mockito.times(1)).onNext(list("one", "two"));
118 inOrder.verify(observer, Mockito.times(1)).onNext(list("four", "five"));
119 inOrder.verify(observer, Mockito.never()).onNext(Mockito.<String>anyList());
120 inOrder.verify(observer, Mockito.never()).onError(Mockito.any(Throwable.class));
121 inOrder.verify(observer, Mockito.times(1)).onComplete();
122 }
123
124 @Test
125 public void timedAndCount() {
126 Observable<String> source = Observable.unsafeCreate(new ObservableSource<String>() {
127 @Override
128 public void subscribe(Observer<? super String> observer) {
129 observer.onSubscribe(Disposable.empty());
130 push(observer, "one", 10);
131 push(observer, "two", 90);
132 push(observer, "three", 110);
133 push(observer, "four", 190);
134 push(observer, "five", 210);
135 complete(observer, 250);
136 }
137 });
138
139 Observable<List<String>> buffered = source.buffer(100, TimeUnit.MILLISECONDS, scheduler, 2);
140 buffered.subscribe(observer);
141
142 InOrder inOrder = Mockito.inOrder(observer);
143 scheduler.advanceTimeTo(100, TimeUnit.MILLISECONDS);
144 inOrder.verify(observer, Mockito.times(1)).onNext(list("one", "two"));
145
146 scheduler.advanceTimeTo(200, TimeUnit.MILLISECONDS);
147 inOrder.verify(observer, Mockito.times(1)).onNext(list("three", "four"));
148
149 scheduler.advanceTimeTo(300, TimeUnit.MILLISECONDS);
150 inOrder.verify(observer, Mockito.times(1)).onNext(list("five"));
151 inOrder.verify(observer, Mockito.never()).onNext(Mockito.<String>anyList());
152 inOrder.verify(observer, Mockito.never()).onError(Mockito.any(Throwable.class));
153 inOrder.verify(observer, Mockito.times(1)).onComplete();
154 }
155
156 @Test
157 public void timed() {
158 Observable<String> source = Observable.unsafeCreate(new ObservableSource<String>() {
159 @Override
160 public void subscribe(Observer<? super String> observer) {
161 observer.onSubscribe(Disposable.empty());
162 push(observer, "one", 97);
163 push(observer, "two", 98);
164 /**
165 * Changed from 100. Because scheduling the cut to 100ms happens before this
166 * Observable even runs due how lift works, pushing at 100ms would execute after the
167 * buffer cut.
168 */
169 push(observer, "three", 99);
170 push(observer, "four", 101);
171 push(observer, "five", 102);
172 complete(observer, 150);
173 }
174 });
175
176 Observable<List<String>> buffered = source.buffer(100, TimeUnit.MILLISECONDS, scheduler);
177 buffered.subscribe(observer);
178
179 InOrder inOrder = Mockito.inOrder(observer);
180 scheduler.advanceTimeTo(101, TimeUnit.MILLISECONDS);
181 inOrder.verify(observer, Mockito.times(1)).onNext(list("one", "two", "three"));
182
183 scheduler.advanceTimeTo(201, TimeUnit.MILLISECONDS);
184 inOrder.verify(observer, Mockito.times(1)).onNext(list("four", "five"));
185 inOrder.verify(observer, Mockito.never()).onNext(Mockito.<String>anyList());
186 inOrder.verify(observer, Mockito.never()).onError(Mockito.any(Throwable.class));
187 inOrder.verify(observer, Mockito.times(1)).onComplete();
188 }
189
190 @Test
191 public void observableBasedOpenerAndCloser() {
192 Observable<String> source = Observable.unsafeCreate(new ObservableSource<String>() {
193 @Override
194 public void subscribe(Observer<? super String> observer) {
195 observer.onSubscribe(Disposable.empty());
196 push(observer, "one", 10);
197 push(observer, "two", 60);
198 push(observer, "three", 110);
199 push(observer, "four", 160);
200 push(observer, "five", 210);
201 complete(observer, 500);
202 }
203 });
204
205 Observable<Object> openings = Observable.unsafeCreate(new ObservableSource<Object>() {
206 @Override
207 public void subscribe(Observer<Object> observer) {
208 observer.onSubscribe(Disposable.empty());
209 push(observer, new Object(), 50);
210 push(observer, new Object(), 200);
211 complete(observer, 250);
212 }
213 });
214
215 Function<Object, Observable<Object>> closer = new Function<Object, Observable<Object>>() {
216 @Override
217 public Observable<Object> apply(Object opening) {
218 return Observable.unsafeCreate(new ObservableSource<Object>() {
219 @Override
220 public void subscribe(Observer<? super Object> observer) {
221 observer.onSubscribe(Disposable.empty());
222 push(observer, new Object(), 100);
223 complete(observer, 101);
224 }
225 });
226 }
227 };
228
229 Observable<List<String>> buffered = source.buffer(openings, closer);
230 buffered.subscribe(observer);
231
232 InOrder inOrder = Mockito.inOrder(observer);
233 scheduler.advanceTimeTo(500, TimeUnit.MILLISECONDS);
234 inOrder.verify(observer, Mockito.times(1)).onNext(list("two", "three"));
235 inOrder.verify(observer, Mockito.times(1)).onNext(list("five"));
236 inOrder.verify(observer, Mockito.never()).onNext(Mockito.<String>anyList());
237 inOrder.verify(observer, Mockito.never()).onError(Mockito.any(Throwable.class));
238 inOrder.verify(observer, Mockito.times(1)).onComplete();
239 }
240
241 @Test
242 public void longTimeAction() throws InterruptedException {
243 final CountDownLatch latch = new CountDownLatch(1);
244 LongTimeAction action = new LongTimeAction(latch);
245 Observable.just(1).buffer(10, TimeUnit.MILLISECONDS, 10)
246 .subscribe(action);
247 latch.await();
248 assertFalse(action.fail);
249 }
250
251 private static class LongTimeAction implements Consumer<List<Integer>> {
252
253 CountDownLatch latch;
254 boolean fail;
255
256 LongTimeAction(CountDownLatch latch) {
257 this.latch = latch;
258 }
259
260 @Override
261 public void accept(List<Integer> t1) {
262 try {
263 if (fail) {
264 return;
265 }
266 Thread.sleep(200);
267 } catch (InterruptedException e) {
268 fail = true;
269 } finally {
270 latch.countDown();
271 }
272 }
273 }
274
275 private List<String> list(String... args) {
276 List<String> list = new ArrayList<>();
277 for (String arg : args) {
278 list.add(arg);
279 }
280 return list;
281 }
282
283 private <T> void push(final Observer<T> observer, final T value, int delay) {
284 innerScheduler.schedule(new Runnable() {
285 @Override
286 public void run() {
287 observer.onNext(value);
288 }
289 }, delay, TimeUnit.MILLISECONDS);
290 }
291
292 private void complete(final Observer<?> observer, int delay) {
293 innerScheduler.schedule(new Runnable() {
294 @Override
295 public void run() {
296 observer.onComplete();
297 }
298 }, delay, TimeUnit.MILLISECONDS);
299 }
300
301 @Test
302 public void bufferStopsWhenUnsubscribed1() {
303 Observable<Integer> source = Observable.never();
304
305 Observer<List<Integer>> o = TestHelper.mockObserver();
306 TestObserver<List<Integer>> to = new TestObserver<>(o);
307
308 source.buffer(100, 200, TimeUnit.MILLISECONDS, scheduler)
309 .doOnNext(new Consumer<List<Integer>>() {
310 @Override
311 public void accept(List<Integer> pv) {
312 System.out.println(pv);
313 }
314 })
315 .subscribe(to);
316
317 InOrder inOrder = Mockito.inOrder(o);
318
319 scheduler.advanceTimeBy(1001, TimeUnit.MILLISECONDS);
320
321 inOrder.verify(o, times(5)).onNext(Arrays.<Integer> asList());
322
323 to.dispose();
324
325 scheduler.advanceTimeBy(999, TimeUnit.MILLISECONDS);
326
327 inOrder.verifyNoMoreInteractions();
328 }
329
330 @Test
331 public void bufferWithBONormal1() {
332 PublishSubject<Integer> source = PublishSubject.create();
333 PublishSubject<Integer> boundary = PublishSubject.create();
334
335 Observer<Object> o = TestHelper.mockObserver();
336 InOrder inOrder = Mockito.inOrder(o);
337
338 source.buffer(boundary).subscribe(o);
339
340 source.onNext(1);
341 source.onNext(2);
342 source.onNext(3);
343
344 boundary.onNext(1);
345
346 inOrder.verify(o, times(1)).onNext(Arrays.asList(1, 2, 3));
347
348 source.onNext(4);
349 source.onNext(5);
350
351 boundary.onNext(2);
352
353 inOrder.verify(o, times(1)).onNext(Arrays.asList(4, 5));
354
355 source.onNext(6);
356 boundary.onComplete();
357
358 inOrder.verify(o, times(1)).onNext(Arrays.asList(6));
359
360 inOrder.verify(o).onComplete();
361
362 verify(o, never()).onError(any(Throwable.class));
363 }
364
365 @Test
366 public void bufferWithBOEmptyLastViaBoundary() {
367 PublishSubject<Integer> source = PublishSubject.create();
368 PublishSubject<Integer> boundary = PublishSubject.create();
369
370 Observer<Object> o = TestHelper.mockObserver();
371 InOrder inOrder = Mockito.inOrder(o);
372
373 source.buffer(boundary).subscribe(o);
374
375 boundary.onComplete();
376
377 inOrder.verify(o, times(1)).onNext(Arrays.asList());
378
379 inOrder.verify(o).onComplete();
380
381 verify(o, never()).onError(any(Throwable.class));
382 }
383
384 @Test
385 public void bufferWithBOEmptyLastViaSource() {
386 PublishSubject<Integer> source = PublishSubject.create();
387 PublishSubject<Integer> boundary = PublishSubject.create();
388
389 Observer<Object> o = TestHelper.mockObserver();
390 InOrder inOrder = Mockito.inOrder(o);
391
392 source.buffer(boundary).subscribe(o);
393
394 source.onComplete();
395
396 inOrder.verify(o, times(1)).onNext(Arrays.asList());
397
398 inOrder.verify(o).onComplete();
399
400 verify(o, never()).onError(any(Throwable.class));
401 }
402
403 @Test
404 public void bufferWithBOEmptyLastViaBoth() {
405 PublishSubject<Integer> source = PublishSubject.create();
406 PublishSubject<Integer> boundary = PublishSubject.create();
407
408 Observer<Object> o = TestHelper.mockObserver();
409 InOrder inOrder = Mockito.inOrder(o);
410
411 source.buffer(boundary).subscribe(o);
412
413 source.onComplete();
414 boundary.onComplete();
415
416 inOrder.verify(o, times(1)).onNext(Arrays.asList());
417
418 inOrder.verify(o).onComplete();
419
420 verify(o, never()).onError(any(Throwable.class));
421 }
422
423 @Test
424 public void bufferWithBOSourceThrows() {
425 PublishSubject<Integer> source = PublishSubject.create();
426 PublishSubject<Integer> boundary = PublishSubject.create();
427
428 Observer<Object> o = TestHelper.mockObserver();
429
430 source.buffer(boundary).subscribe(o);
431 source.onNext(1);
432 source.onError(new TestException());
433
434 verify(o).onError(any(TestException.class));
435 verify(o, never()).onComplete();
436 verify(o, never()).onNext(any());
437 }
438
439 @Test
440 public void bufferWithBOBoundaryThrows() {
441 PublishSubject<Integer> source = PublishSubject.create();
442 PublishSubject<Integer> boundary = PublishSubject.create();
443
444 Observer<Object> o = TestHelper.mockObserver();
445
446 source.buffer(boundary).subscribe(o);
447
448 source.onNext(1);
449 boundary.onError(new TestException());
450
451 verify(o).onError(any(TestException.class));
452 verify(o, never()).onComplete();
453 verify(o, never()).onNext(any());
454 }
455
456 @Test
457 public void bufferWithSizeTake1() {
458 Observable<Integer> source = Observable.just(1).repeat();
459
460 Observable<List<Integer>> result = source.buffer(2).take(1);
461
462 Observer<Object> o = TestHelper.mockObserver();
463
464 result.subscribe(o);
465
466 verify(o).onNext(Arrays.asList(1, 1));
467 verify(o).onComplete();
468 verify(o, never()).onError(any(Throwable.class));
469 }
470
471 @Test
472 public void bufferWithSizeSkipTake1() {
473 Observable<Integer> source = Observable.just(1).repeat();
474
475 Observable<List<Integer>> result = source.buffer(2, 3).take(1);
476
477 Observer<Object> o = TestHelper.mockObserver();
478
479 result.subscribe(o);
480
481 verify(o).onNext(Arrays.asList(1, 1));
482 verify(o).onComplete();
483 verify(o, never()).onError(any(Throwable.class));
484 }
485
486 @Test
487 public void bufferWithTimeTake1() {
488 Observable<Long> source = Observable.interval(40, 40, TimeUnit.MILLISECONDS, scheduler);
489
490 Observable<List<Long>> result = source.buffer(100, TimeUnit.MILLISECONDS, scheduler).take(1);
491
492 Observer<Object> o = TestHelper.mockObserver();
493
494 result.subscribe(o);
495
496 scheduler.advanceTimeBy(5, TimeUnit.SECONDS);
497
498 verify(o).onNext(Arrays.asList(0L, 1L));
499 verify(o).onComplete();
500 verify(o, never()).onError(any(Throwable.class));
501 }
502
503 @Test
504 public void bufferWithTimeSkipTake2() {
505 Observable<Long> source = Observable.interval(40, 40, TimeUnit.MILLISECONDS, scheduler);
506
507 Observable<List<Long>> result = source.buffer(100, 60, TimeUnit.MILLISECONDS, scheduler).take(2);
508
509 Observer<Object> o = TestHelper.mockObserver();
510 InOrder inOrder = inOrder(o);
511
512 result.subscribe(o);
513
514 scheduler.advanceTimeBy(5, TimeUnit.SECONDS);
515
516 inOrder.verify(o).onNext(Arrays.asList(0L, 1L));
517 inOrder.verify(o).onNext(Arrays.asList(1L, 2L));
518 inOrder.verify(o).onComplete();
519 verify(o, never()).onError(any(Throwable.class));
520 }
521
522 @Test
523 public void bufferWithBoundaryTake2() {
524 Observable<Long> boundary = Observable.interval(60, 60, TimeUnit.MILLISECONDS, scheduler);
525 Observable<Long> source = Observable.interval(40, 40, TimeUnit.MILLISECONDS, scheduler);
526
527 Observable<List<Long>> result = source.buffer(boundary).take(2);
528
529 Observer<Object> o = TestHelper.mockObserver();
530 InOrder inOrder = inOrder(o);
531
532 result.subscribe(o);
533
534 scheduler.advanceTimeBy(5, TimeUnit.SECONDS);
535
536 inOrder.verify(o).onNext(Arrays.asList(0L));
537 inOrder.verify(o).onNext(Arrays.asList(1L));
538 inOrder.verify(o).onComplete();
539 verify(o, never()).onError(any(Throwable.class));
540
541 }
542
543 @Test
544 public void bufferWithStartEndBoundaryTake2() {
545 Observable<Long> start = Observable.interval(61, 61, TimeUnit.MILLISECONDS, scheduler);
546 Function<Long, Observable<Long>> end = new Function<Long, Observable<Long>>() {
547 @Override
548 public Observable<Long> apply(Long t1) {
549 return Observable.interval(100, 100, TimeUnit.MILLISECONDS, scheduler);
550 }
551 };
552
553 Observable<Long> source = Observable.interval(40, 40, TimeUnit.MILLISECONDS, scheduler);
554
555 Observable<List<Long>> result = source.buffer(start, end).take(2);
556
557 Observer<Object> o = TestHelper.mockObserver();
558 InOrder inOrder = inOrder(o);
559
560 result
561 .doOnNext(new Consumer<List<Long>>() {
562 @Override
563 public void accept(List<Long> pv) {
564 System.out.println(pv);
565 }
566 })
567 .subscribe(o);
568
569 scheduler.advanceTimeBy(5, TimeUnit.SECONDS);
570
571 inOrder.verify(o).onNext(Arrays.asList(1L, 2L, 3L));
572 inOrder.verify(o).onNext(Arrays.asList(3L, 4L));
573 inOrder.verify(o).onComplete();
574 verify(o, never()).onError(any(Throwable.class));
575 }
576
577 @Test
578 public void bufferWithSizeThrows() {
579 PublishSubject<Integer> source = PublishSubject.create();
580
581 Observable<List<Integer>> result = source.buffer(2);
582
583 Observer<Object> o = TestHelper.mockObserver();
584
585 InOrder inOrder = inOrder(o);
586
587 result.subscribe(o);
588
589 source.onNext(1);
590 source.onNext(2);
591 source.onNext(3);
592 source.onError(new TestException());
593
594 inOrder.verify(o).onNext(Arrays.asList(1, 2));
595 inOrder.verify(o).onError(any(TestException.class));
596 inOrder.verifyNoMoreInteractions();
597 verify(o, never()).onNext(Arrays.asList(3));
598 verify(o, never()).onComplete();
599
600 }
601
602 @Test
603 public void bufferWithTimeThrows() {
604 PublishSubject<Integer> source = PublishSubject.create();
605
606 Observable<List<Integer>> result = source.buffer(100, TimeUnit.MILLISECONDS, scheduler);
607
608 Observer<Object> o = TestHelper.mockObserver();
609 InOrder inOrder = inOrder(o);
610
611 result.subscribe(o);
612
613 source.onNext(1);
614 source.onNext(2);
615 scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
616 source.onNext(3);
617 source.onError(new TestException());
618 scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
619
620 inOrder.verify(o).onNext(Arrays.asList(1, 2));
621 inOrder.verify(o).onError(any(TestException.class));
622 inOrder.verifyNoMoreInteractions();
623 verify(o, never()).onNext(Arrays.asList(3));
624 verify(o, never()).onComplete();
625
626 }
627
628 @Test
629 public void bufferWithTimeAndSize() {
630 Observable<Long> source = Observable.interval(30, 30, TimeUnit.MILLISECONDS, scheduler);
631
632 Observable<List<Long>> result = source.buffer(100, TimeUnit.MILLISECONDS, scheduler, 2).take(3);
633
634 Observer<Object> o = TestHelper.mockObserver();
635 InOrder inOrder = inOrder(o);
636
637 result.subscribe(o);
638
639 scheduler.advanceTimeBy(5, TimeUnit.SECONDS);
640
641 inOrder.verify(o).onNext(Arrays.asList(0L, 1L));
642 inOrder.verify(o).onNext(Arrays.asList(2L));
643 inOrder.verify(o).onComplete();
644 verify(o, never()).onError(any(Throwable.class));
645 }
646
647 @Test
648 public void bufferWithStartEndStartThrows() {
649 PublishSubject<Integer> start = PublishSubject.create();
650
651 Function<Integer, Observable<Integer>> end = new Function<Integer, Observable<Integer>>() {
652 @Override
653 public Observable<Integer> apply(Integer t1) {
654 return Observable.never();
655 }
656 };
657
658 PublishSubject<Integer> source = PublishSubject.create();
659
660 Observable<List<Integer>> result = source.buffer(start, end);
661
662 Observer<Object> o = TestHelper.mockObserver();
663
664 result.subscribe(o);
665
666 start.onNext(1);
667 source.onNext(1);
668 source.onNext(2);
669 start.onError(new TestException());
670
671 verify(o, never()).onNext(any());
672 verify(o, never()).onComplete();
673 verify(o).onError(any(TestException.class));
674 }
675
676 @Test
677 public void bufferWithStartEndEndFunctionThrows() {
678 PublishSubject<Integer> start = PublishSubject.create();
679
680 Function<Integer, Observable<Integer>> end = new Function<Integer, Observable<Integer>>() {
681 @Override
682 public Observable<Integer> apply(Integer t1) {
683 throw new TestException();
684 }
685 };
686
687 PublishSubject<Integer> source = PublishSubject.create();
688
689 Observable<List<Integer>> result = source.buffer(start, end);
690
691 Observer<Object> o = TestHelper.mockObserver();
692
693 result.subscribe(o);
694
695 start.onNext(1);
696 source.onNext(1);
697 source.onNext(2);
698
699 verify(o, never()).onNext(any());
700 verify(o, never()).onComplete();
701 verify(o).onError(any(TestException.class));
702 }
703
704 @Test
705 public void bufferWithStartEndEndThrows() {
706 PublishSubject<Integer> start = PublishSubject.create();
707
708 Function<Integer, Observable<Integer>> end = new Function<Integer, Observable<Integer>>() {
709 @Override
710 public Observable<Integer> apply(Integer t1) {
711 return Observable.error(new TestException());
712 }
713 };
714
715 PublishSubject<Integer> source = PublishSubject.create();
716
717 Observable<List<Integer>> result = source.buffer(start, end);
718
719 Observer<Object> o = TestHelper.mockObserver();
720
721 result.subscribe(o);
722
723 start.onNext(1);
724 source.onNext(1);
725 source.onNext(2);
726
727 verify(o, never()).onNext(any());
728 verify(o, never()).onComplete();
729 verify(o).onError(any(TestException.class));
730 }
731
732 @Test
733 public void bufferWithTimeDoesntUnsubscribeDownstream() throws InterruptedException {
734 final Observer<Object> o = TestHelper.mockObserver();
735
736 final CountDownLatch cdl = new CountDownLatch(1);
737 DisposableObserver<Object> observer = new DisposableObserver<Object>() {
738 @Override
739 public void onNext(Object t) {
740 o.onNext(t);
741 }
742
743 @Override
744 public void onError(Throwable e) {
745 o.onError(e);
746 cdl.countDown();
747 }
748
749 @Override
750 public void onComplete() {
751 o.onComplete();
752 cdl.countDown();
753 }
754 };
755
756 Observable.range(1, 1).delay(1, TimeUnit.SECONDS).buffer(2, TimeUnit.SECONDS).subscribe(observer);
757
758 cdl.await();
759
760 verify(o).onNext(Arrays.asList(1));
761 verify(o).onComplete();
762 verify(o, never()).onError(any(Throwable.class));
763
764 assertFalse(observer.isDisposed());
765 }
766
767 @Test
768 public void bufferTimeSkipDefault() {
769 Observable.range(1, 5).buffer(1, 1, TimeUnit.MINUTES)
770 .test()
771 .assertResult(Arrays.asList(1, 2, 3, 4, 5));
772 }
773
774 @Test
775 public void bufferBoundaryHint() {
776 Observable.range(1, 5).buffer(Observable.timer(1, TimeUnit.MINUTES), 2)
777 .test()
778 .assertResult(Arrays.asList(1, 2, 3, 4, 5));
779 }
780
781 static HashSet<Integer> set(Integer... values) {
782 return new HashSet<>(Arrays.asList(values));
783 }
784
785 @Test
786 public void bufferIntoCustomCollection() {
787 Observable.just(1, 1, 2, 2, 3, 3, 4, 4)
788 .buffer(3, new Supplier<Collection<Integer>>() {
789 @Override
790 public Collection<Integer> get() throws Exception {
791 return new HashSet<>();
792 }
793 })
794 .test()
795 .assertResult(set(1, 2), set(2, 3), set(4));
796 }
797
798 @Test
799 public void bufferSkipIntoCustomCollection() {
800 Observable.just(1, 1, 2, 2, 3, 3, 4, 4)
801 .buffer(3, 3, new Supplier<Collection<Integer>>() {
802 @Override
803 public Collection<Integer> get() throws Exception {
804 return new HashSet<>();
805 }
806 })
807 .test()
808 .assertResult(set(1, 2), set(2, 3), set(4));
809 }
810
811 @Test
812 public void supplierThrows() {
813 Observable.just(1)
814 .buffer(1, TimeUnit.SECONDS, Schedulers.single(), Integer.MAX_VALUE, new Supplier<Collection<Integer>>() {
815 @Override
816 public Collection<Integer> get() throws Exception {
817 throw new TestException();
818 }
819 }, false)
820 .test()
821 .assertFailure(TestException.class);
822 }
823
824 @Test
825 public void supplierThrows2() {
826 Observable.just(1)
827 .buffer(1, TimeUnit.SECONDS, Schedulers.single(), 10, new Supplier<Collection<Integer>>() {
828 @Override
829 public Collection<Integer> get() throws Exception {
830 throw new TestException();
831 }
832 }, false)
833 .test()
834 .assertFailure(TestException.class);
835 }
836
837 @Test
838 public void supplierThrows3() {
839 Observable.just(1)
840 .buffer(2, 1, TimeUnit.SECONDS, Schedulers.single(), new Supplier<Collection<Integer>>() {
841 @Override
842 public Collection<Integer> get() throws Exception {
843 throw new TestException();
844 }
845 })
846 .test()
847 .assertFailure(TestException.class);
848 }
849
850 @Test
851 public void supplierThrows4() {
852 Observable.<Integer>never()
853 .buffer(1, TimeUnit.MILLISECONDS, Schedulers.single(), Integer.MAX_VALUE, new Supplier<Collection<Integer>>() {
854 int count;
855 @Override
856 public Collection<Integer> get() throws Exception {
857 if (count++ == 1) {
858 throw new TestException();
859 } else {
860 return new ArrayList<>();
861 }
862 }
863 }, false)
864 .test()
865 .awaitDone(5, TimeUnit.SECONDS)
866 .assertFailure(TestException.class);
867 }
868
869 @Test
870 public void supplierThrows5() {
871 Observable.<Integer>never()
872 .buffer(1, TimeUnit.MILLISECONDS, Schedulers.single(), 10, new Supplier<Collection<Integer>>() {
873 int count;
874 @Override
875 public Collection<Integer> get() throws Exception {
876 if (count++ == 1) {
877 throw new TestException();
878 } else {
879 return new ArrayList<>();
880 }
881 }
882 }, false)
883 .test()
884 .awaitDone(5, TimeUnit.SECONDS)
885 .assertFailure(TestException.class);
886 }
887
888 @Test
889 public void supplierThrows6() {
890 Observable.<Integer>never()
891 .buffer(2, 1, TimeUnit.MILLISECONDS, Schedulers.single(), new Supplier<Collection<Integer>>() {
892 int count;
893 @Override
894 public Collection<Integer> get() throws Exception {
895 if (count++ == 1) {
896 throw new TestException();
897 } else {
898 return new ArrayList<>();
899 }
900 }
901 })
902 .test()
903 .awaitDone(5, TimeUnit.SECONDS)
904 .assertFailure(TestException.class);
905 }
906
907 @Test
908 public void supplierReturnsNull() {
909 Observable.<Integer>never()
910 .buffer(1, TimeUnit.MILLISECONDS, Schedulers.single(), Integer.MAX_VALUE, new Supplier<Collection<Integer>>() {
911 int count;
912 @Override
913 public Collection<Integer> get() throws Exception {
914 if (count++ == 1) {
915 return null;
916 } else {
917 return new ArrayList<>();
918 }
919 }
920 }, false)
921 .test()
922 .awaitDone(5, TimeUnit.SECONDS)
923 .assertFailure(NullPointerException.class);
924 }
925
926 @Test
927 public void supplierReturnsNull2() {
928 Observable.<Integer>never()
929 .buffer(1, TimeUnit.MILLISECONDS, Schedulers.single(), 10, new Supplier<Collection<Integer>>() {
930 int count;
931 @Override
932 public Collection<Integer> get() throws Exception {
933 if (count++ == 1) {
934 return null;
935 } else {
936 return new ArrayList<>();
937 }
938 }
939 }, false)
940 .test()
941 .awaitDone(5, TimeUnit.SECONDS)
942 .assertFailure(NullPointerException.class);
943 }
944
945 @Test
946 public void supplierReturnsNull3() {
947 Observable.<Integer>never()
948 .buffer(2, 1, TimeUnit.MILLISECONDS, Schedulers.single(), new Supplier<Collection<Integer>>() {
949 int count;
950 @Override
951 public Collection<Integer> get() throws Exception {
952 if (count++ == 1) {
953 return null;
954 } else {
955 return new ArrayList<>();
956 }
957 }
958 })
959 .test()
960 .awaitDone(5, TimeUnit.SECONDS)
961 .assertFailure(NullPointerException.class);
962 }
963
964 @Test
965 public void dispose() {
966 TestHelper.checkDisposed(Observable.range(1, 5).buffer(1, TimeUnit.DAYS, Schedulers.single()));
967
968 TestHelper.checkDisposed(Observable.range(1, 5).buffer(2, 1, TimeUnit.DAYS, Schedulers.single()));
969
970 TestHelper.checkDisposed(Observable.range(1, 5).buffer(1, 2, TimeUnit.DAYS, Schedulers.single()));
971
972 TestHelper.checkDisposed(Observable.range(1, 5)
973 .buffer(1, TimeUnit.DAYS, Schedulers.single(), 2, Functions.<Integer>createArrayList(16), true));
974
975 TestHelper.checkDisposed(Observable.range(1, 5).buffer(1));
976
977 TestHelper.checkDisposed(Observable.range(1, 5).buffer(2, 1));
978
979 TestHelper.checkDisposed(Observable.range(1, 5).buffer(1, 2));
980
981 TestHelper.checkDisposed(PublishSubject.create().buffer(Observable.never()));
982
983 TestHelper.checkDisposed(PublishSubject.create().buffer(Observable.never(), Functions.justFunction(Observable.never())));
984 }
985
986 @Test
987 public void restartTimer() {
988 Observable.range(1, 5)
989 .buffer(1, TimeUnit.DAYS, Schedulers.single(), 2, Functions.<Integer>createArrayList(16), true)
990 .test()
991 .assertResult(Arrays.asList(1, 2), Arrays.asList(3, 4), Arrays.asList(5));
992 }
993
994 @Test
995 public void bufferSupplierCrash2() {
996 Observable.range(1, 2)
997 .buffer(1, new Supplier<List<Integer>>() {
998 int calls;
999 @Override
1000 public List<Integer> get() throws Exception {
1001 if (++calls == 2) {
1002 throw new TestException();
1003 }
1004 return new ArrayList<>();
1005 }
1006 })
1007 .test()
1008 .assertFailure(TestException.class, Arrays.asList(1));
1009 }
1010
1011 @Test
1012 public void bufferSkipSupplierCrash2() {
1013 Observable.range(1, 2)
1014 .buffer(2, 1, new Supplier<List<Integer>>() {
1015 int calls;
1016 @Override
1017 public List<Integer> get() throws Exception {
1018 if (++calls == 2) {
1019 throw new TestException();
1020 }
1021 return new ArrayList<>();
1022 }
1023 })
1024 .test()
1025 .assertFailure(TestException.class);
1026 }
1027
1028 @Test
1029 public void bufferSkipError() {
1030 Observable.<Integer>error(new TestException())
1031 .buffer(2, 1)
1032 .test()
1033 .assertFailure(TestException.class);
1034 }
1035
1036 @Test
1037 public void bufferSkipOverlap() {
1038 Observable.range(1, 5)
1039 .buffer(5, 1)
1040 .test()
1041 .assertResult(
1042 Arrays.asList(1, 2, 3, 4, 5),
1043 Arrays.asList(2, 3, 4, 5),
1044 Arrays.asList(3, 4, 5),
1045 Arrays.asList(4, 5),
1046 Arrays.asList(5)
1047 );
1048 }
1049
1050 @Test
1051 public void bufferTimedExactError() {
1052 Observable.error(new TestException())
1053 .buffer(1, TimeUnit.DAYS)
1054 .test()
1055 .assertFailure(TestException.class);
1056 }
1057
1058 @Test
1059 public void bufferTimedSkipError() {
1060 Observable.error(new TestException())
1061 .buffer(1, 2, TimeUnit.DAYS)
1062 .test()
1063 .assertFailure(TestException.class);
1064 }
1065
1066 @Test
1067 public void bufferTimedOverlapError() {
1068 Observable.error(new TestException())
1069 .buffer(2, 1, TimeUnit.DAYS)
1070 .test()
1071 .assertFailure(TestException.class);
1072 }
1073
1074 @Test
1075 public void bufferTimedExactEmpty() {
1076 Observable.empty()
1077 .buffer(1, TimeUnit.DAYS)
1078 .test()
1079 .assertResult(Collections.emptyList());
1080 }
1081
1082 @Test
1083 public void bufferTimedSkipEmpty() {
1084 Observable.empty()
1085 .buffer(1, 2, TimeUnit.DAYS)
1086 .test()
1087 .assertResult(Collections.emptyList());
1088 }
1089
1090 @Test
1091 public void bufferTimedOverlapEmpty() {
1092 Observable.empty()
1093 .buffer(2, 1, TimeUnit.DAYS)
1094 .test()
1095 .assertResult(Collections.emptyList());
1096 }
1097
1098 @Test
1099 public void bufferTimedExactSupplierCrash() {
1100 TestScheduler scheduler = new TestScheduler();
1101
1102 PublishSubject<Integer> ps = PublishSubject.create();
1103
1104 TestObserver<List<Integer>> to = ps
1105 .buffer(1, TimeUnit.MILLISECONDS, scheduler, 1, new Supplier<List<Integer>>() {
1106 int calls;
1107 @Override
1108 public List<Integer> get() throws Exception {
1109 if (++calls == 2) {
1110 throw new TestException();
1111 }
1112 return new ArrayList<>();
1113 }
1114 }, true)
1115 .test();
1116
1117 ps.onNext(1);
1118
1119 scheduler.advanceTimeBy(1, TimeUnit.MILLISECONDS);
1120
1121 ps.onNext(2);
1122
1123 to
1124 .assertFailure(TestException.class, Arrays.asList(1));
1125 }
1126
1127 @Test
1128 public void bufferTimedExactBoundedError() {
1129 TestScheduler scheduler = new TestScheduler();
1130
1131 PublishSubject<Integer> ps = PublishSubject.create();
1132
1133 TestObserver<List<Integer>> to = ps
1134 .buffer(1, TimeUnit.MILLISECONDS, scheduler, 1, Functions.<Integer>createArrayList(16), true)
1135 .test();
1136
1137 ps.onError(new TestException());
1138
1139 to
1140 .assertFailure(TestException.class);
1141 }
1142
1143 @Test
1144 public void withTimeAndSizeCapacityRace() {
1145 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
1146 final TestScheduler scheduler = new TestScheduler();
1147
1148 final PublishSubject<Object> ps = PublishSubject.create();
1149
1150 TestObserver<List<Object>> to = ps.buffer(1, TimeUnit.SECONDS, scheduler, 5).test();
1151
1152 ps.onNext(1);
1153 ps.onNext(2);
1154 ps.onNext(3);
1155 ps.onNext(4);
1156
1157 Runnable r1 = new Runnable() {
1158 @Override
1159 public void run() {
1160 ps.onNext(5);
1161 }
1162 };
1163
1164 Runnable r2 = new Runnable() {
1165 @Override
1166 public void run() {
1167 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
1168 }
1169 };
1170
1171 TestHelper.race(r1, r2);
1172
1173 ps.onComplete();
1174
1175 int items = 0;
1176 for (List<Object> o : to.values()) {
1177 items += o.size();
1178 }
1179
1180 assertEquals("Round: " + i, 5, items);
1181 }
1182 }
1183
1184 @Test
1185 public void noCompletionCancelExact() {
1186 final AtomicInteger counter = new AtomicInteger();
1187
1188 Observable.<Integer>empty()
1189 .doOnDispose(new Action() {
1190 @Override
1191 public void run() throws Exception {
1192 counter.getAndIncrement();
1193 }
1194 })
1195 .buffer(5, TimeUnit.SECONDS)
1196 .test()
1197 .awaitDone(5, TimeUnit.SECONDS)
1198 .assertResult(Collections.<Integer>emptyList());
1199
1200 assertEquals(0, counter.get());
1201 }
1202
1203 @Test
1204 public void noCompletionCancelSkip() {
1205 final AtomicInteger counter = new AtomicInteger();
1206
1207 Observable.<Integer>empty()
1208 .doOnDispose(new Action() {
1209 @Override
1210 public void run() throws Exception {
1211 counter.getAndIncrement();
1212 }
1213 })
1214 .buffer(5, 10, TimeUnit.SECONDS)
1215 .test()
1216 .awaitDone(5, TimeUnit.SECONDS)
1217 .assertResult(Collections.<Integer>emptyList());
1218
1219 assertEquals(0, counter.get());
1220 }
1221
1222 @Test
1223 public void noCompletionCancelOverlap() {
1224 final AtomicInteger counter = new AtomicInteger();
1225
1226 Observable.<Integer>empty()
1227 .doOnDispose(new Action() {
1228 @Override
1229 public void run() throws Exception {
1230 counter.getAndIncrement();
1231 }
1232 })
1233 .buffer(10, 5, TimeUnit.SECONDS)
1234 .test()
1235 .awaitDone(5, TimeUnit.SECONDS)
1236 .assertResult(Collections.<Integer>emptyList());
1237
1238 assertEquals(0, counter.get());
1239 }
1240
1241 @Test
1242 public void boundaryOpenCloseDisposedOnComplete() {
1243 PublishSubject<Integer> source = PublishSubject.create();
1244
1245 PublishSubject<Integer> openIndicator = PublishSubject.create();
1246
1247 PublishSubject<Integer> closeIndicator = PublishSubject.create();
1248
1249 TestObserver<List<Integer>> to = source
1250 .buffer(openIndicator, Functions.justFunction(closeIndicator))
1251 .test();
1252
1253 assertTrue(source.hasObservers());
1254 assertTrue(openIndicator.hasObservers());
1255 assertFalse(closeIndicator.hasObservers());
1256
1257 openIndicator.onNext(1);
1258
1259 assertTrue(openIndicator.hasObservers());
1260 assertTrue(closeIndicator.hasObservers());
1261
1262 source.onComplete();
1263
1264 to.assertResult(Collections.<Integer>emptyList());
1265
1266 assertFalse(openIndicator.hasObservers());
1267 assertFalse(closeIndicator.hasObservers());
1268 }
1269
1270 @Test
1271 public void bufferedCanCompleteIfOpenNeverCompletesDropping() {
1272 Observable.range(1, 50)
1273 .zipWith(Observable.interval(5, TimeUnit.MILLISECONDS),
1274 new BiFunction<Integer, Long, Integer>() {
1275 @Override
1276 public Integer apply(Integer integer, Long aLong) {
1277 return integer;
1278 }
1279 })
1280 .buffer(Observable.interval(0, 200, TimeUnit.MILLISECONDS),
1281 new Function<Long, Observable<?>>() {
1282 @Override
1283 public Observable<?> apply(Long a) {
1284 return Observable.just(a).delay(100, TimeUnit.MILLISECONDS);
1285 }
1286 })
1287 .to(TestHelper.<List<Integer>>testConsumer())
1288 .assertSubscribed()
1289 .awaitDone(3, TimeUnit.SECONDS)
1290 .assertComplete();
1291 }
1292
1293 @Test
1294 public void bufferedCanCompleteIfOpenNeverCompletesOverlapping() {
1295 Observable.range(1, 50)
1296 .zipWith(Observable.interval(5, TimeUnit.MILLISECONDS),
1297 new BiFunction<Integer, Long, Integer>() {
1298 @Override
1299 public Integer apply(Integer integer, Long aLong) {
1300 return integer;
1301 }
1302 })
1303 .buffer(Observable.interval(0, 100, TimeUnit.MILLISECONDS),
1304 new Function<Long, Observable<?>>() {
1305 @Override
1306 public Observable<?> apply(Long a) {
1307 return Observable.just(a).delay(200, TimeUnit.MILLISECONDS);
1308 }
1309 })
1310 .to(TestHelper.<List<Integer>>testConsumer())
1311 .assertSubscribed()
1312 .awaitDone(3, TimeUnit.SECONDS)
1313 .assertComplete();
1314 }
1315
1316 @Test
1317 public void openClosemainError() {
1318 Observable.error(new TestException())
1319 .buffer(Observable.never(), Functions.justFunction(Observable.never()))
1320 .test()
1321 .assertFailure(TestException.class);
1322 }
1323
1324 @Test
1325 public void openClosebadSource() {
1326 List<Throwable> errors = TestHelper.trackPluginErrors();
1327 try {
1328 new Observable<Object>() {
1329 @Override
1330 protected void subscribeActual(Observer<? super Object> observer) {
1331 Disposable bs1 = Disposable.empty();
1332 Disposable bs2 = Disposable.empty();
1333
1334 observer.onSubscribe(bs1);
1335
1336 assertFalse(bs1.isDisposed());
1337 assertFalse(bs2.isDisposed());
1338
1339 observer.onSubscribe(bs2);
1340
1341 assertFalse(bs1.isDisposed());
1342 assertTrue(bs2.isDisposed());
1343
1344 observer.onError(new IOException());
1345 observer.onComplete();
1346 observer.onNext(1);
1347 observer.onError(new TestException());
1348 }
1349 }
1350 .buffer(Observable.never(), Functions.justFunction(Observable.never()))
1351 .test()
1352 .assertFailure(IOException.class);
1353
1354 TestHelper.assertError(errors, 0, ProtocolViolationException.class);
1355 TestHelper.assertUndeliverable(errors, 1, TestException.class);
1356 } finally {
1357 RxJavaPlugins.reset();
1358 }
1359 }
1360
1361 @Test
1362 public void openCloseOpenCompletes() {
1363 PublishSubject<Integer> source = PublishSubject.create();
1364
1365 PublishSubject<Integer> openIndicator = PublishSubject.create();
1366
1367 PublishSubject<Integer> closeIndicator = PublishSubject.create();
1368
1369 TestObserver<List<Integer>> to = source
1370 .buffer(openIndicator, Functions.justFunction(closeIndicator))
1371 .test();
1372
1373 openIndicator.onNext(1);
1374
1375 assertTrue(closeIndicator.hasObservers());
1376
1377 openIndicator.onComplete();
1378
1379 assertTrue(source.hasObservers());
1380 assertTrue(closeIndicator.hasObservers());
1381
1382 closeIndicator.onComplete();
1383
1384 assertFalse(source.hasObservers());
1385
1386 to.assertResult(Collections.<Integer>emptyList());
1387 }
1388
1389 @Test
1390 public void openCloseOpenCompletesNoBuffers() {
1391 PublishSubject<Integer> source = PublishSubject.create();
1392
1393 PublishSubject<Integer> openIndicator = PublishSubject.create();
1394
1395 PublishSubject<Integer> closeIndicator = PublishSubject.create();
1396
1397 TestObserver<List<Integer>> to = source
1398 .buffer(openIndicator, Functions.justFunction(closeIndicator))
1399 .test();
1400
1401 openIndicator.onNext(1);
1402
1403 assertTrue(closeIndicator.hasObservers());
1404
1405 closeIndicator.onComplete();
1406
1407 assertTrue(source.hasObservers());
1408 assertTrue(openIndicator.hasObservers());
1409
1410 openIndicator.onComplete();
1411
1412 assertFalse(source.hasObservers());
1413
1414 to.assertResult(Collections.<Integer>emptyList());
1415 }
1416
1417 @Test
1418 public void openCloseTake() {
1419 PublishSubject<Integer> source = PublishSubject.create();
1420
1421 PublishSubject<Integer> openIndicator = PublishSubject.create();
1422
1423 PublishSubject<Integer> closeIndicator = PublishSubject.create();
1424
1425 TestObserver<List<Integer>> to = source
1426 .buffer(openIndicator, Functions.justFunction(closeIndicator))
1427 .take(1)
1428 .test();
1429
1430 openIndicator.onNext(1);
1431 closeIndicator.onComplete();
1432
1433 assertFalse(source.hasObservers());
1434 assertFalse(openIndicator.hasObservers());
1435 assertFalse(closeIndicator.hasObservers());
1436
1437 to.assertResult(Collections.<Integer>emptyList());
1438 }
1439
1440 @Test
1441 public void openCloseBadOpen() {
1442 List<Throwable> errors = TestHelper.trackPluginErrors();
1443 try {
1444 Observable.never()
1445 .buffer(new Observable<Object>() {
1446 @Override
1447 protected void subscribeActual(Observer<? super Object> observer) {
1448
1449 assertFalse(((Disposable)observer).isDisposed());
1450
1451 Disposable bs1 = Disposable.empty();
1452 Disposable bs2 = Disposable.empty();
1453
1454 observer.onSubscribe(bs1);
1455
1456 assertFalse(bs1.isDisposed());
1457 assertFalse(bs2.isDisposed());
1458
1459 observer.onSubscribe(bs2);
1460
1461 assertFalse(bs1.isDisposed());
1462 assertTrue(bs2.isDisposed());
1463
1464 observer.onError(new IOException());
1465
1466 assertTrue(((Disposable)observer).isDisposed());
1467
1468 observer.onComplete();
1469 observer.onNext(1);
1470 observer.onError(new TestException());
1471 }
1472 }, Functions.justFunction(Observable.never()))
1473 .test()
1474 .assertFailure(IOException.class);
1475
1476 TestHelper.assertError(errors, 0, ProtocolViolationException.class);
1477 TestHelper.assertUndeliverable(errors, 1, TestException.class);
1478 } finally {
1479 RxJavaPlugins.reset();
1480 }
1481 }
1482
1483 @Test
1484 public void openCloseBadClose() {
1485 List<Throwable> errors = TestHelper.trackPluginErrors();
1486 try {
1487 Observable.never()
1488 .buffer(Observable.just(1).concatWith(Observable.<Integer>never()),
1489 Functions.justFunction(new Observable<Object>() {
1490 @Override
1491 protected void subscribeActual(Observer<? super Object> observer) {
1492
1493 assertFalse(((Disposable)observer).isDisposed());
1494
1495 Disposable bs1 = Disposable.empty();
1496 Disposable bs2 = Disposable.empty();
1497
1498 observer.onSubscribe(bs1);
1499
1500 assertFalse(bs1.isDisposed());
1501 assertFalse(bs2.isDisposed());
1502
1503 observer.onSubscribe(bs2);
1504
1505 assertFalse(bs1.isDisposed());
1506 assertTrue(bs2.isDisposed());
1507
1508 observer.onError(new IOException());
1509
1510 assertTrue(((Disposable)observer).isDisposed());
1511
1512 observer.onComplete();
1513 observer.onNext(1);
1514 observer.onError(new TestException());
1515 }
1516 }))
1517 .test()
1518 .assertFailure(IOException.class);
1519
1520 TestHelper.assertError(errors, 0, ProtocolViolationException.class);
1521 TestHelper.assertUndeliverable(errors, 1, TestException.class);
1522 } finally {
1523 RxJavaPlugins.reset();
1524 }
1525 }
1526
1527 @Test
1528 public void bufferExactBoundaryDoubleOnSubscribe() {
1529 TestHelper.checkDoubleOnSubscribeObservable(
1530 new Function<Observable<Object>, ObservableSource<List<Object>>>() {
1531 @Override
1532 public ObservableSource<List<Object>> apply(Observable<Object> f)
1533 throws Exception {
1534 return f.buffer(Observable.never());
1535 }
1536 }
1537 );
1538 }
1539
1540 @Test
1541 public void bufferExactBoundarySecondBufferCrash() {
1542 PublishSubject<Integer> ps = PublishSubject.create();
1543 PublishSubject<Integer> b = PublishSubject.create();
1544
1545 TestObserver<List<Integer>> to = ps.buffer(b, new Supplier<List<Integer>>() {
1546 int calls;
1547 @Override
1548 public List<Integer> get() throws Exception {
1549 if (++calls == 2) {
1550 throw new TestException();
1551 }
1552 return new ArrayList<>();
1553 }
1554 }).test();
1555
1556 b.onNext(1);
1557
1558 to.assertFailure(TestException.class);
1559 }
1560
1561 @Test
1562 public void bufferExactBoundaryBadSource() {
1563 Observable<Integer> ps = new Observable<Integer>() {
1564 @Override
1565 protected void subscribeActual(Observer<? super Integer> observer) {
1566 observer.onSubscribe(Disposable.empty());
1567 observer.onComplete();
1568 observer.onNext(1);
1569 observer.onComplete();
1570 }
1571 };
1572
1573 final AtomicReference<Observer<? super Integer>> ref = new AtomicReference<>();
1574 Observable<Integer> b = new Observable<Integer>() {
1575 @Override
1576 protected void subscribeActual(Observer<? super Integer> observer) {
1577 observer.onSubscribe(Disposable.empty());
1578 ref.set(observer);
1579 }
1580 };
1581
1582 TestObserver<List<Integer>> to = ps.buffer(b).test();
1583
1584 ref.get().onNext(1);
1585
1586 to.assertResult(Collections.<Integer>emptyList());
1587 }
1588
1589 @Test
1590 public void timedDoubleOnSubscribe() {
1591 TestHelper.checkDoubleOnSubscribeObservable(new Function<Observable<Object>, Observable<List<Object>>>() {
1592 @Override
1593 public Observable<List<Object>> apply(Observable<Object> f)
1594 throws Exception {
1595 return f.buffer(1, TimeUnit.SECONDS);
1596 }
1597 });
1598 }
1599
1600 @Test
1601 public void timedCancelledUpfront() {
1602 TestScheduler sch = new TestScheduler();
1603
1604 TestObserver<List<Object>> to = Observable.never()
1605 .buffer(1, TimeUnit.MILLISECONDS, sch)
1606 .test(true);
1607
1608 sch.advanceTimeBy(1, TimeUnit.MILLISECONDS);
1609
1610 to.assertEmpty();
1611 }
1612
1613 @Test
1614 public void timedInternalState() {
1615 TestScheduler sch = new TestScheduler();
1616
1617 TestObserver<List<Integer>> to = new TestObserver<>();
1618
1619 BufferExactUnboundedObserver<Integer, List<Integer>> sub = new BufferExactUnboundedObserver<>(
1620 to, Functions.justSupplier((List<Integer>) new ArrayList<Integer>()), 1, TimeUnit.SECONDS, sch);
1621
1622 sub.onSubscribe(Disposable.empty());
1623
1624 assertFalse(sub.isDisposed());
1625
1626 sub.onError(new TestException());
1627 sub.onNext(1);
1628 sub.onComplete();
1629
1630 sub.run();
1631
1632 sub.dispose();
1633
1634 assertTrue(sub.isDisposed());
1635
1636 sub.buffer = new ArrayList<>();
1637 sub.enter();
1638 sub.onComplete();
1639 }
1640
1641 @Test
1642 public void timedSkipDoubleOnSubscribe() {
1643 TestHelper.checkDoubleOnSubscribeObservable(new Function<Observable<Object>, Observable<List<Object>>>() {
1644 @Override
1645 public Observable<List<Object>> apply(Observable<Object> f)
1646 throws Exception {
1647 return f.buffer(2, 1, TimeUnit.SECONDS);
1648 }
1649 });
1650 }
1651
1652 @Test
1653 public void timedSizedDoubleOnSubscribe() {
1654 TestHelper.checkDoubleOnSubscribeObservable(new Function<Observable<Object>, Observable<List<Object>>>() {
1655 @Override
1656 public Observable<List<Object>> apply(Observable<Object> f)
1657 throws Exception {
1658 return f.buffer(2, TimeUnit.SECONDS, 10);
1659 }
1660 });
1661 }
1662
1663 @Test
1664 public void timedSkipInternalState() {
1665 TestScheduler sch = new TestScheduler();
1666
1667 TestObserver<List<Integer>> to = new TestObserver<>();
1668
1669 BufferSkipBoundedObserver<Integer, List<Integer>> sub = new BufferSkipBoundedObserver<>(
1670 to, Functions.justSupplier((List<Integer>) new ArrayList<Integer>()), 1, 1, TimeUnit.SECONDS, sch.createWorker());
1671
1672 sub.onSubscribe(Disposable.empty());
1673
1674 sub.enter();
1675 sub.onComplete();
1676
1677 sub.dispose();
1678
1679 sub.run();
1680 }
1681
1682 @Test
1683 public void timedSkipCancelWhenSecondBuffer() {
1684 TestScheduler sch = new TestScheduler();
1685
1686 final TestObserver<List<Integer>> to = new TestObserver<>();
1687
1688 BufferSkipBoundedObserver<Integer, List<Integer>> sub = new BufferSkipBoundedObserver<>(
1689 to, new Supplier<List<Integer>>() {
1690 int calls;
1691
1692 @Override
1693 public List<Integer> get() throws Exception {
1694 if (++calls == 2) {
1695 to.dispose();
1696 }
1697 return new ArrayList<>();
1698 }
1699 }, 1, 1, TimeUnit.SECONDS, sch.createWorker());
1700
1701 sub.onSubscribe(Disposable.empty());
1702
1703 sub.run();
1704
1705 assertTrue(to.isDisposed());
1706 }
1707
1708 @Test
1709 public void timedSizeBufferAlreadyCleared() {
1710 TestScheduler sch = new TestScheduler();
1711
1712 TestObserver<List<Integer>> to = new TestObserver<>();
1713
1714 BufferExactBoundedObserver<Integer, List<Integer>> sub =
1715 new BufferExactBoundedObserver<>(
1716 to, Functions.justSupplier((List<Integer>) new ArrayList<Integer>()),
1717 1, TimeUnit.SECONDS, 1, false, sch.createWorker())
1718 ;
1719
1720 Disposable bs = Disposable.empty();
1721
1722 sub.onSubscribe(bs);
1723
1724 sub.producerIndex++;
1725
1726 sub.run();
1727
1728 assertFalse(sub.isDisposed());
1729
1730 sub.enter();
1731 sub.onComplete();
1732
1733 sub.dispose();
1734
1735 assertTrue(sub.isDisposed());
1736
1737 sub.run();
1738
1739 sub.onNext(1);
1740 }
1741
1742 @Test
1743 public void bufferExactDoubleOnSubscribe() {
1744 TestHelper.checkDoubleOnSubscribeObservable(new Function<Observable<Object>, ObservableSource<List<Object>>>() {
1745 @Override
1746 public ObservableSource<List<Object>> apply(Observable<Object> o)
1747 throws Exception {
1748 return o.buffer(1);
1749 }
1750 });
1751 }
1752
1753 @Test
1754 public void bufferExactState() {
1755 TestObserver<List<Integer>> to = new TestObserver<>();
1756
1757 BufferExactObserver<Integer, List<Integer>> sub = new BufferExactObserver<>(
1758 to, 1, Functions.justSupplier((List<Integer>) new ArrayList<Integer>())
1759 );
1760
1761 sub.onComplete();
1762 sub.onNext(1);
1763 sub.onComplete();
1764 }
1765
1766 @Test
1767 public void bufferSkipDoubleOnSubscribe() {
1768 TestHelper.checkDoubleOnSubscribeObservable(new Function<Observable<Object>, ObservableSource<List<Object>>>() {
1769 @Override
1770 public ObservableSource<List<Object>> apply(Observable<Object> o)
1771 throws Exception {
1772 return o.buffer(1, 2);
1773 }
1774 });
1775 }
1776
1777 @Test
1778 public void bufferExactFailingSupplier() {
1779 Observable.empty()
1780 .buffer(1, TimeUnit.SECONDS, Schedulers.computation(), 10, new Supplier<List<Object>>() {
1781 @Override
1782 public List<Object> get() throws Exception {
1783 throw new TestException();
1784 }
1785 }, false)
1786 .test()
1787 .awaitDone(1, TimeUnit.SECONDS)
1788 .assertFailure(TestException.class)
1789 ;
1790 }
1791
1792 @Test
1793 public void timedUnboundedCancelUpfront() {
1794 Observable.never()
1795 .buffer(1, TimeUnit.SECONDS)
1796 .test(true)
1797 .assertEmpty();
1798 }
1799
1800 @Test
1801 public void boundaryCloseCompleteRace() {
1802 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
1803 BehaviorSubject<Integer> bs = BehaviorSubject.createDefault(1);
1804 PublishSubject<Integer> ps = PublishSubject.create();
1805
1806 TestObserver<List<Integer>> to = bs
1807 .buffer(BehaviorSubject.createDefault(0), v -> ps)
1808 .test();
1809
1810 TestHelper.race(
1811 () -> bs.onComplete(),
1812 () -> ps.onComplete()
1813 );
1814
1815 to.assertResult(Arrays.asList(1));
1816 }
1817 }
1818 }