Debian Codegraph @

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