Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableWindowWithFlowableTest.java

raw
1 /*
2 * Copyright (c) 2016-present, RxJava Contributors.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
5 * compliance with the License. You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software distributed under the License is
10 * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
11 * the License for the specific language governing permissions and limitations under the License.
12 */
13
14 package io.reactivex.rxjava3.internal.operators.flowable;
15
16 import static org.junit.Assert.*;
17 import static org.mockito.ArgumentMatchers.any;
18 import static org.mockito.Mockito.*;
19
20 import java.util.*;
21 import java.util.concurrent.TimeUnit;
22 import java.util.concurrent.atomic.*;
23
24 import org.junit.Test;
25 import org.reactivestreams.*;
26
27 import io.reactivex.rxjava3.core.*;
28 import io.reactivex.rxjava3.exceptions.*;
29 import io.reactivex.rxjava3.functions.*;
30 import io.reactivex.rxjava3.internal.functions.Functions;
31 import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
32 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
33 import io.reactivex.rxjava3.processors.*;
34 import io.reactivex.rxjava3.subscribers.*;
35 import io.reactivex.rxjava3.testsupport.*;
36
37 public class FlowableWindowWithFlowableTest extends RxJavaTest {
38
39 @Test
40 public void windowViaFlowableNormal1() {
41 PublishProcessor<Integer> source = PublishProcessor.create();
42 PublishProcessor<Integer> boundary = PublishProcessor.create();
43
44 final Subscriber<Object> subscriber = TestHelper.mockSubscriber();
45
46 final List<Subscriber<Object>> values = new ArrayList<>();
47
48 Subscriber<Flowable<Integer>> wo = new DefaultSubscriber<Flowable<Integer>>() {
49 @Override
50 public void onNext(Flowable<Integer> args) {
51 final Subscriber<Object> mo = TestHelper.mockSubscriber();
52 values.add(mo);
53
54 args.subscribe(mo);
55 }
56
57 @Override
58 public void onError(Throwable e) {
59 subscriber.onError(e);
60 }
61
62 @Override
63 public void onComplete() {
64 subscriber.onComplete();
65 }
66 };
67
68 source.window(boundary).subscribe(wo);
69
70 int n = 30;
71 for (int i = 0; i < n; i++) {
72 source.onNext(i);
73 if (i % 3 == 2 && i < n - 1) {
74 boundary.onNext(i / 3);
75 }
76 }
77 source.onComplete();
78
79 verify(subscriber, never()).onError(any(Throwable.class));
80
81 assertEquals(n / 3, values.size());
82
83 int j = 0;
84 for (Subscriber<Object> mo : values) {
85 verify(mo, never()).onError(any(Throwable.class));
86 for (int i = 0; i < 3; i++) {
87 verify(mo).onNext(j + i);
88 }
89 verify(mo).onComplete();
90 j += 3;
91 }
92
93 verify(subscriber).onComplete();
94 }
95
96 @Test
97 public void windowViaFlowableBoundaryCompletes() {
98 PublishProcessor<Integer> source = PublishProcessor.create();
99 PublishProcessor<Integer> boundary = PublishProcessor.create();
100
101 final Subscriber<Object> subscriber = TestHelper.mockSubscriber();
102
103 final List<Subscriber<Object>> values = new ArrayList<>();
104
105 Subscriber<Flowable<Integer>> wo = new DefaultSubscriber<Flowable<Integer>>() {
106 @Override
107 public void onNext(Flowable<Integer> args) {
108 final Subscriber<Object> mo = TestHelper.mockSubscriber();
109 values.add(mo);
110
111 args.subscribe(mo);
112 }
113
114 @Override
115 public void onError(Throwable e) {
116 subscriber.onError(e);
117 }
118
119 @Override
120 public void onComplete() {
121 subscriber.onComplete();
122 }
123 };
124
125 source.window(boundary).subscribe(wo);
126
127 int n = 30;
128 for (int i = 0; i < n; i++) {
129 source.onNext(i);
130 if (i % 3 == 2 && i < n - 1) {
131 boundary.onNext(i / 3);
132 }
133 }
134 boundary.onComplete();
135
136 assertEquals(n / 3, values.size());
137
138 int j = 0;
139 for (Subscriber<Object> mo : values) {
140 for (int i = 0; i < 3; i++) {
141 verify(mo).onNext(j + i);
142 }
143 verify(mo).onComplete();
144 verify(mo, never()).onError(any(Throwable.class));
145 j += 3;
146 }
147
148 verify(subscriber).onComplete();
149 verify(subscriber, never()).onError(any(Throwable.class));
150 }
151
152 @Test
153 public void windowViaFlowableBoundaryThrows() {
154 PublishProcessor<Integer> source = PublishProcessor.create();
155 PublishProcessor<Integer> boundary = PublishProcessor.create();
156
157 final Subscriber<Object> subscriber = TestHelper.mockSubscriber();
158
159 final List<Subscriber<Object>> values = new ArrayList<>();
160
161 Subscriber<Flowable<Integer>> wo = new DefaultSubscriber<Flowable<Integer>>() {
162 @Override
163 public void onNext(Flowable<Integer> args) {
164 final Subscriber<Object> mo = TestHelper.mockSubscriber();
165 values.add(mo);
166
167 args.subscribe(mo);
168 }
169
170 @Override
171 public void onError(Throwable e) {
172 subscriber.onError(e);
173 }
174
175 @Override
176 public void onComplete() {
177 subscriber.onComplete();
178 }
179 };
180
181 source.window(boundary).subscribe(wo);
182
183 source.onNext(0);
184 source.onNext(1);
185 source.onNext(2);
186
187 boundary.onError(new TestException());
188
189 assertEquals(1, values.size());
190
191 Subscriber<Object> mo = values.get(0);
192
193 verify(mo).onNext(0);
194 verify(mo).onNext(1);
195 verify(mo).onNext(2);
196 verify(mo).onError(any(TestException.class));
197
198 verify(subscriber, never()).onComplete();
199 verify(subscriber).onError(any(TestException.class));
200 }
201
202 @Test
203 public void windowViaFlowableThrows() {
204 PublishProcessor<Integer> source = PublishProcessor.create();
205 PublishProcessor<Integer> boundary = PublishProcessor.create();
206
207 final Subscriber<Object> subscriber = TestHelper.mockSubscriber();
208
209 final List<Subscriber<Object>> values = new ArrayList<>();
210
211 Subscriber<Flowable<Integer>> wo = new DefaultSubscriber<Flowable<Integer>>() {
212 @Override
213 public void onNext(Flowable<Integer> args) {
214 final Subscriber<Object> mo = TestHelper.mockSubscriber();
215 values.add(mo);
216
217 args.subscribe(mo);
218 }
219
220 @Override
221 public void onError(Throwable e) {
222 subscriber.onError(e);
223 }
224
225 @Override
226 public void onComplete() {
227 subscriber.onComplete();
228 }
229 };
230
231 source.window(boundary).subscribe(wo);
232
233 source.onNext(0);
234 source.onNext(1);
235 source.onNext(2);
236
237 source.onError(new TestException());
238
239 assertEquals(1, values.size());
240
241 Subscriber<Object> mo = values.get(0);
242
243 verify(mo).onNext(0);
244 verify(mo).onNext(1);
245 verify(mo).onNext(2);
246 verify(mo).onError(any(TestException.class));
247
248 verify(subscriber, never()).onComplete();
249 verify(subscriber).onError(any(TestException.class));
250 }
251
252 @Test
253 public void boundaryDispose() {
254 TestHelper.checkDisposed(Flowable.never().window(Flowable.never()));
255 }
256
257 @Test
258 public void boundaryOnError() {
259 TestSubscriberEx<Object> ts = Flowable.error(new TestException())
260 .window(Flowable.never())
261 .flatMap(Functions.<Flowable<Object>>identity(), true)
262 .to(TestHelper.<Object>testConsumer())
263 .assertFailure(CompositeException.class);
264
265 List<Throwable> errors = TestHelper.compositeList(ts.errors().get(0));
266
267 TestHelper.assertError(errors, 0, TestException.class);
268 }
269
270 @Test
271 public void innerBadSource() {
272 TestHelper.checkBadSourceFlowable(new Function<Flowable<Integer>, Object>() {
273 @Override
274 public Object apply(Flowable<Integer> f) throws Exception {
275 return Flowable.just(1).window(f).flatMap(new Function<Flowable<Integer>, Flowable<Integer>>() {
276 @Override
277 public Flowable<Integer> apply(Flowable<Integer> v) throws Exception {
278 return v;
279 }
280 });
281 }
282 }, false, 1, 1, (Object[])null);
283 }
284
285 @Test
286 public void reentrant() {
287 final FlowableProcessor<Integer> ps = PublishProcessor.<Integer>create();
288
289 TestSubscriber<Integer> ts = new TestSubscriber<Integer>() {
290 @Override
291 public void onNext(Integer t) {
292 super.onNext(t);
293 if (t == 1) {
294 ps.onNext(2);
295 ps.onComplete();
296 }
297 }
298 };
299
300 ps.window(BehaviorProcessor.createDefault(1))
301 .flatMap(new Function<Flowable<Integer>, Flowable<Integer>>() {
302 @Override
303 public Flowable<Integer> apply(Flowable<Integer> v) throws Exception {
304 return v;
305 }
306 })
307 .subscribe(ts);
308
309 ps.onNext(1);
310
311 ts
312 .awaitDone(1, TimeUnit.SECONDS)
313 .assertResult(1, 2);
314 }
315
316 @Test
317 public void badSource() {
318 TestHelper.checkBadSourceFlowable(new Function<Flowable<Object>, Object>() {
319 @Override
320 public Object apply(Flowable<Object> f) throws Exception {
321 return f.window(Flowable.never()).flatMap(new Function<Flowable<Object>, Flowable<Object>>() {
322 @Override
323 public Flowable<Object> apply(Flowable<Object> v) throws Exception {
324 return v;
325 }
326 });
327 }
328 }, false, 1, 1, 1);
329 }
330
331 @Test
332 public void boundaryDirectMissingBackpressure() {
333 List<Throwable> errors = TestHelper.trackPluginErrors();
334 try {
335 BehaviorProcessor.create()
336 .window(Flowable.error(new TestException()))
337 .test(0)
338 .assertFailure(MissingBackpressureException.class);
339
340 TestHelper.assertUndeliverable(errors, 0, TestException.class);
341 } finally {
342 RxJavaPlugins.reset();
343 }
344 }
345
346 @Test
347 public void boundaryDirectMissingBackpressureNoNullPointerException() {
348 List<Throwable> errors = TestHelper.trackPluginErrors();
349 try {
350 BehaviorProcessor.createDefault(1)
351 .window(Flowable.error(new TestException()))
352 .test(0)
353 .assertFailure(MissingBackpressureException.class);
354
355 TestHelper.assertUndeliverable(errors, 0, TestException.class);
356 } finally {
357 RxJavaPlugins.reset();
358 }
359 }
360
361 @Test
362 public void boundaryDirectSecondMissingBackpressure() {
363 BehaviorProcessor.createDefault(1)
364 .window(Flowable.just(1))
365 .test(1)
366 .assertError(MissingBackpressureException.class)
367 .assertNotComplete();
368 }
369
370 @Test
371 public void boundaryDirectDoubleOnSubscribe() {
372 TestHelper.checkDoubleOnSubscribeFlowable(new Function<Flowable<Object>, Publisher<Flowable<Object>>>() {
373 @Override
374 public Publisher<Flowable<Object>> apply(Flowable<Object> f)
375 throws Exception {
376 return f.window(Flowable.never()).takeLast(1);
377 }
378 });
379 }
380
381 @Test
382 public void upstreamDisposedWhenOutputsDisposed() {
383 PublishProcessor<Integer> source = PublishProcessor.create();
384 PublishProcessor<Integer> boundary = PublishProcessor.create();
385
386 TestSubscriber<Integer> ts = source.window(boundary)
387 .take(1)
388 .flatMap(new Function<Flowable<Integer>, Flowable<Integer>>() {
389 @Override
390 public Flowable<Integer> apply(
391 Flowable<Integer> w) throws Exception {
392 return w.take(1);
393 }
394 })
395 .test();
396
397 source.onNext(1);
398
399 assertFalse("source not disposed", source.hasSubscribers());
400 assertFalse("boundary not disposed", boundary.hasSubscribers());
401
402 ts.assertResult(1);
403 }
404
405 @Test
406 public void mainAndBoundaryBothError() {
407 List<Throwable> errors = TestHelper.trackPluginErrors();
408 try {
409 final AtomicReference<Subscriber<? super Object>> ref = new AtomicReference<>();
410
411 TestSubscriberEx<Flowable<Object>> ts = Flowable.error(new TestException("main"))
412 .window(new Flowable<Object>() {
413 @Override
414 protected void subscribeActual(Subscriber<? super Object> subscriber) {
415 subscriber.onSubscribe(new BooleanSubscription());
416 ref.set(subscriber);
417 }
418 })
419 .doOnNext(new Consumer<Flowable<Object>>() {
420 @Override
421 public void accept(Flowable<Object> w) throws Throwable {
422 w.subscribe(Functions.emptyConsumer(), Functions.emptyConsumer()); // avoid abandonment
423 }
424 })
425 .to(TestHelper.<Flowable<Object>>testConsumer());
426
427 ts
428 .assertValueCount(1)
429 .assertError(TestException.class)
430 .assertErrorMessage("main")
431 .assertNotComplete();
432
433 ref.get().onError(new TestException("inner"));
434
435 TestHelper.assertUndeliverable(errors, 0, TestException.class, "inner");
436 } finally {
437 RxJavaPlugins.reset();
438 }
439 }
440
441 @Test
442 public void mainCompleteBoundaryErrorRace() {
443 final TestException ex = new TestException();
444
445 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
446 List<Throwable> errors = TestHelper.trackPluginErrors();
447 try {
448 final AtomicReference<Subscriber<? super Object>> refMain = new AtomicReference<>();
449 final AtomicReference<Subscriber<? super Object>> ref = new AtomicReference<>();
450
451 TestSubscriberEx<Flowable<Object>> ts = new Flowable<Object>() {
452 @Override
453 protected void subscribeActual(Subscriber<? super Object> subscriber) {
454 subscriber.onSubscribe(new BooleanSubscription());
455 refMain.set(subscriber);
456 }
457 }
458 .window(new Flowable<Object>() {
459 @Override
460 protected void subscribeActual(Subscriber<? super Object> subscriber) {
461 subscriber.onSubscribe(new BooleanSubscription());
462 ref.set(subscriber);
463 }
464 })
465 .to(TestHelper.<Flowable<Object>>testConsumer());
466
467 Runnable r1 = new Runnable() {
468 @Override
469 public void run() {
470 refMain.get().onComplete();
471 }
472 };
473 Runnable r2 = new Runnable() {
474 @Override
475 public void run() {
476 ref.get().onError(ex);
477 }
478 };
479
480 TestHelper.race(r1, r2);
481
482 ts
483 .assertValueCount(1)
484 .assertTerminated();
485
486 if (!errors.isEmpty()) {
487 TestHelper.assertUndeliverable(errors, 0, TestException.class);
488 }
489 } finally {
490 RxJavaPlugins.reset();
491 }
492 }
493 }
494
495 @Test
496 public void mainNextBoundaryNextRace() {
497 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
498 final AtomicReference<Subscriber<? super Object>> refMain = new AtomicReference<>();
499 final AtomicReference<Subscriber<? super Object>> ref = new AtomicReference<>();
500
501 TestSubscriber<Flowable<Object>> ts = new Flowable<Object>() {
502 @Override
503 protected void subscribeActual(Subscriber<? super Object> subscriber) {
504 subscriber.onSubscribe(new BooleanSubscription());
505 refMain.set(subscriber);
506 }
507 }
508 .window(new Flowable<Object>() {
509 @Override
510 protected void subscribeActual(Subscriber<? super Object> subscriber) {
511 subscriber.onSubscribe(new BooleanSubscription());
512 ref.set(subscriber);
513 }
514 })
515 .test();
516
517 Runnable r1 = new Runnable() {
518 @Override
519 public void run() {
520 refMain.get().onNext(1);
521 }
522 };
523 Runnable r2 = new Runnable() {
524 @Override
525 public void run() {
526 ref.get().onNext(1);
527 }
528 };
529
530 TestHelper.race(r1, r2);
531
532 ts
533 .assertValueCount(2)
534 .assertNotComplete()
535 .assertNoErrors();
536 }
537 }
538
539 @Test
540 public void takeOneAnotherBoundary() {
541 final AtomicReference<Subscriber<? super Object>> refMain = new AtomicReference<>();
542 final AtomicReference<Subscriber<? super Object>> ref = new AtomicReference<>();
543
544 TestSubscriberEx<Flowable<Object>> ts = new Flowable<Object>() {
545 @Override
546 protected void subscribeActual(Subscriber<? super Object> subscriber) {
547 subscriber.onSubscribe(new BooleanSubscription());
548 refMain.set(subscriber);
549 }
550 }
551 .window(new Flowable<Object>() {
552 @Override
553 protected void subscribeActual(Subscriber<? super Object> subscriber) {
554 subscriber.onSubscribe(new BooleanSubscription());
555 ref.set(subscriber);
556 }
557 })
558 .to(TestHelper.<Flowable<Object>>testConsumer());
559
560 ts.assertValueCount(1)
561 .assertNotTerminated()
562 .cancel();
563
564 ref.get().onNext(1);
565
566 ts.assertValueCount(1)
567 .assertNotTerminated();
568 }
569
570 @Test
571 public void disposeMainBoundaryCompleteRace() {
572 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
573 final AtomicReference<Subscriber<? super Object>> refMain = new AtomicReference<>();
574 final AtomicReference<Subscriber<? super Object>> ref = new AtomicReference<>();
575
576 final TestSubscriber<Flowable<Object>> ts = new Flowable<Object>() {
577 @Override
578 protected void subscribeActual(Subscriber<? super Object> subscriber) {
579 subscriber.onSubscribe(new BooleanSubscription());
580 refMain.set(subscriber);
581 }
582 }
583 .window(new Flowable<Object>() {
584 @Override
585 protected void subscribeActual(Subscriber<? super Object> subscriber) {
586 final AtomicInteger counter = new AtomicInteger();
587 subscriber.onSubscribe(new Subscription() {
588
589 @Override
590 public void cancel() {
591 // about a microsecond
592 for (int i = 0; i < 100; i++) {
593 counter.incrementAndGet();
594 }
595 }
596
597 @Override
598 public void request(long n) {
599 }
600 });
601 ref.set(subscriber);
602 }
603 })
604 .test();
605
606 Runnable r1 = new Runnable() {
607 @Override
608 public void run() {
609 ts.cancel();
610 }
611 };
612 Runnable r2 = new Runnable() {
613 @Override
614 public void run() {
615 Subscriber<Object> subscriber = ref.get();
616 subscriber.onNext(1);
617 subscriber.onComplete();
618 }
619 };
620
621 TestHelper.race(r1, r2);
622 }
623 }
624
625 @Test
626 @SuppressUndeliverable
627 public void disposeMainBoundaryErrorRace() {
628 final TestException ex = new TestException();
629
630 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
631 final AtomicReference<Subscriber<? super Object>> refMain = new AtomicReference<>();
632 final AtomicReference<Subscriber<? super Object>> ref = new AtomicReference<>();
633
634 final TestSubscriber<Flowable<Object>> ts = new Flowable<Object>() {
635 @Override
636 protected void subscribeActual(Subscriber<? super Object> subscriber) {
637 subscriber.onSubscribe(new BooleanSubscription());
638 refMain.set(subscriber);
639 }
640 }
641 .window(new Flowable<Object>() {
642 @Override
643 protected void subscribeActual(Subscriber<? super Object> subscriber) {
644 final AtomicInteger counter = new AtomicInteger();
645 subscriber.onSubscribe(new Subscription() {
646
647 @Override
648 public void cancel() {
649 // about a microsecond
650 for (int i = 0; i < 100; i++) {
651 counter.incrementAndGet();
652 }
653 }
654
655 @Override
656 public void request(long n) {
657 }
658 });
659 ref.set(subscriber);
660 }
661 })
662 .test();
663
664 Runnable r1 = new Runnable() {
665 @Override
666 public void run() {
667 ts.cancel();
668 }
669 };
670 Runnable r2 = new Runnable() {
671 @Override
672 public void run() {
673 Subscriber<Object> subscriber = ref.get();
674 subscriber.onNext(1);
675 subscriber.onError(ex);
676 }
677 };
678
679 TestHelper.race(r1, r2);
680 }
681 }
682
683 @Test
684 public void cancellingWindowCancelsUpstream() {
685 PublishProcessor<Integer> pp = PublishProcessor.create();
686
687 TestSubscriber<Integer> ts = pp.window(Flowable.just(1).concatWith(Flowable.<Integer>never()))
688 .take(1)
689 .flatMap(new Function<Flowable<Integer>, Publisher<Integer>>() {
690 @Override
691 public Publisher<Integer> apply(Flowable<Integer> w) throws Throwable {
692 return w.take(1);
693 }
694 })
695 .test();
696
697 assertTrue(pp.hasSubscribers());
698
699 pp.onNext(1);
700
701 ts
702 .assertResult(1);
703
704 assertFalse("Processor still has subscribers!", pp.hasSubscribers());
705 }
706
707 @Test
708 public void windowAbandonmentCancelsUpstream() {
709 PublishProcessor<Integer> pp = PublishProcessor.create();
710
711 final AtomicReference<Flowable<Integer>> inner = new AtomicReference<>();
712
713 TestSubscriber<Flowable<Integer>> ts = pp.window(Flowable.<Integer>never())
714 .doOnNext(new Consumer<Flowable<Integer>>() {
715 @Override
716 public void accept(Flowable<Integer> v) throws Throwable {
717 inner.set(v);
718 }
719 })
720 .test();
721
722 assertTrue(pp.hasSubscribers());
723
724 ts
725 .assertValueCount(1)
726 ;
727
728 pp.onNext(1);
729
730 assertTrue(pp.hasSubscribers());
731
732 ts.cancel();
733
734 ts
735 .assertValueCount(1)
736 .assertNoErrors()
737 .assertNotComplete();
738
739 assertFalse("Processor still has subscribers!", pp.hasSubscribers());
740
741 inner.get().test().assertResult();
742 }
743 }