Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/mixed/ObservableConcatMapSingleTest.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.mixed;
15
16 import static org.junit.Assert.*;
17
18 import java.util.List;
19 import java.util.concurrent.atomic.AtomicReference;
20
21 import io.reactivex.rxjava3.disposables.Disposable;
22 import org.junit.Test;
23
24 import io.reactivex.rxjava3.core.*;
25 import io.reactivex.rxjava3.exceptions.*;
26 import io.reactivex.rxjava3.functions.Function;
27 import io.reactivex.rxjava3.internal.functions.Functions;
28 import io.reactivex.rxjava3.internal.operators.mixed.ObservableConcatMapSingle.ConcatMapSingleMainObserver;
29 import io.reactivex.rxjava3.internal.util.ErrorMode;
30 import io.reactivex.rxjava3.observers.TestObserver;
31 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
32 import io.reactivex.rxjava3.subjects.*;
33 import io.reactivex.rxjava3.testsupport.*;
34
35 public class ObservableConcatMapSingleTest extends RxJavaTest {
36
37 @Test
38 public void simple() {
39 Observable.range(1, 5)
40 .concatMapSingle(new Function<Integer, SingleSource<Integer>>() {
41 @Override
42 public SingleSource<Integer> apply(Integer v)
43 throws Exception {
44 return Single.just(v);
45 }
46 })
47 .test()
48 .assertResult(1, 2, 3, 4, 5);
49 }
50
51 @Test
52 public void simpleLong() {
53 Observable.range(1, 1024)
54 .concatMapSingle(new Function<Integer, SingleSource<Integer>>() {
55 @Override
56 public SingleSource<Integer> apply(Integer v)
57 throws Exception {
58 return Single.just(v);
59 }
60 }, 32)
61 .test()
62 .assertValueCount(1024)
63 .assertNoErrors()
64 .assertComplete();
65 }
66
67 @Test
68 public void mainError() {
69 Observable.error(new TestException())
70 .concatMapSingle(Functions.justFunction(Single.just(1)))
71 .test()
72 .assertFailure(TestException.class);
73 }
74
75 @Test
76 public void innerError() {
77 Observable.just(1)
78 .concatMapSingle(Functions.justFunction(Single.error(new TestException())))
79 .test()
80 .assertFailure(TestException.class);
81 }
82
83 @Test
84 public void mainBoundaryErrorInnerSuccess() {
85 PublishSubject<Integer> ps = PublishSubject.create();
86 SingleSubject<Integer> ms = SingleSubject.create();
87
88 TestObserver<Integer> to = ps.concatMapSingleDelayError(Functions.justFunction(ms), false).test();
89
90 to.assertEmpty();
91
92 ps.onNext(1);
93
94 assertTrue(ms.hasObservers());
95
96 ps.onError(new TestException());
97
98 assertTrue(ms.hasObservers());
99
100 to.assertEmpty();
101
102 ms.onSuccess(1);
103
104 to.assertFailure(TestException.class, 1);
105 }
106
107 @Test
108 public void doubleOnSubscribe() {
109 TestHelper.checkDoubleOnSubscribeObservable(
110 new Function<Observable<Object>, Observable<Object>>() {
111 @Override
112 public Observable<Object> apply(Observable<Object> f)
113 throws Exception {
114 return f.concatMapSingleDelayError(
115 Functions.justFunction(Single.never()));
116 }
117 }
118 );
119 }
120
121 @Test
122 public void take() {
123 Observable.range(1, 5)
124 .concatMapSingle(new Function<Integer, SingleSource<Integer>>() {
125 @Override
126 public SingleSource<Integer> apply(Integer v)
127 throws Exception {
128 return Single.just(v);
129 }
130 })
131 .take(3)
132 .test()
133 .assertResult(1, 2, 3);
134 }
135
136 @Test
137 public void cancel() {
138 Observable.range(1, 5).concatWith(Observable.<Integer>never())
139 .concatMapSingle(new Function<Integer, SingleSource<Integer>>() {
140 @Override
141 public SingleSource<Integer> apply(Integer v)
142 throws Exception {
143 return Single.just(v);
144 }
145 })
146 .test()
147 .assertValues(1, 2, 3, 4, 5)
148 .assertNoErrors()
149 .assertNotComplete()
150 .dispose();
151 }
152
153 @Test
154 public void mainErrorAfterInnerError() {
155 List<Throwable> errors = TestHelper.trackPluginErrors();
156 try {
157 new Observable<Integer>() {
158 @Override
159 protected void subscribeActual(Observer<? super Integer> observer) {
160 observer.onSubscribe(Disposable.empty());
161 observer.onNext(1);
162 observer.onError(new TestException("outer"));
163 }
164 }
165 .concatMapSingle(
166 Functions.justFunction(Single.error(new TestException("inner"))), 1
167 )
168 .to(TestHelper.<Object>testConsumer())
169 .assertFailureAndMessage(TestException.class, "inner");
170
171 TestHelper.assertUndeliverable(errors, 0, TestException.class, "outer");
172 } finally {
173 RxJavaPlugins.reset();
174 }
175 }
176
177 @Test
178 public void innerErrorAfterMainError() {
179 List<Throwable> errors = TestHelper.trackPluginErrors();
180 try {
181 final PublishSubject<Integer> ps = PublishSubject.create();
182
183 final AtomicReference<SingleObserver<? super Integer>> obs = new AtomicReference<>();
184
185 TestObserverEx<Integer> to = ps.concatMapSingle(
186 new Function<Integer, SingleSource<Integer>>() {
187 @Override
188 public SingleSource<Integer> apply(Integer v)
189 throws Exception {
190 return new Single<Integer>() {
191 @Override
192 protected void subscribeActual(
193 SingleObserver<? super Integer> observer) {
194 observer.onSubscribe(Disposable.empty());
195 obs.set(observer);
196 }
197 };
198 }
199 }
200 ).to(TestHelper.<Integer>testConsumer());
201
202 ps.onNext(1);
203
204 ps.onError(new TestException("outer"));
205 obs.get().onError(new TestException("inner"));
206
207 to.assertFailureAndMessage(TestException.class, "outer");
208
209 TestHelper.assertUndeliverable(errors, 0, TestException.class, "inner");
210 } finally {
211 RxJavaPlugins.reset();
212 }
213 }
214
215 @Test
216 public void delayAllErrors() {
217 TestObserverEx<Object> to = Observable.range(1, 5)
218 .concatMapSingleDelayError(new Function<Integer, SingleSource<? extends Object>>() {
219 @Override
220 public SingleSource<? extends Object> apply(Integer v)
221 throws Exception {
222 return Single.error(new TestException());
223 }
224 })
225 .to(TestHelper.<Object>testConsumer())
226 .assertFailure(CompositeException.class)
227 ;
228
229 CompositeException ce = (CompositeException)to.errors().get(0);
230 assertEquals(5, ce.getExceptions().size());
231 }
232
233 @Test
234 public void mapperCrash() {
235 final PublishSubject<Integer> ps = PublishSubject.create();
236
237 TestObserver<Object> to = ps
238 .concatMapSingle(new Function<Integer, SingleSource<? extends Object>>() {
239 @Override
240 public SingleSource<? extends Object> apply(Integer v)
241 throws Exception {
242 throw new TestException();
243 }
244 })
245 .test();
246
247 to.assertEmpty();
248
249 assertTrue(ps.hasObservers());
250
251 ps.onNext(1);
252
253 to.assertFailure(TestException.class);
254
255 assertFalse(ps.hasObservers());
256 }
257
258 @Test
259 public void mapperCrashScalar() {
260 TestObserver<Object> to = Observable.just(1)
261 .concatMapSingle(new Function<Integer, SingleSource<? extends Object>>() {
262 @Override
263 public SingleSource<? extends Object> apply(Integer v)
264 throws Exception {
265 throw new TestException();
266 }
267 })
268 .test();
269
270 to.assertFailure(TestException.class);
271 }
272
273 @Test
274 public void disposed() {
275 TestHelper.checkDisposed(Observable.just(1).hide()
276 .concatMapSingle(Functions.justFunction(Single.never()))
277 );
278 }
279
280 @Test
281 public void mainCompletesWhileInnerActive() {
282 PublishSubject<Integer> ps = PublishSubject.create();
283 SingleSubject<Integer> ms = SingleSubject.create();
284
285 TestObserver<Integer> to = ps.concatMapSingleDelayError(Functions.justFunction(ms), false).test();
286
287 to.assertEmpty();
288
289 ps.onNext(1);
290 ps.onNext(2);
291 ps.onComplete();
292
293 assertTrue(ms.hasObservers());
294
295 to.assertEmpty();
296
297 ms.onSuccess(1);
298
299 to.assertResult(1, 1);
300 }
301
302 @Test
303 public void scalarEmptySource() {
304 SingleSubject<Integer> ss = SingleSubject.create();
305
306 Observable.empty()
307 .concatMapSingle(Functions.justFunction(ss))
308 .test()
309 .assertResult();
310
311 assertFalse(ss.hasObservers());
312 }
313
314 @Test
315 public void cancelNoConcurrentClean() {
316 TestObserver<Integer> to = new TestObserver<>();
317 ConcatMapSingleMainObserver<Integer, Integer> operator =
318 new ConcatMapSingleMainObserver<>(
319 to, Functions.justFunction(Single.<Integer>never()), 16, ErrorMode.IMMEDIATE);
320
321 operator.onSubscribe(Disposable.empty());
322
323 operator.queue.offer(1);
324
325 operator.getAndIncrement();
326
327 to.dispose();
328
329 assertFalse(operator.queue.isEmpty());
330
331 operator.addAndGet(-2);
332
333 operator.dispose();
334
335 assertTrue(operator.queue.isEmpty());
336 }
337
338 @Test
339 public void checkUnboundedInnerQueue() {
340 SingleSubject<Integer> ss = SingleSubject.create();
341
342 TestObserver<Integer> to = Observable
343 .fromArray(ss, Single.just(2), Single.just(3), Single.just(4))
344 .concatMapSingle(Functions.<Single<Integer>>identity(), 2)
345 .test();
346
347 to.assertEmpty();
348
349 ss.onSuccess(1);
350
351 to.assertResult(1, 2, 3, 4);
352 }
353
354 @Test
355 public void innerSuccessDisposeRace() {
356 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
357
358 final SingleSubject<Integer> ss = SingleSubject.create();
359
360 final TestObserver<Integer> to = Observable.just(1)
361 .hide()
362 .concatMapSingle(Functions.justFunction(ss))
363 .test();
364
365 Runnable r1 = new Runnable() {
366 @Override
367 public void run() {
368 ss.onSuccess(1);
369 }
370 };
371 Runnable r2 = new Runnable() {
372 @Override
373 public void run() {
374 to.dispose();
375 }
376 };
377
378 TestHelper.race(r1, r2);
379
380 to.assertNoErrors();
381 }
382 }
383
384 @Test
385 public void undeliverableUponCancel() {
386 TestHelper.checkUndeliverableUponCancel(new ObservableConverter<Integer, Observable<Integer>>() {
387 @Override
388 public Observable<Integer> apply(Observable<Integer> upstream) {
389 return upstream.concatMapSingle(new Function<Integer, Single<Integer>>() {
390 @Override
391 public Single<Integer> apply(Integer v) throws Throwable {
392 return Single.just(v).hide();
393 }
394 });
395 }
396 });
397 }
398
399 @Test
400 public void undeliverableUponCancelDelayError() {
401 TestHelper.checkUndeliverableUponCancel(new ObservableConverter<Integer, Observable<Integer>>() {
402 @Override
403 public Observable<Integer> apply(Observable<Integer> upstream) {
404 return upstream.concatMapSingleDelayError(new Function<Integer, Single<Integer>>() {
405 @Override
406 public Single<Integer> apply(Integer v) throws Throwable {
407 return Single.just(v).hide();
408 }
409 }, false, 2);
410 }
411 });
412 }
413
414 @Test
415 public void undeliverableUponCancelDelayErrorTillEnd() {
416 TestHelper.checkUndeliverableUponCancel(new ObservableConverter<Integer, Observable<Integer>>() {
417 @Override
418 public Observable<Integer> apply(Observable<Integer> upstream) {
419 return upstream.concatMapSingleDelayError(new Function<Integer, Single<Integer>>() {
420 @Override
421 public Single<Integer> apply(Integer v) throws Throwable {
422 return Single.just(v).hide();
423 }
424 }, true, 2);
425 }
426 });
427 }
428
429 @Test
430 public void basicNonFused() {
431 Observable.range(1, 5).hide()
432 .concatMapSingle(v -> Single.just(v).hide())
433 .test()
434 .assertResult(1, 2, 3, 4, 5);
435 }
436
437 @Test
438 public void basicSyncFused() {
439 Observable.range(1, 5)
440 .concatMapSingle(v -> Single.just(v).hide())
441 .test()
442 .assertResult(1, 2, 3, 4, 5);
443 }
444
445 @Test
446 public void basicAsyncFused() {
447 UnicastSubject<Integer> us = UnicastSubject.create();
448 TestHelper.emit(us, 1, 2, 3, 4, 5);
449
450 us
451 .concatMapSingle(v -> Single.just(v).hide())
452 .test()
453 .assertResult(1, 2, 3, 4, 5);
454 }
455
456 @Test
457 public void basicFusionRejected() {
458 TestHelper.<Integer>rejectObservableFusion()
459 .concatMapSingle(v -> Single.just(v).hide())
460 .test()
461 .assertEmpty();
462 }
463
464 @Test
465 public void fusedPollCrash() {
466 Observable.range(1, 5)
467 .map(v -> {
468 if (v == 3) {
469 throw new TestException();
470 }
471 return v;
472 })
473 .compose(TestHelper.observableStripBoundary())
474 .concatMapSingle(v -> Single.just(v).hide())
475 .test()
476 .assertFailure(TestException.class, 1, 2);
477 }
478 }