Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableWindowWithTimeTest.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
18 import java.util.*;
19 import java.util.concurrent.*;
20 import java.util.concurrent.atomic.*;
21
22 import org.junit.*;
23 import org.reactivestreams.*;
24
25 import io.reactivex.rxjava3.core.*;
26 import io.reactivex.rxjava3.exceptions.*;
27 import io.reactivex.rxjava3.functions.*;
28 import io.reactivex.rxjava3.internal.functions.Functions;
29 import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
30 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
31 import io.reactivex.rxjava3.processors.*;
32 import io.reactivex.rxjava3.schedulers.*;
33 import io.reactivex.rxjava3.subscribers.*;
34 import io.reactivex.rxjava3.testsupport.*;
35
36 public class FlowableWindowWithTimeTest extends RxJavaTest {
37
38 private TestScheduler scheduler;
39 private Scheduler.Worker innerScheduler;
40
41 @Before
42 public void before() {
43 scheduler = new TestScheduler();
44 innerScheduler = scheduler.createWorker();
45 }
46
47 @Test
48 public void timedAndCount() {
49 final List<String> list = new ArrayList<>();
50 final List<List<String>> lists = new ArrayList<>();
51
52 Flowable<String> source = Flowable.unsafeCreate(new Publisher<String>() {
53 @Override
54 public void subscribe(Subscriber<? super String> subscriber) {
55 subscriber.onSubscribe(new BooleanSubscription());
56 push(subscriber, "one", 10);
57 push(subscriber, "two", 90);
58 push(subscriber, "three", 110);
59 push(subscriber, "four", 190);
60 push(subscriber, "five", 210);
61 complete(subscriber, 250);
62 }
63 });
64
65 Flowable<Flowable<String>> windowed = source.window(100, TimeUnit.MILLISECONDS, scheduler, 2);
66 windowed.subscribe(observeWindow(list, lists));
67
68 scheduler.advanceTimeTo(95, TimeUnit.MILLISECONDS);
69 assertEquals(1, lists.size());
70 assertEquals(lists.get(0), list("one", "two"));
71
72 scheduler.advanceTimeTo(195, TimeUnit.MILLISECONDS);
73 assertEquals(3, lists.size());
74 assertTrue(lists.get(1).isEmpty());
75 assertEquals(lists.get(2), list("three", "four"));
76
77 scheduler.advanceTimeTo(300, TimeUnit.MILLISECONDS);
78 assertEquals(5, lists.size());
79 assertTrue(lists.get(3).isEmpty());
80 assertEquals(lists.get(4), list("five"));
81 }
82
83 @Test
84 public void timed() {
85 final List<String> list = new ArrayList<>();
86 final List<List<String>> lists = new ArrayList<>();
87
88 Flowable<String> source = Flowable.unsafeCreate(new Publisher<String>() {
89 @Override
90 public void subscribe(Subscriber<? super String> subscriber) {
91 subscriber.onSubscribe(new BooleanSubscription());
92 push(subscriber, "one", 98);
93 push(subscriber, "two", 99);
94 push(subscriber, "three", 99); // FIXME happens after the window is open
95 push(subscriber, "four", 101);
96 push(subscriber, "five", 102);
97 complete(subscriber, 150);
98 }
99 });
100
101 Flowable<Flowable<String>> windowed = source.window(100, TimeUnit.MILLISECONDS, scheduler);
102 windowed.subscribe(observeWindow(list, lists));
103
104 scheduler.advanceTimeTo(101, TimeUnit.MILLISECONDS);
105 assertEquals(1, lists.size());
106 assertEquals(lists.get(0), list("one", "two", "three"));
107
108 scheduler.advanceTimeTo(201, TimeUnit.MILLISECONDS);
109 assertEquals(2, lists.size());
110 assertEquals(lists.get(1), list("four", "five"));
111 }
112
113 private List<String> list(String... args) {
114 List<String> list = new ArrayList<>();
115 for (String arg : args) {
116 list.add(arg);
117 }
118 return list;
119 }
120
121 private <T> void push(final Subscriber<T> subscriber, final T value, int delay) {
122 innerScheduler.schedule(new Runnable() {
123 @Override
124 public void run() {
125 subscriber.onNext(value);
126 }
127 }, delay, TimeUnit.MILLISECONDS);
128 }
129
130 private void complete(final Subscriber<?> subscriber, int delay) {
131 innerScheduler.schedule(new Runnable() {
132 @Override
133 public void run() {
134 subscriber.onComplete();
135 }
136 }, delay, TimeUnit.MILLISECONDS);
137 }
138
139 private <T> Consumer<Flowable<T>> observeWindow(final List<T> list, final List<List<T>> lists) {
140 return new Consumer<Flowable<T>>() {
141 @Override
142 public void accept(Flowable<T> stringFlowable) {
143 stringFlowable.subscribe(new DefaultSubscriber<T>() {
144 @Override
145 public void onComplete() {
146 lists.add(new ArrayList<>(list));
147 list.clear();
148 }
149
150 @Override
151 public void onError(Throwable e) {
152 Assert.fail(e.getMessage());
153 }
154
155 @Override
156 public void onNext(T args) {
157 list.add(args);
158 }
159 });
160 }
161 };
162 }
163
164 @Test
165 public void exactWindowSize() {
166 Flowable<Flowable<Integer>> source = Flowable.range(1, 10)
167 .window(1, TimeUnit.MINUTES, scheduler, 3);
168
169 final List<Integer> list = new ArrayList<>();
170 final List<List<Integer>> lists = new ArrayList<>();
171
172 source.subscribe(observeWindow(list, lists));
173
174 assertEquals(4, lists.size());
175 assertEquals(3, lists.get(0).size());
176 assertEquals(Arrays.asList(1, 2, 3), lists.get(0));
177 assertEquals(3, lists.get(1).size());
178 assertEquals(Arrays.asList(4, 5, 6), lists.get(1));
179 assertEquals(3, lists.get(2).size());
180 assertEquals(Arrays.asList(7, 8, 9), lists.get(2));
181 assertEquals(1, lists.get(3).size());
182 assertEquals(Arrays.asList(10), lists.get(3));
183 }
184
185 @Test
186 public void takeFlatMapCompletes() {
187 TestSubscriber<Integer> ts = new TestSubscriber<>();
188
189 final AtomicInteger wip = new AtomicInteger();
190
191 final int indicator = 999999999;
192
193 FlowableWindowWithSizeTest.hotStream()
194 .window(300, TimeUnit.MILLISECONDS)
195 .take(10)
196 .doOnComplete(new Action() {
197 @Override
198 public void run() {
199 System.out.println("Main done!");
200 }
201 })
202 .flatMap(new Function<Flowable<Integer>, Flowable<Integer>>() {
203 @Override
204 public Flowable<Integer> apply(Flowable<Integer> w) {
205 return w.startWithItem(indicator)
206 .doOnComplete(new Action() {
207 @Override
208 public void run() {
209 System.out.println("inner done: " + wip.incrementAndGet());
210 }
211 })
212 ;
213 }
214 })
215 .doOnNext(new Consumer<Integer>() {
216 @Override
217 public void accept(Integer pv) {
218 System.out.println(pv);
219 }
220 })
221 .subscribe(ts);
222
223 ts.awaitDone(5, TimeUnit.SECONDS);
224 ts.assertComplete();
225 Assert.assertTrue(ts.values().size() != 0);
226 }
227
228 @Test
229 public void timespanTimeskipCustomSchedulerBufferSize() {
230 Flowable.range(1, 10)
231 .window(1, 1, TimeUnit.MINUTES, Schedulers.io(), 2)
232 .flatMap(Functions.<Flowable<Integer>>identity())
233 .test()
234 .awaitDone(5, TimeUnit.SECONDS)
235 .assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
236 }
237
238 @Test
239 public void timespanDefaultSchedulerSize() {
240 Flowable.range(1, 10)
241 .window(1, TimeUnit.MINUTES, 20)
242 .flatMap(Functions.<Flowable<Integer>>identity())
243 .test()
244 .awaitDone(5, TimeUnit.SECONDS)
245 .assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
246 }
247
248 @Test
249 public void timespanDefaultSchedulerSizeRestart() {
250 Flowable.range(1, 10)
251 .window(1, TimeUnit.MINUTES, 20, true)
252 .flatMap(Functions.<Flowable<Integer>>identity(), true)
253 .test()
254 .awaitDone(5, TimeUnit.SECONDS)
255 .assertResult(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
256 }
257
258 @Test
259 public void invalidSpan() {
260 try {
261 Flowable.just(1).window(-99, 1, TimeUnit.SECONDS);
262 fail("Should have thrown!");
263 } catch (IllegalArgumentException ex) {
264 assertEquals("timespan > 0 required but it was -99", ex.getMessage());
265 }
266 }
267
268 @Test
269 public void timespanTimeskipDefaultScheduler() {
270 Flowable.just(1)
271 .window(1, 1, TimeUnit.MINUTES)
272 .flatMap(Functions.<Flowable<Integer>>identity())
273 .test()
274 .awaitDone(5, TimeUnit.SECONDS)
275 .assertResult(1);
276 }
277
278 @Test
279 public void timespanTimeskipCustomScheduler() {
280 Flowable.just(1)
281 .window(1, 1, TimeUnit.MINUTES, Schedulers.io())
282 .flatMap(Functions.<Flowable<Integer>>identity())
283 .test()
284 .awaitDone(5, TimeUnit.SECONDS)
285 .assertResult(1);
286 }
287
288 @Test
289 public void timeskipJustOverlap() {
290 Flowable.just(1)
291 .window(2, 1, TimeUnit.MINUTES, Schedulers.single())
292 .flatMap(Functions.<Flowable<Integer>>identity())
293 .test()
294 .awaitDone(5, TimeUnit.SECONDS)
295 .assertResult(1);
296 }
297
298 @Test
299 public void timeskipJustSkip() {
300 Flowable.just(1)
301 .window(1, 2, TimeUnit.MINUTES, Schedulers.single())
302 .flatMap(Functions.<Flowable<Integer>>identity())
303 .test()
304 .awaitDone(5, TimeUnit.SECONDS)
305 .assertResult(1);
306 }
307
308 @Test
309 public void timeskipSkipping() {
310 TestScheduler scheduler = new TestScheduler();
311
312 PublishProcessor<Integer> pp = PublishProcessor.create();
313
314 TestSubscriber<Integer> ts = pp.window(1, 2, TimeUnit.SECONDS, scheduler)
315 .flatMap(Functions.<Flowable<Integer>>identity())
316 .test();
317
318 pp.onNext(1);
319 pp.onNext(2);
320
321 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
322
323 pp.onNext(3);
324 pp.onNext(4);
325
326 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
327
328 pp.onNext(5);
329 pp.onNext(6);
330
331 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
332
333 pp.onNext(7);
334 pp.onComplete();
335
336 ts.assertResult(1, 2, 5, 6);
337 }
338
339 @Test
340 public void timeskipOverlapping() {
341 TestScheduler scheduler = new TestScheduler();
342
343 PublishProcessor<Integer> pp = PublishProcessor.create();
344
345 TestSubscriber<Integer> ts = pp.window(2, 1, TimeUnit.SECONDS, scheduler)
346 .flatMap(Functions.<Flowable<Integer>>identity())
347 .test();
348
349 pp.onNext(1);
350 pp.onNext(2);
351
352 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
353
354 pp.onNext(3);
355 pp.onNext(4);
356
357 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
358
359 pp.onNext(5);
360 pp.onNext(6);
361
362 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
363
364 pp.onNext(7);
365 pp.onComplete();
366
367 ts.assertResult(1, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7);
368 }
369
370 @Test
371 public void exactOnError() {
372 List<Throwable> errors = TestHelper.trackPluginErrors();
373 try {
374 TestScheduler scheduler = new TestScheduler();
375
376 PublishProcessor<Integer> pp = PublishProcessor.create();
377
378 TestSubscriber<Integer> ts = pp.window(1, 1, TimeUnit.SECONDS, scheduler)
379 .flatMap(Functions.<Flowable<Integer>>identity())
380 .test();
381
382 pp.onError(new TestException());
383
384 ts.assertFailure(TestException.class);
385
386 TestHelper.assertUndeliverable(errors, 0, TestException.class);
387 } finally {
388 RxJavaPlugins.reset();
389 }
390 }
391
392 @Test
393 public void overlappingOnError() {
394 List<Throwable> errors = TestHelper.trackPluginErrors();
395 try {
396 TestScheduler scheduler = new TestScheduler();
397
398 PublishProcessor<Integer> pp = PublishProcessor.create();
399
400 TestSubscriber<Integer> ts = pp.window(2, 1, TimeUnit.SECONDS, scheduler)
401 .flatMap(Functions.<Flowable<Integer>>identity())
402 .test();
403
404 pp.onError(new TestException());
405
406 ts.assertFailure(TestException.class);
407
408 TestHelper.assertUndeliverable(errors, 0, TestException.class);
409 } finally {
410 RxJavaPlugins.reset();
411 }
412 }
413
414 @Test
415 public void skipOnError() {
416 List<Throwable> errors = TestHelper.trackPluginErrors();
417 try {
418 TestScheduler scheduler = new TestScheduler();
419
420 PublishProcessor<Integer> pp = PublishProcessor.create();
421
422 TestSubscriber<Integer> ts = pp.window(1, 2, TimeUnit.SECONDS, scheduler)
423 .flatMap(Functions.<Flowable<Integer>>identity())
424 .test();
425
426 pp.onError(new TestException());
427
428 ts.assertFailure(TestException.class);
429
430 TestHelper.assertUndeliverable(errors, 0, TestException.class);
431 } finally {
432 RxJavaPlugins.reset();
433 }
434 }
435
436 @Test
437 public void exactBackpressure() {
438 TestScheduler scheduler = new TestScheduler();
439
440 PublishProcessor<Integer> pp = PublishProcessor.create();
441
442 TestSubscriber<Flowable<Integer>> ts = pp.window(1, 1, TimeUnit.SECONDS, scheduler)
443 .test(0L);
444
445 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
446
447 ts.assertFailure(MissingBackpressureException.class);
448 }
449
450 @Test
451 public void skipBackpressure() {
452 TestScheduler scheduler = new TestScheduler();
453
454 PublishProcessor<Integer> pp = PublishProcessor.create();
455
456 TestSubscriber<Flowable<Integer>> ts = pp.window(1, 2, TimeUnit.SECONDS, scheduler)
457 .test(0L);
458
459 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
460
461 ts.assertFailure(MissingBackpressureException.class);
462 }
463
464 @Test
465 public void overlapBackpressure() {
466 TestScheduler scheduler = new TestScheduler();
467
468 PublishProcessor<Integer> pp = PublishProcessor.create();
469
470 TestSubscriber<Flowable<Integer>> ts = pp.window(2, 1, TimeUnit.SECONDS, scheduler)
471 .test(0L);
472
473 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
474
475 ts.assertFailure(MissingBackpressureException.class);
476 }
477
478 @Test
479 public void exactBackpressure2() {
480 TestScheduler scheduler = new TestScheduler();
481
482 PublishProcessor<Integer> pp = PublishProcessor.create();
483
484 TestSubscriber<Flowable<Integer>> ts = pp.window(1, 1, TimeUnit.SECONDS, scheduler)
485 .test(1L);
486
487 scheduler.advanceTimeBy(2, TimeUnit.SECONDS);
488
489 ts.assertError(MissingBackpressureException.class);
490 }
491
492 @Test
493 public void skipBackpressure2() {
494 TestScheduler scheduler = new TestScheduler();
495
496 PublishProcessor<Integer> pp = PublishProcessor.create();
497
498 TestSubscriber<Flowable<Integer>> ts = pp.window(1, 2, TimeUnit.SECONDS, scheduler)
499 .test(1L);
500
501 scheduler.advanceTimeBy(2, TimeUnit.SECONDS);
502
503 ts.assertError(MissingBackpressureException.class);
504 }
505
506 @Test
507 public void overlapBackpressure2() {
508 List<Throwable> errors = TestHelper.trackPluginErrors();
509 try {
510 TestScheduler scheduler = new TestScheduler();
511
512 PublishProcessor<Integer> pp = PublishProcessor.create();
513
514 final TestSubscriber<Integer> tsInner = new TestSubscriber<>();
515
516 TestSubscriber<Flowable<Integer>> ts = pp.window(2, 1, TimeUnit.SECONDS, scheduler)
517 .doOnNext(new Consumer<Flowable<Integer>>() {
518 @Override
519 public void accept(Flowable<Integer> w) throws Throwable {
520 w.subscribe(tsInner);
521 }
522 }) // avoid abandonment
523 .test(1L);
524
525 scheduler.advanceTimeBy(2, TimeUnit.SECONDS);
526
527 ts.assertError(MissingBackpressureException.class);
528
529 tsInner.assertError(MissingBackpressureException.class);
530
531 assertTrue(errors.isEmpty());
532 } finally {
533 RxJavaPlugins.reset();
534 }
535 }
536
537 @Test
538 public void dispose() {
539 TestHelper.checkDisposed(Flowable.range(1, 5).window(1, TimeUnit.DAYS, Schedulers.single()).onBackpressureDrop());
540
541 TestHelper.checkDisposed(Flowable.range(1, 5).window(2, 1, TimeUnit.DAYS, Schedulers.single()).onBackpressureDrop());
542
543 TestHelper.checkDisposed(Flowable.range(1, 5).window(1, 2, TimeUnit.DAYS, Schedulers.single()).onBackpressureDrop());
544
545 TestHelper.checkDisposed(Flowable.never()
546 .window(1, TimeUnit.DAYS, Schedulers.single(), 2, true).onBackpressureDrop());
547 }
548
549 @Test
550 public void restartTimer() {
551 Flowable.range(1, 5)
552 .window(1, TimeUnit.DAYS, Schedulers.single(), 2, true)
553 .flatMap(Functions.<Flowable<Integer>>identity())
554 .test()
555 .assertResult(1, 2, 3, 4, 5);
556 }
557
558 @Test
559 @SuppressUndeliverable
560 public void exactBoundaryError() {
561 Flowable.error(new TestException())
562 .window(1, TimeUnit.DAYS, Schedulers.single(), 2, true)
563 .to(TestHelper.<Flowable<Object>>testConsumer())
564 .assertSubscribed()
565 .assertError(TestException.class)
566 .assertNotComplete();
567 }
568
569 @Test
570 public void restartTimerMany() throws Exception {
571 final AtomicBoolean cancel1 = new AtomicBoolean();
572 Flowable.intervalRange(1, 1000, 1, 1, TimeUnit.MILLISECONDS)
573 .doOnCancel(new Action() {
574 @Override
575 public void run() throws Exception {
576 cancel1.set(true);
577 }
578 })
579 .window(1, TimeUnit.MILLISECONDS, Schedulers.single(), 2, true)
580 .flatMap(Functions.<Flowable<Long>>identity())
581 .take(500)
582 .to(TestHelper.<Long>testConsumer())
583 .awaitDone(5, TimeUnit.SECONDS)
584 .assertSubscribed()
585 .assertValueCount(500)
586 .assertNoErrors()
587 .assertComplete();
588
589 int timeout = 20;
590 while (timeout-- > 0 && !cancel1.get()) {
591 Thread.sleep(100);
592 }
593
594 assertTrue("intervalRange was not cancelled!", cancel1.get());
595 }
596
597 @Test
598 public void exactUnboundedReentrant() {
599 TestScheduler scheduler = new TestScheduler();
600
601 final FlowableProcessor<Integer> ps = PublishProcessor.<Integer>create();
602
603 TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
604 @Override
605 public void onNext(Integer t) {
606 super.onNext(t);
607 if (t == 1) {
608 ps.onNext(2);
609 ps.onComplete();
610 }
611 }
612 };
613
614 ps.window(1, TimeUnit.MILLISECONDS, scheduler)
615 .flatMap(new Function<Flowable<Integer>, Flowable<Integer>>() {
616 @Override
617 public Flowable<Integer> apply(Flowable<Integer> v) throws Exception {
618 return v;
619 }
620 })
621 .subscribe(ts);
622
623 ps.onNext(1);
624
625 ts
626 .awaitDone(1, TimeUnit.SECONDS)
627 .assertResult(1, 2);
628 }
629
630 @Test
631 public void exactBoundedReentrant() {
632 TestScheduler scheduler = new TestScheduler();
633
634 final FlowableProcessor<Integer> ps = PublishProcessor.<Integer>create();
635
636 TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
637 @Override
638 public void onNext(Integer t) {
639 super.onNext(t);
640 if (t == 1) {
641 ps.onNext(2);
642 ps.onComplete();
643 }
644 }
645 };
646
647 ps.window(1, TimeUnit.MILLISECONDS, scheduler, 10, true)
648 .flatMap(new Function<Flowable<Integer>, Flowable<Integer>>() {
649 @Override
650 public Flowable<Integer> apply(Flowable<Integer> v) throws Exception {
651 return v;
652 }
653 })
654 .subscribe(ts);
655
656 ps.onNext(1);
657
658 ts
659 .awaitDone(1, TimeUnit.SECONDS)
660 .assertResult(1, 2);
661 }
662
663 @Test
664 public void exactBoundedReentrant2() {
665 TestScheduler scheduler = new TestScheduler();
666
667 final FlowableProcessor<Integer> ps = PublishProcessor.<Integer>create();
668
669 TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
670 @Override
671 public void onNext(Integer t) {
672 super.onNext(t);
673 if (t == 1) {
674 ps.onNext(2);
675 ps.onComplete();
676 }
677 }
678 };
679
680 ps.window(1, TimeUnit.MILLISECONDS, scheduler, 2, true)
681 .flatMap(new Function<Flowable<Integer>, Flowable<Integer>>() {
682 @Override
683 public Flowable<Integer> apply(Flowable<Integer> v) throws Exception {
684 return v;
685 }
686 })
687 .subscribe(ts);
688
689 ps.onNext(1);
690
691 ts
692 .awaitDone(1, TimeUnit.SECONDS)
693 .assertResult(1, 2);
694 }
695
696 @Test
697 public void skipReentrant() {
698 TestScheduler scheduler = new TestScheduler();
699
700 final FlowableProcessor<Integer> ps = PublishProcessor.<Integer>create();
701
702 TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
703 @Override
704 public void onNext(Integer t) {
705 super.onNext(t);
706 if (t == 1) {
707 ps.onNext(2);
708 ps.onComplete();
709 }
710 }
711 };
712
713 ps.window(1, 2, TimeUnit.MILLISECONDS, scheduler)
714 .flatMap(new Function<Flowable<Integer>, Flowable<Integer>>() {
715 @Override
716 public Flowable<Integer> apply(Flowable<Integer> v) throws Exception {
717 return v;
718 }
719 })
720 .subscribe(ts);
721
722 ps.onNext(1);
723
724 ts
725 .awaitDone(1, TimeUnit.SECONDS)
726 .assertResult(1, 2);
727 }
728
729 @Test
730 public void sizeTimeTimeout() {
731 TestScheduler scheduler = new TestScheduler();
732 PublishProcessor<Integer> pp = PublishProcessor.<Integer>create();
733
734 TestSubscriber<Flowable<Integer>> ts = pp.window(5, TimeUnit.MILLISECONDS, scheduler, 100)
735 .test()
736 .assertValueCount(1);
737
738 scheduler.advanceTimeBy(5, TimeUnit.MILLISECONDS);
739
740 ts.assertValueCount(2)
741 .assertNoErrors()
742 .assertNotComplete();
743
744 ts.values().get(0).test().assertResult();
745 }
746
747 @Test
748 public void periodicWindowCompletion() {
749 TestScheduler scheduler = new TestScheduler();
750 FlowableProcessor<Integer> ps = PublishProcessor.<Integer>create();
751
752 TestSubscriber<Flowable<Integer>> ts = ps.window(5, TimeUnit.MILLISECONDS, scheduler, Long.MAX_VALUE, false)
753 .test();
754
755 scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
756
757 ts.assertValueCount(21)
758 .assertNoErrors()
759 .assertNotComplete();
760 }
761
762 @Test
763 public void periodicWindowCompletionRestartTimer() {
764 TestScheduler scheduler = new TestScheduler();
765 FlowableProcessor<Integer> ps = PublishProcessor.<Integer>create();
766
767 TestSubscriber<Flowable<Integer>> ts = ps.window(5, TimeUnit.MILLISECONDS, scheduler, Long.MAX_VALUE, true)
768 .test();
769
770 scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
771
772 ts.assertValueCount(21)
773 .assertNoErrors()
774 .assertNotComplete();
775 }
776
777 @Test
778 public void periodicWindowCompletionBounded() {
779 TestScheduler scheduler = new TestScheduler();
780 FlowableProcessor<Integer> ps = PublishProcessor.<Integer>create();
781
782 TestSubscriber<Flowable<Integer>> ts = ps.window(5, TimeUnit.MILLISECONDS, scheduler, 5, false)
783 .test();
784
785 scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
786
787 ts.assertValueCount(21)
788 .assertNoErrors()
789 .assertNotComplete();
790 }
791
792 @Test
793 public void periodicWindowCompletionRestartTimerBounded() {
794 TestScheduler scheduler = new TestScheduler();
795 FlowableProcessor<Integer> ps = PublishProcessor.<Integer>create();
796
797 TestSubscriber<Flowable<Integer>> ts = ps.window(5, TimeUnit.MILLISECONDS, scheduler, 5, true)
798 .test();
799
800 scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
801
802 ts.assertValueCount(21)
803 .assertNoErrors()
804 .assertNotComplete();
805 }
806
807 @Test
808 public void periodicWindowCompletionRestartTimerBoundedSomeData() {
809 TestScheduler scheduler = new TestScheduler();
810 FlowableProcessor<Integer> ps = PublishProcessor.<Integer>create();
811
812 TestSubscriber<Flowable<Integer>> ts = ps.window(5, TimeUnit.MILLISECONDS, scheduler, 2, true)
813 .test();
814
815 ps.onNext(1);
816 ps.onNext(2);
817
818 scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
819
820 ts.assertValueCount(22)
821 .assertNoErrors()
822 .assertNotComplete();
823 }
824
825 @Test
826 public void countRestartsOnTimeTick() {
827 TestScheduler scheduler = new TestScheduler();
828 FlowableProcessor<Integer> ps = PublishProcessor.<Integer>create();
829
830 TestSubscriber<Flowable<Integer>> ts = ps.window(5, TimeUnit.MILLISECONDS, scheduler, 5, true)
831 .doOnNext(new Consumer<Flowable<Integer>>() {
832 @Override
833 public void accept(Flowable<Integer> w) throws Throwable {
834 w.subscribe();
835 }
836 }) // avoid abandonment
837 .test();
838
839 // window #1
840 ps.onNext(1);
841 ps.onNext(2);
842
843 scheduler.advanceTimeBy(5, TimeUnit.MILLISECONDS);
844
845 // window #2
846 ps.onNext(3);
847 ps.onNext(4);
848 ps.onNext(5);
849 ps.onNext(6);
850
851 ts.assertValueCount(2)
852 .assertNoErrors()
853 .assertNotComplete();
854 }
855
856 @Test
857 public void doubleOnSubscribe() {
858 TestHelper.checkDoubleOnSubscribeFlowable(new Function<Flowable<Object>, Publisher<Flowable<Object>>>() {
859 @Override
860 public Publisher<Flowable<Object>> apply(Flowable<Object> f)
861 throws Exception {
862 return f.window(1, TimeUnit.SECONDS, 1).takeLast(0);
863 }
864 });
865 }
866
867 @Test
868 public void firstWindowMissingBackpressure() {
869 Flowable.never()
870 .window(1, TimeUnit.SECONDS, 1)
871 .test(0L)
872 .assertFailure(MissingBackpressureException.class);
873 }
874
875 @Test
876 public void nextWindowMissingBackpressure() {
877 PublishProcessor<Integer> pp = PublishProcessor.create();
878
879 TestSubscriber<Flowable<Integer>> ts = pp.window(1, TimeUnit.SECONDS, 1)
880 .test(1L);
881
882 pp.onNext(1);
883
884 ts.assertValueCount(1)
885 .assertError(MissingBackpressureException.class)
886 .assertNotComplete();
887 }
888
889 @Test
890 public void cancelUpfront() {
891 Flowable.never()
892 .window(1, TimeUnit.SECONDS, 1)
893 .test(0L, true)
894 .assertEmpty();
895 }
896
897 @Test
898 public void nextWindowMissingBackpressureDrainOnSize() {
899 final PublishProcessor<Integer> pp = PublishProcessor.create();
900
901 TestSubscriber<Flowable<Integer>> ts = pp.window(1, TimeUnit.MINUTES, 1)
902 .subscribeWith(new TestSubscriber<Flowable<Integer>>(2) {
903 int calls;
904 @Override
905 public void onNext(Flowable<Integer> t) {
906 super.onNext(t);
907 if (++calls == 2) {
908 pp.onNext(2);
909 }
910 }
911 });
912
913 pp.onNext(1);
914
915 ts.assertValueCount(2)
916 .assertError(MissingBackpressureException.class)
917 .assertNotComplete();
918 }
919
920 @Test
921 public void nextWindowMissingBackpressureDrainOnTime() {
922 final PublishProcessor<Integer> pp = PublishProcessor.create();
923
924 final TestScheduler sch = new TestScheduler();
925
926 TestSubscriber<Flowable<Integer>> ts = pp.window(1, TimeUnit.MILLISECONDS, sch, 10)
927 .test(1);
928
929 sch.advanceTimeBy(1, TimeUnit.MILLISECONDS);
930
931 ts.assertValueCount(1)
932 .assertError(MissingBackpressureException.class)
933 .assertNotComplete();
934 }
935
936 @Test
937 public void exactTimeBoundNoInterruptWindowOutputOnComplete() throws Exception {
938 final AtomicBoolean isInterrupted = new AtomicBoolean();
939
940 final PublishProcessor<Integer> pp = PublishProcessor.create();
941
942 final CountDownLatch doOnNextDone = new CountDownLatch(1);
943 final CountDownLatch secondWindowProcessing = new CountDownLatch(1);
944
945 pp.window(100, TimeUnit.MILLISECONDS)
946 .doOnNext(new Consumer<Flowable<Integer>>() {
947 int count;
948 @Override
949 public void accept(Flowable<Integer> v) throws Exception {
950 System.out.println(Thread.currentThread());
951 if (count++ == 1) {
952 secondWindowProcessing.countDown();
953 try {
954 Thread.sleep(200);
955 isInterrupted.set(Thread.interrupted());
956 } catch (InterruptedException ex) {
957 isInterrupted.set(true);
958 }
959 doOnNextDone.countDown();
960 }
961 }
962 })
963 .test();
964
965 pp.onNext(1);
966
967 assertTrue(secondWindowProcessing.await(5, TimeUnit.SECONDS));
968
969 pp.onComplete();
970
971 assertTrue(doOnNextDone.await(5, TimeUnit.SECONDS));
972
973 assertFalse("The doOnNext got interrupted!", isInterrupted.get());
974 }
975
976 @Test
977 @SuppressUndeliverable
978 public void exactTimeBoundNoInterruptWindowOutputOnError() throws Exception {
979 final AtomicBoolean isInterrupted = new AtomicBoolean();
980
981 final PublishProcessor<Integer> pp = PublishProcessor.create();
982
983 final CountDownLatch doOnNextDone = new CountDownLatch(1);
984 final CountDownLatch secondWindowProcessing = new CountDownLatch(1);
985
986 pp.window(100, TimeUnit.MILLISECONDS)
987 .doOnNext(new Consumer<Flowable<Integer>>() {
988 int count;
989 @Override
990 public void accept(Flowable<Integer> v) throws Exception {
991 System.out.println(Thread.currentThread());
992 if (count++ == 1) {
993 secondWindowProcessing.countDown();
994 try {
995 Thread.sleep(200);
996 isInterrupted.set(Thread.interrupted());
997 } catch (InterruptedException ex) {
998 isInterrupted.set(true);
999 }
1000 doOnNextDone.countDown();
1001 }
1002 }
1003 })
1004 .test();
1005
1006 pp.onNext(1);
1007
1008 assertTrue(secondWindowProcessing.await(5, TimeUnit.SECONDS));
1009
1010 pp.onError(new TestException());
1011
1012 assertTrue(doOnNextDone.await(5, TimeUnit.SECONDS));
1013
1014 assertFalse("The doOnNext got interrupted!", isInterrupted.get());
1015 }
1016
1017 @Test
1018 public void exactTimeAndSizeBoundNoInterruptWindowOutputOnComplete() throws Exception {
1019 final AtomicBoolean isInterrupted = new AtomicBoolean();
1020
1021 final PublishProcessor<Integer> pp = PublishProcessor.create();
1022
1023 final CountDownLatch doOnNextDone = new CountDownLatch(1);
1024 final CountDownLatch secondWindowProcessing = new CountDownLatch(1);
1025
1026 pp.window(100, TimeUnit.MILLISECONDS, 10)
1027 .doOnNext(new Consumer<Flowable<Integer>>() {
1028 int count;
1029 @Override
1030 public void accept(Flowable<Integer> v) throws Exception {
1031 System.out.println(Thread.currentThread());
1032 if (count++ == 1) {
1033 secondWindowProcessing.countDown();
1034 try {
1035 Thread.sleep(200);
1036 isInterrupted.set(Thread.interrupted());
1037 } catch (InterruptedException ex) {
1038 isInterrupted.set(true);
1039 }
1040 doOnNextDone.countDown();
1041 }
1042 }
1043 })
1044 .test();
1045
1046 pp.onNext(1);
1047
1048 assertTrue(secondWindowProcessing.await(5, TimeUnit.SECONDS));
1049
1050 pp.onComplete();
1051
1052 assertTrue(doOnNextDone.await(5, TimeUnit.SECONDS));
1053
1054 assertFalse("The doOnNext got interrupted!", isInterrupted.get());
1055 }
1056
1057 @Test
1058 @SuppressUndeliverable
1059 public void exactTimeAndSizeBoundNoInterruptWindowOutputOnError() throws Exception {
1060 final AtomicBoolean isInterrupted = new AtomicBoolean();
1061
1062 final PublishProcessor<Integer> pp = PublishProcessor.create();
1063
1064 final CountDownLatch doOnNextDone = new CountDownLatch(1);
1065 final CountDownLatch secondWindowProcessing = new CountDownLatch(1);
1066
1067 pp.window(100, TimeUnit.MILLISECONDS, 10)
1068 .doOnNext(new Consumer<Flowable<Integer>>() {
1069 int count;
1070 @Override
1071 public void accept(Flowable<Integer> v) throws Exception {
1072 System.out.println(Thread.currentThread());
1073 if (count++ == 1) {
1074 secondWindowProcessing.countDown();
1075 try {
1076 Thread.sleep(200);
1077 isInterrupted.set(Thread.interrupted());
1078 } catch (InterruptedException ex) {
1079 isInterrupted.set(true);
1080 }
1081 doOnNextDone.countDown();
1082 }
1083 }
1084 })
1085 .test();
1086
1087 pp.onNext(1);
1088
1089 assertTrue(secondWindowProcessing.await(5, TimeUnit.SECONDS));
1090
1091 pp.onError(new TestException());
1092
1093 assertTrue(doOnNextDone.await(5, TimeUnit.SECONDS));
1094
1095 assertFalse("The doOnNext got interrupted!", isInterrupted.get());
1096 }
1097
1098 @Test
1099 public void skipTimeAndSizeBoundNoInterruptWindowOutputOnComplete() throws Exception {
1100 final AtomicBoolean isInterrupted = new AtomicBoolean();
1101
1102 final PublishProcessor<Integer> pp = PublishProcessor.create();
1103
1104 final CountDownLatch doOnNextDone = new CountDownLatch(1);
1105 final CountDownLatch secondWindowProcessing = new CountDownLatch(1);
1106
1107 pp.window(90, 100, TimeUnit.MILLISECONDS)
1108 .doOnNext(new Consumer<Flowable<Integer>>() {
1109 int count;
1110 @Override
1111 public void accept(Flowable<Integer> v) throws Exception {
1112 System.out.println(Thread.currentThread());
1113 if (count++ == 1) {
1114 secondWindowProcessing.countDown();
1115 try {
1116 Thread.sleep(200);
1117 isInterrupted.set(Thread.interrupted());
1118 } catch (InterruptedException ex) {
1119 isInterrupted.set(true);
1120 }
1121 doOnNextDone.countDown();
1122 }
1123 }
1124 })
1125 .test();
1126
1127 pp.onNext(1);
1128
1129 assertTrue(secondWindowProcessing.await(5, TimeUnit.SECONDS));
1130
1131 pp.onComplete();
1132
1133 assertTrue(doOnNextDone.await(5, TimeUnit.SECONDS));
1134
1135 assertFalse("The doOnNext got interrupted!", isInterrupted.get());
1136 }
1137
1138 @Test
1139 @SuppressUndeliverable
1140 public void skipTimeAndSizeBoundNoInterruptWindowOutputOnError() throws Exception {
1141 final AtomicBoolean isInterrupted = new AtomicBoolean();
1142
1143 final PublishProcessor<Integer> pp = PublishProcessor.create();
1144
1145 final CountDownLatch doOnNextDone = new CountDownLatch(1);
1146 final CountDownLatch secondWindowProcessing = new CountDownLatch(1);
1147
1148 pp.window(90, 100, TimeUnit.MILLISECONDS)
1149 .doOnNext(new Consumer<Flowable<Integer>>() {
1150 int count;
1151 @Override
1152 public void accept(Flowable<Integer> v) throws Exception {
1153 System.out.println(Thread.currentThread());
1154 if (count++ == 1) {
1155 secondWindowProcessing.countDown();
1156 try {
1157 Thread.sleep(200);
1158 isInterrupted.set(Thread.interrupted());
1159 } catch (InterruptedException ex) {
1160 isInterrupted.set(true);
1161 }
1162 doOnNextDone.countDown();
1163 }
1164 }
1165 })
1166 .test();
1167
1168 pp.onNext(1);
1169
1170 assertTrue(secondWindowProcessing.await(5, TimeUnit.SECONDS));
1171
1172 pp.onError(new TestException());
1173
1174 assertTrue(doOnNextDone.await(5, TimeUnit.SECONDS));
1175
1176 assertFalse("The doOnNext got interrupted!", isInterrupted.get());
1177 }
1178
1179 @Test
1180 public void cancellingWindowCancelsUpstreamExactTime() {
1181 PublishProcessor<Integer> pp = PublishProcessor.create();
1182
1183 TestSubscriber<Integer> ts = pp.window(10, TimeUnit.MINUTES)
1184 .take(1)
1185 .flatMap(new Function<Flowable<Integer>, Publisher<Integer>>() {
1186 @Override
1187 public Publisher<Integer> apply(Flowable<Integer> w) throws Throwable {
1188 return w.take(1);
1189 }
1190 })
1191 .test();
1192
1193 assertTrue(pp.hasSubscribers());
1194
1195 pp.onNext(1);
1196
1197 ts
1198 .assertResult(1);
1199
1200 assertFalse("Processor still has subscribers!", pp.hasSubscribers());
1201 }
1202
1203 @Test
1204 public void windowAbandonmentCancelsUpstreamExactTime() {
1205 PublishProcessor<Integer> pp = PublishProcessor.create();
1206
1207 final AtomicReference<Flowable<Integer>> inner = new AtomicReference<>();
1208
1209 TestSubscriber<Flowable<Integer>> ts = pp.window(10, TimeUnit.MINUTES)
1210 .take(1)
1211 .doOnNext(new Consumer<Flowable<Integer>>() {
1212 @Override
1213 public void accept(Flowable<Integer> v) throws Throwable {
1214 inner.set(v);
1215 }
1216 })
1217 .test();
1218
1219 assertFalse("Processor still has subscribers!", pp.hasSubscribers());
1220
1221 ts
1222 .assertValueCount(1)
1223 .assertNoErrors()
1224 .assertComplete();
1225
1226 inner.get().test().assertResult();
1227 }
1228
1229 @Test
1230 public void cancellingWindowCancelsUpstreamExactTimeAndSize() {
1231 PublishProcessor<Integer> pp = PublishProcessor.create();
1232
1233 TestSubscriber<Integer> ts = pp.window(10, TimeUnit.MINUTES, 100)
1234 .take(1)
1235 .flatMap(new Function<Flowable<Integer>, Publisher<Integer>>() {
1236 @Override
1237 public Publisher<Integer> apply(Flowable<Integer> w) throws Throwable {
1238 return w.take(1);
1239 }
1240 })
1241 .test();
1242
1243 assertTrue(pp.hasSubscribers());
1244
1245 pp.onNext(1);
1246
1247 ts
1248 .assertResult(1);
1249
1250 assertFalse("Processor still has subscribers!", pp.hasSubscribers());
1251 }
1252
1253 @Test
1254 public void windowAbandonmentCancelsUpstreamExactTimeAndSize() {
1255 PublishProcessor<Integer> pp = PublishProcessor.create();
1256
1257 final AtomicReference<Flowable<Integer>> inner = new AtomicReference<>();
1258
1259 TestSubscriber<Flowable<Integer>> ts = pp.window(10, TimeUnit.MINUTES, 100)
1260 .take(1)
1261 .doOnNext(new Consumer<Flowable<Integer>>() {
1262 @Override
1263 public void accept(Flowable<Integer> v) throws Throwable {
1264 inner.set(v);
1265 }
1266 })
1267 .test();
1268
1269 assertFalse("Processor still has subscribers!", pp.hasSubscribers());
1270
1271 ts
1272 .assertValueCount(1)
1273 .assertNoErrors()
1274 .assertComplete();
1275
1276 inner.get().test().assertResult();
1277 }
1278
1279 @Test
1280 public void cancellingWindowCancelsUpstreamExactTimeSkip() {
1281 PublishProcessor<Integer> pp = PublishProcessor.create();
1282
1283 TestSubscriber<Integer> ts = pp.window(10, 15, TimeUnit.MINUTES)
1284 .take(1)
1285 .flatMap(new Function<Flowable<Integer>, Publisher<Integer>>() {
1286 @Override
1287 public Publisher<Integer> apply(Flowable<Integer> w) throws Throwable {
1288 return w.take(1);
1289 }
1290 })
1291 .test();
1292
1293 assertTrue(pp.hasSubscribers());
1294
1295 pp.onNext(1);
1296
1297 ts
1298 .assertResult(1);
1299
1300 assertFalse("Processor still has subscribers!", pp.hasSubscribers());
1301 }
1302
1303 @Test
1304 public void windowAbandonmentCancelsUpstreamExactTimeSkip() {
1305 PublishProcessor<Integer> pp = PublishProcessor.create();
1306
1307 final AtomicReference<Flowable<Integer>> inner = new AtomicReference<>();
1308
1309 TestSubscriber<Flowable<Integer>> ts = pp.window(10, 15, TimeUnit.MINUTES)
1310 .take(1)
1311 .doOnNext(new Consumer<Flowable<Integer>>() {
1312 @Override
1313 public void accept(Flowable<Integer> v) throws Throwable {
1314 inner.set(v);
1315 }
1316 })
1317 .test();
1318
1319 assertFalse("Processor still has subscribers!", pp.hasSubscribers());
1320
1321 ts
1322 .assertValueCount(1)
1323 .assertNoErrors()
1324 .assertComplete();
1325
1326 inner.get().test().assertResult();
1327 }
1328
1329 @Test
1330 public void badRequest() {
1331 TestHelper.assertBadRequestReported(Flowable.never().window(1, TimeUnit.SECONDS));
1332 }
1333
1334 @Test
1335 public void timedBoundarySignalAndDisposeRace() {
1336 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
1337 TestScheduler scheduler = new TestScheduler();
1338
1339 PublishProcessor<Integer> pp = PublishProcessor.create();
1340
1341 TestSubscriber<Flowable<Integer>> ts = pp.window(1, TimeUnit.MINUTES, scheduler, 1)
1342 .test();
1343
1344 TestHelper.race(
1345 () -> pp.onNext(1),
1346 () -> ts.cancel()
1347 );
1348 }
1349 }
1350 }
1351