Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/jdk8/ObservableMapOptionalTest.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.jdk8;
15
16 import static org.junit.Assert.assertFalse;
17
18 import java.util.Optional;
19
20 import org.junit.Test;
21
22 import io.reactivex.rxjava3.core.*;
23 import io.reactivex.rxjava3.disposables.Disposable;
24 import io.reactivex.rxjava3.exceptions.TestException;
25 import io.reactivex.rxjava3.functions.Function;
26 import io.reactivex.rxjava3.operators.QueueFuseable;
27 import io.reactivex.rxjava3.subjects.*;
28 import io.reactivex.rxjava3.testsupport.TestHelper;
29
30 public class ObservableMapOptionalTest extends RxJavaTest {
31
32 static final Function<? super Integer, Optional<? extends Integer>> MODULO = v -> v % 2 == 0 ? Optional.of(v) : Optional.<Integer>empty();
33
34 @Test
35 public void allPresent() {
36 Observable.range(1, 5)
37 .mapOptional(Optional::of)
38 .test()
39 .assertResult(1, 2, 3, 4, 5);
40 }
41
42 @Test
43 public void allEmpty() {
44 Observable.range(1, 5)
45 .mapOptional(v -> Optional.<Integer>empty())
46 .test()
47 .assertResult();
48 }
49
50 @Test
51 public void mixed() {
52 Observable.range(1, 10)
53 .mapOptional(MODULO)
54 .test()
55 .assertResult(2, 4, 6, 8, 10);
56 }
57
58 @Test
59 public void mapperChash() {
60 BehaviorSubject<Integer> source = BehaviorSubject.createDefault(1);
61
62 source
63 .mapOptional(v -> { throw new TestException(); })
64 .test()
65 .assertFailure(TestException.class);
66
67 assertFalse(source.hasObservers());
68 }
69
70 @Test
71 public void mapperNull() {
72 BehaviorSubject<Integer> source = BehaviorSubject.createDefault(1);
73
74 source
75 .mapOptional(v -> null)
76 .test()
77 .assertFailure(NullPointerException.class);
78
79 assertFalse(source.hasObservers());
80 }
81
82 @Test
83 public void crashDropsOnNexts() {
84 Observable<Integer> source = new Observable<Integer>() {
85 @Override
86 protected void subscribeActual(Observer<? super Integer> observer) {
87 observer.onSubscribe(Disposable.empty());
88 observer.onNext(1);
89 observer.onNext(2);
90 }
91 };
92
93 source
94 .mapOptional(v -> { throw new TestException(); })
95 .test()
96 .assertFailure(TestException.class);
97 }
98
99 @Test
100 public void syncFusedAll() {
101 Observable.range(1, 5)
102 .mapOptional(Optional::of)
103 .to(TestHelper.testConsumer(false, QueueFuseable.SYNC))
104 .assertFuseable()
105 .assertFusionMode(QueueFuseable.SYNC)
106 .assertResult(1, 2, 3, 4, 5);
107 }
108
109 @Test
110 public void asyncFusedAll() {
111 UnicastSubject<Integer> us = UnicastSubject.create();
112 TestHelper.emit(us, 1, 2, 3, 4, 5);
113
114 us
115 .mapOptional(Optional::of)
116 .to(TestHelper.testConsumer(false, QueueFuseable.ASYNC))
117 .assertFuseable()
118 .assertFusionMode(QueueFuseable.ASYNC)
119 .assertResult(1, 2, 3, 4, 5);
120 }
121
122 @Test
123 public void boundaryFusedAll() {
124 UnicastSubject<Integer> us = UnicastSubject.create();
125 TestHelper.emit(us, 1, 2, 3, 4, 5);
126
127 us
128 .mapOptional(Optional::of)
129 .to(TestHelper.testConsumer(false, QueueFuseable.ASYNC | QueueFuseable.BOUNDARY))
130 .assertFuseable()
131 .assertFusionMode(QueueFuseable.NONE)
132 .assertResult(1, 2, 3, 4, 5);
133 }
134
135 @Test
136 public void syncFusedNone() {
137 Observable.range(1, 5)
138 .mapOptional(v -> Optional.empty())
139 .to(TestHelper.testConsumer(false, QueueFuseable.SYNC))
140 .assertFuseable()
141 .assertFusionMode(QueueFuseable.SYNC)
142 .assertResult();
143 }
144
145 @Test
146 public void asyncFusedNone() {
147 UnicastSubject<Integer> us = UnicastSubject.create();
148 TestHelper.emit(us, 1, 2, 3, 4, 5);
149
150 us
151 .mapOptional(v -> Optional.empty())
152 .to(TestHelper.testConsumer(false, QueueFuseable.ASYNC))
153 .assertFuseable()
154 .assertFusionMode(QueueFuseable.ASYNC)
155 .assertResult();
156 }
157
158 @Test
159 public void boundaryFusedNone() {
160 UnicastSubject<Integer> us = UnicastSubject.create();
161 TestHelper.emit(us, 1, 2, 3, 4, 5);
162
163 us
164 .mapOptional(v -> Optional.empty())
165 .to(TestHelper.testConsumer(false, QueueFuseable.ASYNC | QueueFuseable.BOUNDARY))
166 .assertFuseable()
167 .assertFusionMode(QueueFuseable.NONE)
168 .assertResult();
169 }
170
171 @Test
172 public void syncFusedMixed() {
173 Observable.range(1, 10)
174 .mapOptional(MODULO)
175 .to(TestHelper.testConsumer(false, QueueFuseable.SYNC))
176 .assertFuseable()
177 .assertFusionMode(QueueFuseable.SYNC)
178 .assertResult(2, 4, 6, 8, 10);
179 }
180
181 @Test
182 public void asyncFusedMixed() {
183 UnicastSubject<Integer> us = UnicastSubject.create();
184 TestHelper.emit(us, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
185
186 us
187 .mapOptional(MODULO)
188 .to(TestHelper.testConsumer(false, QueueFuseable.ASYNC))
189 .assertFuseable()
190 .assertFusionMode(QueueFuseable.ASYNC)
191 .assertResult(2, 4, 6, 8, 10);
192 }
193
194 @Test
195 public void boundaryFusedMixed() {
196 UnicastSubject<Integer> us = UnicastSubject.create();
197 TestHelper.emit(us, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
198
199 us
200 .mapOptional(MODULO)
201 .to(TestHelper.testConsumer(false, QueueFuseable.ASYNC | QueueFuseable.BOUNDARY))
202 .assertFuseable()
203 .assertFusionMode(QueueFuseable.NONE)
204 .assertResult(2, 4, 6, 8, 10);
205 }
206
207 @Test
208 public void allPresentConditional() {
209 Observable.range(1, 5)
210 .mapOptional(Optional::of)
211 .filter(v -> true)
212 .test()
213 .assertResult(1, 2, 3, 4, 5);
214 }
215
216 @Test
217 public void allEmptyConditional() {
218 Observable.range(1, 5)
219 .mapOptional(v -> Optional.<Integer>empty())
220 .filter(v -> true)
221 .test()
222 .assertResult();
223 }
224
225 @Test
226 public void mixedConditional() {
227 Observable.range(1, 10)
228 .mapOptional(MODULO)
229 .filter(v -> true)
230 .test()
231 .assertResult(2, 4, 6, 8, 10);
232 }
233
234 @Test
235 public void mapperChashConditional() {
236 BehaviorSubject<Integer> source = BehaviorSubject.createDefault(1);
237
238 source
239 .mapOptional(v -> { throw new TestException(); })
240 .filter(v -> true)
241 .test()
242 .assertFailure(TestException.class);
243
244 assertFalse(source.hasObservers());
245 }
246
247 @Test
248 public void mapperNullConditional() {
249 BehaviorSubject<Integer> source = BehaviorSubject.createDefault(1);
250
251 source
252 .mapOptional(v -> null)
253 .filter(v -> true)
254 .test()
255 .assertFailure(NullPointerException.class);
256
257 assertFalse(source.hasObservers());
258 }
259
260 @Test
261 public void crashDropsOnNextsConditional() {
262 Observable<Integer> source = new Observable<Integer>() {
263 @Override
264 protected void subscribeActual(Observer<? super Integer> observer) {
265 observer.onSubscribe(Disposable.empty());
266 observer.onNext(1);
267 observer.onNext(2);
268 }
269 };
270
271 source
272 .mapOptional(v -> { throw new TestException(); })
273 .filter(v -> true)
274 .test()
275 .assertFailure(TestException.class);
276 }
277
278 @Test
279 public void syncFusedAllConditional() {
280 Observable.range(1, 5)
281 .mapOptional(Optional::of)
282 .filter(v -> true)
283 .to(TestHelper.testConsumer(false, QueueFuseable.SYNC))
284 .assertFuseable()
285 .assertFusionMode(QueueFuseable.SYNC)
286 .assertResult(1, 2, 3, 4, 5);
287 }
288
289 @Test
290 public void asyncFusedAllConditional() {
291 UnicastSubject<Integer> us = UnicastSubject.create();
292 TestHelper.emit(us, 1, 2, 3, 4, 5);
293
294 us
295 .mapOptional(Optional::of)
296 .filter(v -> true)
297 .to(TestHelper.testConsumer(false, QueueFuseable.ASYNC))
298 .assertFuseable()
299 .assertFusionMode(QueueFuseable.ASYNC)
300 .assertResult(1, 2, 3, 4, 5);
301 }
302
303 @Test
304 public void boundaryFusedAllConditiona() {
305 UnicastSubject<Integer> us = UnicastSubject.create();
306 TestHelper.emit(us, 1, 2, 3, 4, 5);
307
308 us
309 .mapOptional(Optional::of)
310 .filter(v -> true)
311 .to(TestHelper.testConsumer(false, QueueFuseable.ASYNC | QueueFuseable.BOUNDARY))
312 .assertFuseable()
313 .assertFusionMode(QueueFuseable.NONE)
314 .assertResult(1, 2, 3, 4, 5);
315 }
316
317 @Test
318 public void syncFusedNoneConditional() {
319 Observable.range(1, 5)
320 .mapOptional(v -> Optional.empty())
321 .filter(v -> true)
322 .to(TestHelper.testConsumer(false, QueueFuseable.SYNC))
323 .assertFuseable()
324 .assertFusionMode(QueueFuseable.SYNC)
325 .assertResult();
326 }
327
328 @Test
329 public void asyncFusedNoneConditional() {
330 UnicastSubject<Integer> us = UnicastSubject.create();
331 TestHelper.emit(us, 1, 2, 3, 4, 5);
332
333 us
334 .mapOptional(v -> Optional.empty())
335 .filter(v -> true)
336 .to(TestHelper.testConsumer(false, QueueFuseable.ASYNC))
337 .assertFuseable()
338 .assertFusionMode(QueueFuseable.ASYNC)
339 .assertResult();
340 }
341
342 @Test
343 public void boundaryFusedNoneConditional() {
344 UnicastSubject<Integer> us = UnicastSubject.create();
345 TestHelper.emit(us, 1, 2, 3, 4, 5);
346
347 us
348 .mapOptional(v -> Optional.empty())
349 .filter(v -> true)
350 .to(TestHelper.testConsumer(false, QueueFuseable.ASYNC | QueueFuseable.BOUNDARY))
351 .assertFuseable()
352 .assertFusionMode(QueueFuseable.NONE)
353 .assertResult();
354 }
355
356 @Test
357 public void syncFusedMixedConditional() {
358 Observable.range(1, 10)
359 .mapOptional(MODULO)
360 .filter(v -> true)
361 .to(TestHelper.testConsumer(false, QueueFuseable.SYNC))
362 .assertFuseable()
363 .assertFusionMode(QueueFuseable.SYNC)
364 .assertResult(2, 4, 6, 8, 10);
365 }
366
367 @Test
368 public void asyncFusedMixedConditional() {
369 UnicastSubject<Integer> us = UnicastSubject.create();
370 TestHelper.emit(us, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
371
372 us
373 .mapOptional(MODULO)
374 .filter(v -> true)
375 .to(TestHelper.testConsumer(false, QueueFuseable.ASYNC))
376 .assertFuseable()
377 .assertFusionMode(QueueFuseable.ASYNC)
378 .assertResult(2, 4, 6, 8, 10);
379 }
380
381 @Test
382 public void boundaryFusedMixedConditional() {
383 UnicastSubject<Integer> us = UnicastSubject.create();
384 TestHelper.emit(us, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
385
386 us
387 .mapOptional(MODULO)
388 .filter(v -> true)
389 .to(TestHelper.testConsumer(false, QueueFuseable.ASYNC | QueueFuseable.BOUNDARY))
390 .assertFuseable()
391 .assertFusionMode(QueueFuseable.NONE)
392 .assertResult(2, 4, 6, 8, 10);
393 }
394 }