Debian Codegraph @

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