Debian Codegraph @

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