Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableMergeWithMaybeTest.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.List;
20 import java.util.concurrent.atomic.AtomicReference;
21
22 import org.junit.Test;
23
24 import io.reactivex.rxjava3.core.*;
25 import io.reactivex.rxjava3.disposables.*;
26 import io.reactivex.rxjava3.exceptions.TestException;
27 import io.reactivex.rxjava3.functions.Function;
28 import io.reactivex.rxjava3.observers.TestObserver;
29 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
30 import io.reactivex.rxjava3.subjects.*;
31 import io.reactivex.rxjava3.testsupport.TestHelper;
32
33 public class ObservableMergeWithMaybeTest extends RxJavaTest {
34
35 @Test
36 public void normal() {
37 Observable.range(1, 5)
38 .mergeWith(Maybe.just(100))
39 .test()
40 .assertResult(1, 2, 3, 4, 5, 100);
41 }
42
43 @Test
44 public void emptyOther() {
45 Observable.range(1, 5)
46 .mergeWith(Maybe.<Integer>empty())
47 .test()
48 .assertResult(1, 2, 3, 4, 5);
49 }
50
51 @Test
52 public void normalLong() {
53 Observable.range(1, 512)
54 .mergeWith(Maybe.just(100))
55 .test()
56 .assertValueCount(513)
57 .assertComplete();
58 }
59
60 @Test
61 public void take() {
62 Observable.range(1, 5)
63 .mergeWith(Maybe.just(100))
64 .take(3)
65 .test()
66 .assertResult(1, 2, 3);
67 }
68
69 @Test
70 public void cancel() {
71 final PublishSubject<Integer> ps = PublishSubject.create();
72 final MaybeSubject<Integer> cs = MaybeSubject.create();
73
74 TestObserver<Integer> to = ps.mergeWith(cs).test();
75
76 assertTrue(ps.hasObservers());
77 assertTrue(cs.hasObservers());
78
79 to.dispose();
80
81 assertFalse(ps.hasObservers());
82 assertFalse(cs.hasObservers());
83 }
84
85 @Test
86 public void mainError() {
87 Observable.error(new TestException())
88 .mergeWith(Maybe.just(100))
89 .test()
90 .assertFailure(TestException.class);
91 }
92
93 @Test
94 public void otherError() {
95 Observable.never()
96 .mergeWith(Maybe.error(new TestException()))
97 .test()
98 .assertFailure(TestException.class);
99 }
100
101 @Test
102 public void completeRace() {
103 for (int i = 0; i < 10000; i++) {
104 final PublishSubject<Integer> ps = PublishSubject.create();
105 final MaybeSubject<Integer> cs = MaybeSubject.create();
106
107 TestObserver<Integer> to = ps.mergeWith(cs).test();
108
109 Runnable r1 = new Runnable() {
110 @Override
111 public void run() {
112 ps.onNext(1);
113 ps.onComplete();
114 }
115 };
116
117 Runnable r2 = new Runnable() {
118 @Override
119 public void run() {
120 cs.onSuccess(1);
121 }
122 };
123
124 TestHelper.race(r1, r2);
125
126 to.assertResult(1, 1);
127 }
128 }
129
130 @Test
131 public void onNextSlowPath() {
132 final PublishSubject<Integer> ps = PublishSubject.create();
133 final MaybeSubject<Integer> cs = MaybeSubject.create();
134
135 TestObserver<Integer> to = ps.mergeWith(cs).subscribeWith(new TestObserver<Integer>() {
136 @Override
137 public void onNext(Integer t) {
138 super.onNext(t);
139 if (t == 1) {
140 ps.onNext(2);
141 }
142 }
143 });
144
145 ps.onNext(1);
146 cs.onSuccess(3);
147
148 ps.onNext(4);
149 ps.onComplete();
150
151 to.assertResult(1, 2, 3, 4);
152 }
153
154 @Test
155 public void onSuccessSlowPath() {
156 final PublishSubject<Integer> ps = PublishSubject.create();
157 final MaybeSubject<Integer> cs = MaybeSubject.create();
158
159 TestObserver<Integer> to = ps.mergeWith(cs).subscribeWith(new TestObserver<Integer>() {
160 @Override
161 public void onNext(Integer t) {
162 super.onNext(t);
163 if (t == 1) {
164 cs.onSuccess(2);
165 }
166 }
167 });
168
169 ps.onNext(1);
170
171 ps.onNext(3);
172 ps.onComplete();
173
174 to.assertResult(1, 2, 3);
175 }
176
177 @Test
178 public void onErrorMainOverflow() {
179 List<Throwable> errors = TestHelper.trackPluginErrors();
180 try {
181 final AtomicReference<Observer<?>> observerRef = new AtomicReference<>();
182 TestObserver<Integer> to = new Observable<Integer>() {
183 @Override
184 protected void subscribeActual(Observer<? super Integer> observer) {
185 observer.onSubscribe(Disposable.empty());
186 observerRef.set(observer);
187 }
188 }
189 .mergeWith(Maybe.<Integer>error(new IOException()))
190 .test();
191
192 observerRef.get().onError(new TestException());
193
194 to.assertFailure(IOException.class)
195 ;
196
197 TestHelper.assertUndeliverable(errors, 0, TestException.class);
198 } finally {
199 RxJavaPlugins.reset();
200 }
201 }
202
203 @Test
204 public void onErrorOtherOverflow() {
205 List<Throwable> errors = TestHelper.trackPluginErrors();
206 try {
207 Observable.error(new IOException())
208 .mergeWith(Maybe.error(new TestException()))
209 .test()
210 .assertFailure(IOException.class)
211 ;
212
213 TestHelper.assertUndeliverable(errors, 0, TestException.class);
214 } finally {
215 RxJavaPlugins.reset();
216 }
217 }
218
219 @Test
220 public void doubleOnSubscribeMain() {
221 TestHelper.checkDoubleOnSubscribeObservable(
222 new Function<Observable<Object>, Observable<Object>>() {
223 @Override
224 public Observable<Object> apply(Observable<Object> f)
225 throws Exception {
226 return f.mergeWith(Maybe.just(1));
227 }
228 }
229 );
230 }
231
232 @Test
233 public void isDisposed() {
234 new Observable<Integer>() {
235 @Override
236 protected void subscribeActual(Observer<? super Integer> observer) {
237 observer.onSubscribe(Disposable.empty());
238
239 assertFalse(((Disposable)observer).isDisposed());
240
241 observer.onNext(1);
242
243 assertTrue(((Disposable)observer).isDisposed());
244 }
245 }.mergeWith(Maybe.<Integer>empty())
246 .take(1)
247 .test()
248 .assertResult(1);
249 }
250
251 @Test
252 public void onNextSlowPathCreateQueue() {
253 final PublishSubject<Integer> ps = PublishSubject.create();
254 final MaybeSubject<Integer> cs = MaybeSubject.create();
255
256 TestObserver<Integer> to = ps.mergeWith(cs).subscribeWith(new TestObserver<Integer>() {
257 @Override
258 public void onNext(Integer t) {
259 super.onNext(t);
260 if (t == 1) {
261 ps.onNext(2);
262 ps.onNext(3);
263 }
264 }
265 });
266
267 cs.onSuccess(0);
268 ps.onNext(1);
269
270 ps.onNext(4);
271 ps.onComplete();
272
273 to.assertResult(0, 1, 2, 3, 4);
274 }
275
276 @Test
277 public void cancelOtherOnMainError() {
278 PublishSubject<Integer> ps = PublishSubject.create();
279 MaybeSubject<Integer> ms = MaybeSubject.create();
280
281 TestObserver<Integer> to = ps.mergeWith(ms).test();
282
283 assertTrue(ps.hasObservers());
284 assertTrue(ms.hasObservers());
285
286 ps.onError(new TestException());
287
288 to.assertFailure(TestException.class);
289
290 assertFalse("main has observers!", ps.hasObservers());
291 assertFalse("other has observers", ms.hasObservers());
292 }
293
294 @Test
295 public void cancelMainOnOtherError() {
296 PublishSubject<Integer> ps = PublishSubject.create();
297 MaybeSubject<Integer> ms = MaybeSubject.create();
298
299 TestObserver<Integer> to = ps.mergeWith(ms).test();
300
301 assertTrue(ps.hasObservers());
302 assertTrue(ms.hasObservers());
303
304 ms.onError(new TestException());
305
306 to.assertFailure(TestException.class);
307
308 assertFalse("main has observers!", ps.hasObservers());
309 assertFalse("other has observers", ms.hasObservers());
310 }
311
312 @Test
313 public void undeliverableUponCancel() {
314 TestHelper.checkUndeliverableUponCancel(new ObservableConverter<Integer, Observable<Integer>>() {
315 @Override
316 public Observable<Integer> apply(Observable<Integer> upstream) {
317 return upstream.mergeWith(Maybe.just(1).hide());
318 }
319 });
320 }
321 }