Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableAmbTest.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.Mockito.*;
18
19 import java.io.IOException;
20 import java.util.*;
21 import java.util.concurrent.*;
22 import java.util.concurrent.atomic.*;
23
24 import org.junit.*;
25 import org.mockito.InOrder;
26
27 import io.reactivex.rxjava3.core.*;
28 import io.reactivex.rxjava3.core.Observable;
29 import io.reactivex.rxjava3.core.Observer;
30 import io.reactivex.rxjava3.disposables.*;
31 import io.reactivex.rxjava3.exceptions.TestException;
32 import io.reactivex.rxjava3.functions.*;
33 import io.reactivex.rxjava3.internal.functions.Functions;
34 import io.reactivex.rxjava3.observers.TestObserver;
35 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
36 import io.reactivex.rxjava3.schedulers.*;
37 import io.reactivex.rxjava3.subjects.PublishSubject;
38 import io.reactivex.rxjava3.testsupport.*;
39
40 public class ObservableAmbTest extends RxJavaTest {
41
42 private TestScheduler scheduler;
43 private Scheduler.Worker innerScheduler;
44
45 @Before
46 public void setUp() {
47 scheduler = new TestScheduler();
48 innerScheduler = scheduler.createWorker();
49 }
50
51 private Observable<String> createObservable(final String[] values,
52 final long interval, final Throwable e) {
53 return Observable.unsafeCreate(new ObservableSource<String>() {
54
55 @Override
56 public void subscribe(final Observer<? super String> observer) {
57 CompositeDisposable parentSubscription = new CompositeDisposable();
58
59 observer.onSubscribe(parentSubscription);
60
61 long delay = interval;
62 for (final String value : values) {
63 parentSubscription.add(innerScheduler.schedule(new Runnable() {
64 @Override
65 public void run() {
66 observer.onNext(value);
67 }
68 }
69 , delay, TimeUnit.MILLISECONDS));
70 delay += interval;
71 }
72 parentSubscription.add(innerScheduler.schedule(new Runnable() {
73 @Override
74 public void run() {
75 if (e == null) {
76 observer.onComplete();
77 } else {
78 observer.onError(e);
79 }
80 }
81 }, delay, TimeUnit.MILLISECONDS));
82 }
83 });
84 }
85
86 @Test
87 public void amb() {
88 Observable<String> observable1 = createObservable(new String[] {
89 "1", "11", "111", "1111" }, 2000, null);
90 Observable<String> observable2 = createObservable(new String[] {
91 "2", "22", "222", "2222" }, 1000, null);
92 Observable<String> observable3 = createObservable(new String[] {
93 "3", "33", "333", "3333" }, 3000, null);
94
95 Observable<String> o = Observable.ambArray(observable1,
96 observable2, observable3);
97
98 Observer<String> observer = TestHelper.mockObserver();
99 o.subscribe(observer);
100
101 scheduler.advanceTimeBy(100000, TimeUnit.MILLISECONDS);
102
103 InOrder inOrder = inOrder(observer);
104 inOrder.verify(observer, times(1)).onNext("2");
105 inOrder.verify(observer, times(1)).onNext("22");
106 inOrder.verify(observer, times(1)).onNext("222");
107 inOrder.verify(observer, times(1)).onNext("2222");
108 inOrder.verify(observer, times(1)).onComplete();
109 inOrder.verifyNoMoreInteractions();
110 }
111
112 @Test
113 public void amb2() {
114 IOException expectedException = new IOException(
115 "fake exception");
116 Observable<String> observable1 = createObservable(new String[] {},
117 2000, new IOException("fake exception"));
118 Observable<String> observable2 = createObservable(new String[] {
119 "2", "22", "222", "2222" }, 1000, expectedException);
120 Observable<String> observable3 = createObservable(new String[] {},
121 3000, new IOException("fake exception"));
122
123 Observable<String> o = Observable.ambArray(observable1,
124 observable2, observable3);
125
126 Observer<String> observer = TestHelper.mockObserver();
127 o.subscribe(observer);
128
129 scheduler.advanceTimeBy(100000, TimeUnit.MILLISECONDS);
130
131 InOrder inOrder = inOrder(observer);
132 inOrder.verify(observer, times(1)).onNext("2");
133 inOrder.verify(observer, times(1)).onNext("22");
134 inOrder.verify(observer, times(1)).onNext("222");
135 inOrder.verify(observer, times(1)).onNext("2222");
136 inOrder.verify(observer, times(1)).onError(expectedException);
137 inOrder.verifyNoMoreInteractions();
138 }
139
140 @Test
141 public void amb3() {
142 Observable<String> observable1 = createObservable(new String[] {
143 "1" }, 2000, null);
144 Observable<String> observable2 = createObservable(new String[] {},
145 1000, null);
146 Observable<String> observable3 = createObservable(new String[] {
147 "3" }, 3000, null);
148
149 Observable<String> o = Observable.ambArray(observable1,
150 observable2, observable3);
151
152 Observer<String> observer = TestHelper.mockObserver();
153 o.subscribe(observer);
154
155 scheduler.advanceTimeBy(100000, TimeUnit.MILLISECONDS);
156 InOrder inOrder = inOrder(observer);
157 inOrder.verify(observer, times(1)).onComplete();
158 inOrder.verifyNoMoreInteractions();
159 }
160
161 @Test
162 public void subscriptionOnlyHappensOnce() throws InterruptedException {
163 final AtomicLong count = new AtomicLong();
164 Consumer<Disposable> incrementer = new Consumer<Disposable>() {
165 @Override
166 public void accept(Disposable d) {
167 count.incrementAndGet();
168 }
169 };
170
171 //this aync stream should emit first
172 Observable<Integer> o1 = Observable.just(1).doOnSubscribe(incrementer)
173 .delay(100, TimeUnit.MILLISECONDS).subscribeOn(Schedulers.computation());
174 //this stream emits second
175 Observable<Integer> o2 = Observable.just(1).doOnSubscribe(incrementer)
176 .delay(100, TimeUnit.MILLISECONDS).subscribeOn(Schedulers.computation());
177 TestObserver<Integer> to = new TestObserver<>();
178 Observable.ambArray(o1, o2).subscribe(to);
179 to.awaitDone(5, TimeUnit.SECONDS);
180 to.assertNoErrors();
181 assertEquals(2, count.get());
182 }
183
184 @Test
185 public void synchronousSources() {
186 // under async subscription the second Observable would complete before
187 // the first but because this is a synchronous subscription to sources
188 // then second Observable does not get subscribed to before first
189 // subscription completes hence first Observable emits result through
190 // amb
191 int result = Observable.just(1).doOnNext(new Consumer<Integer>() {
192 @Override
193 public void accept(Integer t) {
194 try {
195 Thread.sleep(100);
196 } catch (InterruptedException e) {
197 //
198 }
199 }
200 }).ambWith(Observable.just(2)).blockingSingle();
201 assertEquals(1, result);
202 }
203
204 @Test
205 public void ambCancelsOthers() {
206 PublishSubject<Integer> source1 = PublishSubject.create();
207 PublishSubject<Integer> source2 = PublishSubject.create();
208 PublishSubject<Integer> source3 = PublishSubject.create();
209
210 TestObserver<Integer> to = new TestObserver<>();
211
212 Observable.ambArray(source1, source2, source3).subscribe(to);
213
214 assertTrue("Source 1 doesn't have subscribers!", source1.hasObservers());
215 assertTrue("Source 2 doesn't have subscribers!", source2.hasObservers());
216 assertTrue("Source 3 doesn't have subscribers!", source3.hasObservers());
217
218 source1.onNext(1);
219
220 assertTrue("Source 1 doesn't have subscribers!", source1.hasObservers());
221 assertFalse("Source 2 still has subscribers!", source2.hasObservers());
222 assertFalse("Source 2 still has subscribers!", source3.hasObservers());
223
224 }
225
226 @Test
227 public void ambArrayEmpty() {
228 assertSame(Observable.empty(), Observable.ambArray());
229 }
230
231 @Test
232 public void ambArraySingleElement() {
233 assertSame(Observable.never(), Observable.ambArray(Observable.never()));
234 }
235
236 @Test
237 public void manySources() {
238 Observable<?>[] a = new Observable[32];
239 Arrays.fill(a, Observable.never());
240 a[31] = Observable.just(1);
241
242 Observable.amb(Arrays.asList(a))
243 .test()
244 .assertResult(1);
245 }
246
247 @Test
248 public void emptyIterable() {
249 Observable.amb(Collections.<Observable<Integer>>emptyList())
250 .test()
251 .assertResult();
252 }
253
254 @Test
255 public void singleIterable() {
256 Observable.amb(Collections.singletonList(Observable.just(1)))
257 .test()
258 .assertResult(1);
259 }
260
261 @Test
262 public void disposed() {
263 TestHelper.checkDisposed(Observable.ambArray(Observable.never(), Observable.never()));
264 }
265
266 @Test
267 public void onNextRace() {
268 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
269 final PublishSubject<Integer> ps1 = PublishSubject.create();
270 final PublishSubject<Integer> ps2 = PublishSubject.create();
271
272 TestObserverEx<Integer> to = Observable.ambArray(ps1, ps2).to(TestHelper.<Integer>testConsumer());
273
274 Runnable r1 = new Runnable() {
275 @Override
276 public void run() {
277 ps1.onNext(1);
278 }
279 };
280 Runnable r2 = new Runnable() {
281 @Override
282 public void run() {
283 ps2.onNext(1);
284 }
285 };
286
287 TestHelper.race(r1, r2);
288
289 to.assertSubscribed()
290 .assertNoErrors()
291 .assertNotComplete()
292 .assertValueCount(1);
293 }
294 }
295
296 @Test
297 public void onCompleteRace() {
298 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
299 final PublishSubject<Integer> ps1 = PublishSubject.create();
300 final PublishSubject<Integer> ps2 = PublishSubject.create();
301
302 TestObserver<Integer> to = Observable.ambArray(ps1, ps2).test();
303
304 Runnable r1 = new Runnable() {
305 @Override
306 public void run() {
307 ps1.onComplete();
308 }
309 };
310 Runnable r2 = new Runnable() {
311 @Override
312 public void run() {
313 ps2.onComplete();
314 }
315 };
316
317 TestHelper.race(r1, r2);
318
319 to.assertResult();
320 }
321 }
322
323 @Test
324 public void onErrorRace() {
325 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
326 final PublishSubject<Integer> ps1 = PublishSubject.create();
327 final PublishSubject<Integer> ps2 = PublishSubject.create();
328
329 TestObserver<Integer> to = Observable.ambArray(ps1, ps2).test();
330
331 final Throwable ex = new TestException();
332
333 Runnable r1 = new Runnable() {
334 @Override
335 public void run() {
336 ps1.onError(ex);
337 }
338 };
339 Runnable r2 = new Runnable() {
340 @Override
341 public void run() {
342 ps2.onError(ex);
343 }
344 };
345
346 List<Throwable> errors = TestHelper.trackPluginErrors();
347 try {
348 TestHelper.race(r1, r2);
349 } finally {
350 RxJavaPlugins.reset();
351 }
352
353 to.assertFailure(TestException.class);
354 if (!errors.isEmpty()) {
355 TestHelper.assertUndeliverable(errors, 0, TestException.class);
356 }
357 }
358 }
359
360 @Test
361 public void ambWithOrder() {
362 Observable<Integer> error = Observable.error(new RuntimeException());
363 Observable.just(1).ambWith(error).test().assertValue(1).assertComplete();
364 }
365
366 @Test
367 public void ambIterableOrder() {
368 Observable<Integer> error = Observable.error(new RuntimeException());
369 Observable.amb(Arrays.asList(Observable.just(1), error)).test().assertValue(1).assertComplete();
370 }
371
372 @Test
373 public void ambArrayOrder() {
374 Observable<Integer> error = Observable.error(new RuntimeException());
375 Observable.ambArray(Observable.just(1), error).test().assertValue(1).assertComplete();
376 }
377
378 @Test
379 public void noWinnerSuccessDispose() throws Exception {
380 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
381 final AtomicBoolean interrupted = new AtomicBoolean();
382 final CountDownLatch cdl = new CountDownLatch(1);
383
384 Observable.ambArray(
385 Observable.just(1)
386 .subscribeOn(Schedulers.single())
387 .observeOn(Schedulers.computation()),
388 Observable.never()
389 )
390 .subscribe(new Consumer<Object>() {
391 @Override
392 public void accept(Object v) throws Exception {
393 interrupted.set(Thread.currentThread().isInterrupted());
394 cdl.countDown();
395 }
396 });
397
398 assertTrue(cdl.await(500, TimeUnit.SECONDS));
399 assertFalse("Interrupted!", interrupted.get());
400 }
401 }
402
403 @Test
404 public void noWinnerErrorDispose() throws Exception {
405 final TestException ex = new TestException();
406 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
407 final AtomicBoolean interrupted = new AtomicBoolean();
408 final CountDownLatch cdl = new CountDownLatch(1);
409
410 Observable.ambArray(
411 Observable.error(ex)
412 .subscribeOn(Schedulers.single())
413 .observeOn(Schedulers.computation()),
414 Observable.never()
415 )
416 .subscribe(Functions.emptyConsumer(), new Consumer<Throwable>() {
417 @Override
418 public void accept(Throwable e) throws Exception {
419 interrupted.set(Thread.currentThread().isInterrupted());
420 cdl.countDown();
421 }
422 });
423
424 assertTrue(cdl.await(500, TimeUnit.SECONDS));
425 assertFalse("Interrupted!", interrupted.get());
426 }
427 }
428
429 @Test
430 public void noWinnerCompleteDispose() throws Exception {
431 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
432 final AtomicBoolean interrupted = new AtomicBoolean();
433 final CountDownLatch cdl = new CountDownLatch(1);
434
435 Observable.ambArray(
436 Observable.empty()
437 .subscribeOn(Schedulers.single())
438 .observeOn(Schedulers.computation()),
439 Observable.never()
440 )
441 .subscribe(Functions.emptyConsumer(), Functions.emptyConsumer(), new Action() {
442 @Override
443 public void run() throws Exception {
444 interrupted.set(Thread.currentThread().isInterrupted());
445 cdl.countDown();
446 }
447 });
448
449 assertTrue(cdl.await(500, TimeUnit.SECONDS));
450 assertFalse("Interrupted!", interrupted.get());
451 }
452 }
453
454 @Test
455 public void observableSourcesInIterable() {
456 ObservableSource<Integer> source = new ObservableSource<Integer>() {
457 @Override
458 public void subscribe(Observer<? super Integer> observer) {
459 Observable.just(1).subscribe(observer);
460 }
461 };
462
463 Observable.amb(Arrays.asList(source, source))
464 .test()
465 .assertResult(1);
466 }
467 }