Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableObserveOnTest.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.*;
18 import static org.mockito.Mockito.*;
19
20 import java.util.*;
21 import java.util.concurrent.*;
22 import java.util.concurrent.atomic.*;
23
24 import org.junit.Test;
25 import org.mockito.InOrder;
26
27 import io.reactivex.rxjava3.annotations.Nullable;
28 import io.reactivex.rxjava3.core.*;
29 import io.reactivex.rxjava3.core.Observable;
30 import io.reactivex.rxjava3.core.Observer;
31 import io.reactivex.rxjava3.disposables.*;
32 import io.reactivex.rxjava3.exceptions.*;
33 import io.reactivex.rxjava3.functions.*;
34 import io.reactivex.rxjava3.internal.operators.flowable.FlowableObserveOnTest.DisposeTrackingScheduler;
35 import io.reactivex.rxjava3.internal.operators.observable.ObservableObserveOn.ObserveOnObserver;
36 import io.reactivex.rxjava3.internal.schedulers.ImmediateThinScheduler;
37 import io.reactivex.rxjava3.observers.*;
38 import io.reactivex.rxjava3.operators.QueueDisposable;
39 import io.reactivex.rxjava3.operators.QueueFuseable;
40 import io.reactivex.rxjava3.operators.SimpleQueue;
41 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
42 import io.reactivex.rxjava3.schedulers.*;
43 import io.reactivex.rxjava3.subjects.*;
44 import io.reactivex.rxjava3.testsupport.*;
45
46 public class ObservableObserveOnTest extends RxJavaTest {
47
48 /**
49 * This is testing a no-op path since it uses Schedulers.immediate() which will not do scheduling.
50 */
51 @Test
52 public void observeOn() {
53 Observer<Integer> observer = TestHelper.mockObserver();
54 Observable.just(1, 2, 3).observeOn(ImmediateThinScheduler.INSTANCE).subscribe(observer);
55
56 verify(observer, times(1)).onNext(1);
57 verify(observer, times(1)).onNext(2);
58 verify(observer, times(1)).onNext(3);
59 verify(observer, times(1)).onComplete();
60 }
61
62 @Test
63 public void ordering() throws InterruptedException {
64 // Observable<String> obs = Observable.just("one", null, "two", "three", "four");
65 // FIXME null values not allowed
66 Observable<String> obs = Observable.just("one", "null", "two", "three", "four");
67
68 Observer<String> observer = TestHelper.mockObserver();
69
70 InOrder inOrder = inOrder(observer);
71 TestObserverEx<String> to = new TestObserverEx<>(observer);
72
73 obs.observeOn(Schedulers.computation()).subscribe(to);
74
75 to.awaitDone(1000, TimeUnit.MILLISECONDS);
76 if (to.errors().size() > 0) {
77 for (Throwable t : to.errors()) {
78 t.printStackTrace();
79 }
80 fail("failed with exception");
81 }
82
83 inOrder.verify(observer, times(1)).onNext("one");
84 inOrder.verify(observer, times(1)).onNext("null");
85 inOrder.verify(observer, times(1)).onNext("two");
86 inOrder.verify(observer, times(1)).onNext("three");
87 inOrder.verify(observer, times(1)).onNext("four");
88 inOrder.verify(observer, times(1)).onComplete();
89 inOrder.verifyNoMoreInteractions();
90 }
91
92 @Test
93 public void threadName() throws InterruptedException {
94 System.out.println("Main Thread: " + Thread.currentThread().getName());
95 // FIXME null values not allowed
96 // Observable<String> obs = Observable.just("one", null, "two", "three", "four");
97 Observable<String> obs = Observable.just("one", "null", "two", "three", "four");
98
99 Observer<String> observer = TestHelper.mockObserver();
100 final String parentThreadName = Thread.currentThread().getName();
101
102 final CountDownLatch completedLatch = new CountDownLatch(1);
103
104 // assert subscribe is on main thread
105 obs = obs.doOnNext(new Consumer<String>() {
106
107 @Override
108 public void accept(String s) {
109 String threadName = Thread.currentThread().getName();
110 System.out.println("Source ThreadName: " + threadName + " Expected => " + parentThreadName);
111 assertEquals(parentThreadName, threadName);
112 }
113
114 });
115
116 // assert observe is on new thread
117 obs.observeOn(Schedulers.newThread()).doOnNext(new Consumer<String>() {
118
119 @Override
120 public void accept(String t1) {
121 String threadName = Thread.currentThread().getName();
122 boolean correctThreadName = threadName.startsWith("RxNewThreadScheduler");
123 System.out.println("ObserveOn ThreadName: " + threadName + " Correct => " + correctThreadName);
124 assertTrue(correctThreadName);
125 }
126
127 }).doAfterTerminate(new Action() {
128
129 @Override
130 public void run() {
131 completedLatch.countDown();
132
133 }
134 }).subscribe(observer);
135
136 if (!completedLatch.await(1000, TimeUnit.MILLISECONDS)) {
137 fail("timed out waiting");
138 }
139
140 verify(observer, never()).onError(any(Throwable.class));
141 verify(observer, times(5)).onNext(any(String.class));
142 verify(observer, times(1)).onComplete();
143 }
144
145 @Test
146 public void observeOnTheSameSchedulerTwice() {
147 Scheduler scheduler = ImmediateThinScheduler.INSTANCE;
148
149 Observable<Integer> o = Observable.just(1, 2, 3);
150 Observable<Integer> o2 = o.observeOn(scheduler);
151
152 Observer<Object> observer1 = TestHelper.mockObserver();
153 Observer<Object> observer2 = TestHelper.mockObserver();
154
155 InOrder inOrder1 = inOrder(observer1);
156 InOrder inOrder2 = inOrder(observer2);
157
158 o2.subscribe(observer1);
159 o2.subscribe(observer2);
160
161 inOrder1.verify(observer1, times(1)).onNext(1);
162 inOrder1.verify(observer1, times(1)).onNext(2);
163 inOrder1.verify(observer1, times(1)).onNext(3);
164 inOrder1.verify(observer1, times(1)).onComplete();
165 verify(observer1, never()).onError(any(Throwable.class));
166 inOrder1.verifyNoMoreInteractions();
167
168 inOrder2.verify(observer2, times(1)).onNext(1);
169 inOrder2.verify(observer2, times(1)).onNext(2);
170 inOrder2.verify(observer2, times(1)).onNext(3);
171 inOrder2.verify(observer2, times(1)).onComplete();
172 verify(observer2, never()).onError(any(Throwable.class));
173 inOrder2.verifyNoMoreInteractions();
174 }
175
176 @Test
177 public void observeSameOnMultipleSchedulers() {
178 TestScheduler scheduler1 = new TestScheduler();
179 TestScheduler scheduler2 = new TestScheduler();
180
181 Observable<Integer> o = Observable.just(1, 2, 3);
182 Observable<Integer> o1 = o.observeOn(scheduler1);
183 Observable<Integer> o2 = o.observeOn(scheduler2);
184
185 Observer<Object> observer1 = TestHelper.mockObserver();
186 Observer<Object> observer2 = TestHelper.mockObserver();
187
188 InOrder inOrder1 = inOrder(observer1);
189 InOrder inOrder2 = inOrder(observer2);
190
191 o1.subscribe(observer1);
192 o2.subscribe(observer2);
193
194 scheduler1.advanceTimeBy(1, TimeUnit.SECONDS);
195 scheduler2.advanceTimeBy(1, TimeUnit.SECONDS);
196
197 inOrder1.verify(observer1, times(1)).onNext(1);
198 inOrder1.verify(observer1, times(1)).onNext(2);
199 inOrder1.verify(observer1, times(1)).onNext(3);
200 inOrder1.verify(observer1, times(1)).onComplete();
201 verify(observer1, never()).onError(any(Throwable.class));
202 inOrder1.verifyNoMoreInteractions();
203
204 inOrder2.verify(observer2, times(1)).onNext(1);
205 inOrder2.verify(observer2, times(1)).onNext(2);
206 inOrder2.verify(observer2, times(1)).onNext(3);
207 inOrder2.verify(observer2, times(1)).onComplete();
208 verify(observer2, never()).onError(any(Throwable.class));
209 inOrder2.verifyNoMoreInteractions();
210 }
211
212 /**
213 * Confirm that running on a NewThreadScheduler uses the same thread for the entire stream.
214 */
215 @Test
216 public void observeOnWithNewThreadScheduler() {
217 final AtomicInteger count = new AtomicInteger();
218 final int _multiple = 99;
219
220 Observable.range(1, 100000).map(new Function<Integer, Integer>() {
221
222 @Override
223 public Integer apply(Integer t1) {
224 return t1 * _multiple;
225 }
226
227 }).observeOn(Schedulers.newThread())
228 .blockingForEach(new Consumer<Integer>() {
229
230 @Override
231 public void accept(Integer t1) {
232 assertEquals(count.incrementAndGet() * _multiple, t1.intValue());
233 // FIXME toBlocking methods run on the current thread
234 String name = Thread.currentThread().getName();
235 assertFalse("Wrong thread name: " + name, name.startsWith("Rx"));
236 }
237
238 });
239
240 }
241
242 /**
243 * Confirm that running on a ThreadPoolScheduler allows multiple threads but is still ordered.
244 */
245 @Test
246 public void observeOnWithThreadPoolScheduler() {
247 final AtomicInteger count = new AtomicInteger();
248 final int _multiple = 99;
249
250 Observable.range(1, 100000).map(new Function<Integer, Integer>() {
251
252 @Override
253 public Integer apply(Integer t1) {
254 return t1 * _multiple;
255 }
256
257 }).observeOn(Schedulers.computation())
258 .blockingForEach(new Consumer<Integer>() {
259
260 @Override
261 public void accept(Integer t1) {
262 assertEquals(count.incrementAndGet() * _multiple, t1.intValue());
263 // FIXME toBlocking methods run on the caller's thread
264 String name = Thread.currentThread().getName();
265 assertFalse("Wrong thread name: " + name, name.startsWith("Rx"));
266 }
267
268 });
269 }
270
271 /**
272 * Attempts to confirm that when pauses exist between events, the ScheduledObserver
273 * does not lose or reorder any events since the scheduler will not block, but will
274 * be re-scheduled when it receives new events after each pause.
275 *
276 *
277 * This is non-deterministic in proving success, but if it ever fails (non-deterministically)
278 * it is a sign of potential issues as thread-races and scheduling should not affect output.
279 */
280 @Test
281 public void observeOnOrderingConcurrency() {
282 final AtomicInteger count = new AtomicInteger();
283 final int _multiple = 99;
284
285 Observable.range(1, 10000).map(new Function<Integer, Integer>() {
286
287 @Override
288 public Integer apply(Integer t1) {
289 if (randomIntFrom0to100() > 98) {
290 try {
291 Thread.sleep(2);
292 } catch (InterruptedException e) {
293 e.printStackTrace();
294 }
295 }
296 return t1 * _multiple;
297 }
298
299 }).observeOn(Schedulers.computation())
300 .blockingForEach(new Consumer<Integer>() {
301
302 @Override
303 public void accept(Integer t1) {
304 assertEquals(count.incrementAndGet() * _multiple, t1.intValue());
305 // assertTrue(name.startsWith("RxComputationThreadPool"));
306 // FIXME toBlocking now runs its methods on the caller thread
307 String name = Thread.currentThread().getName();
308 assertFalse("Wrong thread name: " + name, name.startsWith("Rx"));
309 }
310
311 });
312 }
313
314 @Test
315 public void nonBlockingOuterWhileBlockingOnNext() throws InterruptedException {
316
317 final CountDownLatch completedLatch = new CountDownLatch(1);
318 final CountDownLatch nextLatch = new CountDownLatch(1);
319 final AtomicLong completeTime = new AtomicLong();
320 // use subscribeOn to make async, observeOn to move
321 Observable.range(1, 2).subscribeOn(Schedulers.newThread()).observeOn(Schedulers.newThread()).subscribe(new DefaultObserver<Integer>() {
322
323 @Override
324 public void onComplete() {
325 System.out.println("onComplete");
326 completeTime.set(System.nanoTime());
327 completedLatch.countDown();
328 }
329
330 @Override
331 public void onError(Throwable e) {
332
333 }
334
335 @Override
336 public void onNext(Integer t) {
337 // don't let this thing finish yet
338 try {
339 if (!nextLatch.await(1000, TimeUnit.MILLISECONDS)) {
340 throw new RuntimeException("it shouldn't have timed out");
341 }
342 } catch (InterruptedException e) {
343 throw new RuntimeException("it shouldn't have failed");
344 }
345 }
346
347 });
348
349 long afterSubscribeTime = System.nanoTime();
350 System.out.println("After subscribe: " + completedLatch.getCount());
351 assertEquals(1, completedLatch.getCount());
352 nextLatch.countDown();
353 completedLatch.await(1000, TimeUnit.MILLISECONDS);
354 assertTrue(completeTime.get() > afterSubscribeTime);
355 System.out.println("onComplete nanos after subscribe: " + (completeTime.get() - afterSubscribeTime));
356 }
357
358 private static int randomIntFrom0to100() {
359 // XORShift instead of Math.random http://javamex.com/tutorials/random_numbers/xorshift.shtml
360 long x = System.nanoTime();
361 x ^= (x << 21);
362 x ^= (x >>> 35);
363 x ^= (x << 4);
364 return Math.abs((int) x % 100);
365 }
366
367 @Test
368 public void delayedErrorDeliveryWhenSafeSubscriberUnsubscribes() {
369 TestScheduler testScheduler = new TestScheduler();
370
371 Observable<Integer> source = Observable.concat(Observable.<Integer> error(new TestException()), Observable.just(1));
372
373 Observer<Integer> o = TestHelper.mockObserver();
374 InOrder inOrder = inOrder(o);
375
376 source.observeOn(testScheduler).subscribe(o);
377
378 inOrder.verify(o, never()).onError(any(TestException.class));
379
380 testScheduler.advanceTimeBy(1, TimeUnit.SECONDS);
381
382 inOrder.verify(o).onError(any(TestException.class));
383 inOrder.verify(o, never()).onNext(anyInt());
384 inOrder.verify(o, never()).onComplete();
385 }
386
387 @Test
388 public void afterUnsubscribeCalledThenObserverOnNextNeverCalled() {
389 final TestScheduler testScheduler = new TestScheduler();
390
391 final Observer<Integer> observer = TestHelper.mockObserver();
392 TestObserver<Integer> to = new TestObserver<>(observer);
393
394 Observable.just(1, 2, 3)
395 .observeOn(testScheduler)
396 .subscribe(to);
397
398 to.dispose();
399 testScheduler.advanceTimeBy(1, TimeUnit.SECONDS);
400
401 final InOrder inOrder = inOrder(observer);
402
403 inOrder.verify(observer, never()).onNext(anyInt());
404 inOrder.verify(observer, never()).onError(any(Exception.class));
405 inOrder.verify(observer, never()).onComplete();
406 }
407
408 @Test
409 public void backpressureWithTakeBefore() {
410 final AtomicInteger generated = new AtomicInteger();
411 Observable<Integer> o = Observable.fromIterable(new Iterable<Integer>() {
412 @Override
413 public Iterator<Integer> iterator() {
414 return new Iterator<Integer>() {
415
416 @Override
417 public void remove() {
418 }
419
420 @Override
421 public Integer next() {
422 return generated.getAndIncrement();
423 }
424
425 @Override
426 public boolean hasNext() {
427 return true;
428 }
429 };
430 }
431 });
432
433 TestObserver<Integer> to = new TestObserver<>();
434 o
435 .take(7)
436 .observeOn(Schedulers.newThread())
437 .subscribe(to);
438
439 to.awaitDone(5, TimeUnit.SECONDS);
440 to.assertValues(0, 1, 2, 3, 4, 5, 6);
441 assertEquals(7, generated.get());
442 }
443
444 @Test
445 public void asyncChild() {
446 TestObserver<Integer> to = new TestObserver<>();
447 Observable.range(0, 100000).observeOn(Schedulers.newThread()).observeOn(Schedulers.newThread()).subscribe(to);
448 to.awaitDone(5, TimeUnit.SECONDS);
449 to.assertNoErrors();
450 }
451
452 @Test
453 public void delayError() {
454 Observable.range(1, 5).concatWith(Observable.<Integer>error(new TestException()))
455 .observeOn(Schedulers.computation(), true)
456 .doOnNext(new Consumer<Integer>() {
457 @Override
458 public void accept(Integer v) throws Exception {
459 if (v == 1) {
460 Thread.sleep(100);
461 }
462 }
463 })
464 .test()
465 .awaitDone(5, TimeUnit.SECONDS)
466 .assertFailure(TestException.class, 1, 2, 3, 4, 5);
467 }
468
469 @Test
470 public void trampolineScheduler() {
471 Observable.just(1)
472 .observeOn(Schedulers.trampoline())
473 .test()
474 .assertResult(1);
475 }
476
477 @Test
478 public void dispose() {
479 TestHelper.checkDisposed(PublishSubject.create().observeOn(new TestScheduler()));
480 }
481
482 @Test
483 public void doubleOnSubscribe() {
484 TestHelper.checkDoubleOnSubscribeObservable(new Function<Observable<Object>, ObservableSource<Object>>() {
485 @Override
486 public ObservableSource<Object> apply(Observable<Object> o) throws Exception {
487 return o.observeOn(new TestScheduler());
488 }
489 });
490 }
491
492 @Test
493 public void badSource() {
494 List<Throwable> errors = TestHelper.trackPluginErrors();
495 try {
496 TestScheduler scheduler = new TestScheduler();
497 TestObserver<Integer> to = new Observable<Integer>() {
498 @Override
499 protected void subscribeActual(Observer<? super Integer> observer) {
500 observer.onSubscribe(Disposable.empty());
501 observer.onComplete();
502 observer.onNext(1);
503 observer.onError(new TestException());
504 observer.onComplete();
505 }
506 }
507 .observeOn(scheduler)
508 .test();
509
510 scheduler.triggerActions();
511
512 to.assertResult();
513
514 TestHelper.assertUndeliverable(errors, 0, TestException.class);
515 } finally {
516 RxJavaPlugins.reset();
517 }
518 }
519
520 @Test
521 public void inputSyncFused() {
522 Observable.range(1, 5)
523 .observeOn(Schedulers.single())
524 .test()
525 .awaitDone(5, TimeUnit.SECONDS)
526 .assertResult(1, 2, 3, 4, 5);
527 }
528
529 @Test
530 public void inputAsyncFused() {
531 UnicastSubject<Integer> us = UnicastSubject.create();
532
533 TestObserver<Integer> to = us.observeOn(Schedulers.single()).test();
534
535 TestHelper.emit(us, 1, 2, 3, 4, 5);
536
537 to
538 .awaitDone(5, TimeUnit.SECONDS)
539 .assertResult(1, 2, 3, 4, 5);
540 }
541
542 @Test
543 public void inputAsyncFusedError() {
544 UnicastSubject<Integer> us = UnicastSubject.create();
545
546 TestObserver<Integer> to = us.observeOn(Schedulers.single()).test();
547
548 us.onError(new TestException());
549
550 to
551 .awaitDone(5, TimeUnit.SECONDS)
552 .assertFailure(TestException.class);
553 }
554
555 @Test
556 public void inputAsyncFusedErrorDelayed() {
557 UnicastSubject<Integer> us = UnicastSubject.create();
558
559 TestObserver<Integer> to = us.observeOn(Schedulers.single(), true).test();
560
561 us.onError(new TestException());
562
563 to
564 .awaitDone(5, TimeUnit.SECONDS)
565 .assertFailure(TestException.class);
566 }
567
568 @Test
569 public void outputFused() {
570 TestObserverEx<Integer> to = new TestObserverEx<>(QueueFuseable.ANY);
571
572 Observable.range(1, 5).hide()
573 .observeOn(Schedulers.single())
574 .subscribe(to);
575
576 to.assertFusionMode(QueueFuseable.ASYNC)
577 .awaitDone(5, TimeUnit.SECONDS)
578 .assertResult(1, 2, 3, 4, 5);
579 }
580
581 @Test
582 public void outputFusedReject() {
583 TestObserverEx<Integer> to = new TestObserverEx<>(QueueFuseable.SYNC);
584
585 Observable.range(1, 5).hide()
586 .observeOn(Schedulers.single())
587 .subscribe(to);
588
589 to.assertFusionMode(QueueFuseable.NONE)
590 .awaitDone(5, TimeUnit.SECONDS)
591 .assertResult(1, 2, 3, 4, 5);
592 }
593
594 @Test
595 public void inputOutputAsyncFusedError() {
596 TestObserverEx<Integer> to = new TestObserverEx<>(QueueFuseable.ANY);
597
598 UnicastSubject<Integer> us = UnicastSubject.create();
599
600 us.observeOn(Schedulers.single())
601 .subscribe(to);
602
603 us.onError(new TestException());
604
605 to
606 .awaitDone(5, TimeUnit.SECONDS)
607 .assertFailure(TestException.class);
608
609 to.assertFusionMode(QueueFuseable.ASYNC)
610 .awaitDone(5, TimeUnit.SECONDS)
611 .assertFailure(TestException.class);
612 }
613
614 @Test
615 public void inputOutputAsyncFusedErrorDelayed() {
616 TestObserverEx<Integer> to = new TestObserverEx<>(QueueFuseable.ANY);
617
618 UnicastSubject<Integer> us = UnicastSubject.create();
619
620 us.observeOn(Schedulers.single(), true)
621 .subscribe(to);
622
623 us.onError(new TestException());
624
625 to
626 .awaitDone(5, TimeUnit.SECONDS)
627 .assertFailure(TestException.class);
628
629 to.assertFusionMode(QueueFuseable.ASYNC)
630 .awaitDone(5, TimeUnit.SECONDS)
631 .assertFailure(TestException.class);
632 }
633
634 @Test
635 public void outputFusedCancelReentrant() throws Exception {
636 final UnicastSubject<Integer> us = UnicastSubject.create();
637
638 final CountDownLatch cdl = new CountDownLatch(1);
639
640 us.observeOn(Schedulers.single())
641 .subscribe(new Observer<Integer>() {
642 Disposable upstream;
643 int count;
644 @Override
645 public void onSubscribe(Disposable d) {
646 this.upstream = d;
647 ((QueueDisposable<?>)d).requestFusion(QueueFuseable.ANY);
648 }
649
650 @Override
651 public void onNext(Integer value) {
652 if (++count == 1) {
653 us.onNext(2);
654 upstream.dispose();
655 cdl.countDown();
656 }
657 }
658
659 @Override
660 public void onError(Throwable e) {
661
662 }
663
664 @Override
665 public void onComplete() {
666
667 }
668 });
669
670 us.onNext(1);
671
672 cdl.await();
673 }
674
675 @Test
676 public void nonFusedPollThrows() {
677 new Observable<Integer>() {
678 @Override
679 protected void subscribeActual(Observer<? super Integer> observer) {
680 observer.onSubscribe(Disposable.empty());
681
682 @SuppressWarnings("unchecked")
683 ObserveOnObserver<Integer> oo = (ObserveOnObserver<Integer>)observer;
684
685 oo.queue = new SimpleQueue<Integer>() {
686
687 @Override
688 public boolean offer(Integer value) {
689 return false;
690 }
691
692 @Override
693 public boolean offer(Integer v1, Integer v2) {
694 return false;
695 }
696
697 @Nullable
698 @Override
699 public Integer poll() throws Exception {
700 throw new TestException();
701 }
702
703 @Override
704 public boolean isEmpty() {
705 return false;
706 }
707
708 @Override
709 public void clear() {
710 }
711 };
712
713 oo.clear();
714
715 oo.schedule();
716 }
717 }
718 .observeOn(Schedulers.single())
719 .test()
720 .awaitDone(5, TimeUnit.SECONDS)
721 .assertFailure(TestException.class);
722 }
723
724 @Test
725 public void outputFusedOneSignal() {
726 final BehaviorSubject<Integer> bs = BehaviorSubject.createDefault(1);
727
728 bs.observeOn(ImmediateThinScheduler.INSTANCE)
729 .concatMap(new Function<Integer, ObservableSource<Integer>>() {
730 @Override
731 public ObservableSource<Integer> apply(Integer v)
732 throws Exception {
733 return Observable.just(v + 1);
734 }
735 })
736 .subscribeWith(new TestObserver<Integer>() {
737 @Override
738 public void onNext(Integer t) {
739 super.onNext(t);
740 if (t == 2) {
741 bs.onNext(2);
742 }
743 }
744 })
745 .assertValuesOnly(2, 3);
746 }
747
748 @Test
749 public void workerNotDisposedPrematurelyNormalInNormalOut() {
750 DisposeTrackingScheduler s = new DisposeTrackingScheduler();
751
752 Observable.concat(
753 Observable.just(1).hide().observeOn(s),
754 Observable.just(2)
755 )
756 .test()
757 .assertResult(1, 2);
758
759 assertEquals(1, s.disposedCount.get());
760 }
761
762 @Test
763 public void workerNotDisposedPrematurelySyncInNormalOut() {
764 DisposeTrackingScheduler s = new DisposeTrackingScheduler();
765
766 Observable.concat(
767 Observable.just(1).observeOn(s),
768 Observable.just(2)
769 )
770 .test()
771 .assertResult(1, 2);
772
773 assertEquals(1, s.disposedCount.get());
774 }
775
776 @Test
777 public void workerNotDisposedPrematurelyAsyncInNormalOut() {
778 DisposeTrackingScheduler s = new DisposeTrackingScheduler();
779
780 UnicastSubject<Integer> us = UnicastSubject.create();
781 us.onNext(1);
782 us.onComplete();
783
784 Observable.concat(
785 us.observeOn(s),
786 Observable.just(2)
787 )
788 .test()
789 .assertResult(1, 2);
790
791 assertEquals(1, s.disposedCount.get());
792 }
793
794 static final class TestObserverFusedCanceling
795 extends TestObserverEx<Integer> {
796
797 TestObserverFusedCanceling() {
798 super();
799 initialFusionMode = QueueFuseable.ANY;
800 }
801
802 @Override
803 public void onComplete() {
804 dispose();
805 super.onComplete();
806 }
807 }
808
809 @Test
810 public void workerNotDisposedPrematurelyNormalInAsyncOut() {
811 DisposeTrackingScheduler s = new DisposeTrackingScheduler();
812
813 TestObserverEx<Integer> to = new TestObserverFusedCanceling();
814
815 Observable.just(1).hide().observeOn(s).subscribe(to);
816
817 assertEquals(1, s.disposedCount.get());
818 }
819
820 @Test
821 public void fusedNoConcurrentCleanDueToCancel() {
822 for (int j = 0; j < TestHelper.RACE_LONG_LOOPS; j++) {
823 List<Throwable> errors = TestHelper.trackPluginErrors();
824 try {
825 final UnicastSubject<Integer> us = UnicastSubject.create();
826
827 TestObserver<Integer> to = us.hide()
828 .observeOn(Schedulers.io())
829 .observeOn(Schedulers.single())
830 .unsubscribeOn(Schedulers.computation())
831 .firstOrError()
832 .test();
833
834 for (int i = 0; us.hasObservers() && i < 10000; i++) {
835 us.onNext(i);
836 }
837
838 to
839 .awaitDone(5, TimeUnit.SECONDS)
840 ;
841
842 if (!errors.isEmpty()) {
843 throw new CompositeException(errors);
844 }
845
846 to.assertResult(0);
847 } finally {
848 RxJavaPlugins.reset();
849 }
850 }
851 }
852 }