Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/jdk8/MaybeFlattenStreamAsObservableTest.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.*;
17 import static org.mockito.ArgumentMatchers.any;
18 import static org.mockito.Mockito.*;
19
20 import java.util.Iterator;
21 import java.util.concurrent.atomic.AtomicReference;
22 import java.util.stream.Stream;
23
24 import org.junit.Test;
25
26 import io.reactivex.rxjava3.core.*;
27 import io.reactivex.rxjava3.disposables.Disposable;
28 import io.reactivex.rxjava3.exceptions.TestException;
29 import io.reactivex.rxjava3.functions.Function;
30 import io.reactivex.rxjava3.observers.TestObserver;
31 import io.reactivex.rxjava3.operators.QueueDisposable;
32 import io.reactivex.rxjava3.operators.QueueFuseable;
33 import io.reactivex.rxjava3.subjects.MaybeSubject;
34 import io.reactivex.rxjava3.testsupport.*;
35
36 public class MaybeFlattenStreamAsObservableTest extends RxJavaTest {
37
38 @Test
39 public void successJust() {
40 Maybe.just(1)
41 .flattenStreamAsObservable(Stream::of)
42 .test()
43 .assertResult(1);
44 }
45
46 @Test
47 public void successEmpty() {
48 Maybe.just(1)
49 .flattenStreamAsObservable(v -> Stream.of())
50 .test()
51 .assertResult();
52 }
53
54 @Test
55 public void successMany() {
56 Maybe.just(1)
57 .flattenStreamAsObservable(v -> Stream.of(2, 3, 4, 5, 6))
58 .test()
59 .assertResult(2, 3, 4, 5, 6);
60 }
61
62 @Test
63 public void successManyTake() {
64 Maybe.just(1)
65 .flattenStreamAsObservable(v -> Stream.of(2, 3, 4, 5, 6))
66 .take(3)
67 .test()
68 .assertResult(2, 3, 4);
69 }
70
71 @Test
72 public void empty() throws Throwable {
73 @SuppressWarnings("unchecked")
74 Function<? super Integer, Stream<? extends Integer>> f = mock(Function.class);
75
76 Maybe.<Integer>empty()
77 .flattenStreamAsObservable(f)
78 .test()
79 .assertResult();
80
81 verify(f, never()).apply(any());
82 }
83
84 @Test
85 public void error() throws Throwable {
86 @SuppressWarnings("unchecked")
87 Function<? super Integer, Stream<? extends Integer>> f = mock(Function.class);
88
89 Maybe.<Integer>error(new TestException())
90 .flattenStreamAsObservable(f)
91 .test()
92 .assertFailure(TestException.class);
93
94 verify(f, never()).apply(any());
95 }
96
97 @Test
98 public void mapperCrash() {
99 Maybe.just(1)
100 .flattenStreamAsObservable(v -> { throw new TestException(); })
101 .test()
102 .assertFailure(TestException.class);
103 }
104
105 @Test
106 public void dispose() {
107 TestHelper.checkDisposed(Maybe.never().flattenStreamAsObservable(Stream::of));
108 }
109
110 @Test
111 public void doubleOnSubscribe() {
112 TestHelper.checkDoubleOnSubscribeMaybeToObservable(m -> m.flattenStreamAsObservable(Stream::of));
113 }
114
115 @Test
116 public void fusedEmpty() {
117 TestObserverEx<Integer> to = new TestObserverEx<>();
118 to.setInitialFusionMode(QueueFuseable.ANY);
119
120 Maybe.just(1)
121 .flattenStreamAsObservable(v -> Stream.<Integer>of())
122 .subscribe(to);
123
124 to.assertFuseable()
125 .assertFusionMode(QueueFuseable.ASYNC)
126 .assertResult();
127 }
128
129 @Test
130 public void fusedJust() {
131 TestObserverEx<Integer> to = new TestObserverEx<>();
132 to.setInitialFusionMode(QueueFuseable.ANY);
133
134 Maybe.just(1)
135 .flattenStreamAsObservable(v -> Stream.<Integer>of(v))
136 .subscribe(to);
137
138 to.assertFuseable()
139 .assertFusionMode(QueueFuseable.ASYNC)
140 .assertResult(1);
141 }
142
143 @Test
144 public void fusedMany() {
145 TestObserverEx<Integer> to = new TestObserverEx<>();
146 to.setInitialFusionMode(QueueFuseable.ANY);
147
148 Maybe.just(1)
149 .flattenStreamAsObservable(v -> Stream.<Integer>of(v, v + 1, v + 2))
150 .subscribe(to);
151
152 to.assertFuseable()
153 .assertFusionMode(QueueFuseable.ASYNC)
154 .assertResult(1, 2, 3);
155 }
156
157 @Test
158 public void fusedManyRejected() {
159 TestObserverEx<Integer> to = new TestObserverEx<>();
160 to.setInitialFusionMode(QueueFuseable.SYNC);
161
162 Maybe.just(1)
163 .flattenStreamAsObservable(v -> Stream.<Integer>of(v, v + 1, v + 2))
164 .subscribe(to);
165
166 to.assertFuseable()
167 .assertFusionMode(QueueFuseable.NONE)
168 .assertResult(1, 2, 3);
169 }
170
171 @Test
172 public void fusedStreamAvailableLater() {
173 TestObserverEx<Integer> to = new TestObserverEx<>();
174 to.setInitialFusionMode(QueueFuseable.ANY);
175
176 MaybeSubject<Integer> ms = MaybeSubject.create();
177
178 ms
179 .flattenStreamAsObservable(v -> Stream.<Integer>of(v, v + 1, v + 2))
180 .subscribe(to);
181
182 to.assertFuseable()
183 .assertFusionMode(QueueFuseable.ASYNC)
184 .assertEmpty();
185
186 ms.onSuccess(1);
187
188 to
189 .assertResult(1, 2, 3);
190 }
191
192 @Test
193 public void fused() throws Throwable {
194 AtomicReference<QueueDisposable<Integer>> qdr = new AtomicReference<>();
195
196 MaybeSubject<Integer> ms = MaybeSubject.create();
197
198 ms
199 .flattenStreamAsObservable(Stream::of)
200 .subscribe(new Observer<Integer>() {
201
202 @Override
203 public void onNext(Integer t) {
204 }
205
206 @Override
207 public void onError(Throwable t) {
208 }
209
210 @Override
211 public void onComplete() {
212 }
213
214 @Override
215 @SuppressWarnings("unchecked")
216 public void onSubscribe(Disposable d) {
217 qdr.set((QueueDisposable<Integer>)d);
218 }
219 });
220
221 QueueDisposable<Integer> qd = qdr.get();
222
223 assertEquals(QueueFuseable.ASYNC, qd.requestFusion(QueueFuseable.ASYNC));
224
225 assertTrue(qd.isEmpty());
226 assertNull(qd.poll());
227
228 ms.onSuccess(1);
229
230 assertFalse(qd.isEmpty());
231 assertEquals(1, qd.poll().intValue());
232
233 assertTrue(qd.isEmpty());
234 assertNull(qd.poll());
235
236 qd.dispose();
237
238 assertTrue(qd.isEmpty());
239 assertNull(qd.poll());
240 }
241
242 @Test
243 public void fused2() throws Throwable {
244 AtomicReference<QueueDisposable<Integer>> qdr = new AtomicReference<>();
245
246 MaybeSubject<Integer> ms = MaybeSubject.create();
247
248 ms
249 .flattenStreamAsObservable(v -> Stream.of(v, v + 1))
250 .subscribe(new Observer<Integer>() {
251
252 @Override
253 public void onNext(Integer t) {
254 }
255
256 @Override
257 public void onError(Throwable t) {
258 }
259
260 @Override
261 public void onComplete() {
262 }
263
264 @Override
265 @SuppressWarnings("unchecked")
266 public void onSubscribe(Disposable d) {
267 qdr.set((QueueDisposable<Integer>)d);
268 }
269 });
270
271 QueueDisposable<Integer> qd = qdr.get();
272
273 assertEquals(QueueFuseable.ASYNC, qd.requestFusion(QueueFuseable.ASYNC));
274
275 assertTrue(qd.isEmpty());
276 assertNull(qd.poll());
277
278 ms.onSuccess(1);
279
280 assertFalse(qd.isEmpty());
281 assertEquals(1, qd.poll().intValue());
282
283 assertFalse(qd.isEmpty());
284 assertEquals(2, qd.poll().intValue());
285
286 assertTrue(qd.isEmpty());
287 assertNull(qd.poll());
288
289 qd.dispose();
290
291 assertTrue(qd.isEmpty());
292 assertNull(qd.poll());
293 }
294
295 @Test
296 public void streamCloseCrash() throws Throwable {
297 TestHelper.withErrorTracking(errors -> {
298 Maybe.just(1)
299 .flattenStreamAsObservable(v -> Stream.of(v).onClose(() -> { throw new TestException(); }))
300 .test()
301 .assertResult(1);
302
303 TestHelper.assertUndeliverable(errors, 0, TestException.class);
304 });
305 }
306
307 @Test
308 public void hasNextThrowsInDrain() {
309 @SuppressWarnings("unchecked")
310 Stream<Integer> stream = mock(Stream.class);
311 when(stream.iterator()).thenReturn(new Iterator<Integer>() {
312
313 int count;
314
315 @Override
316 public boolean hasNext() {
317 if (count++ > 0) {
318 throw new TestException();
319 }
320 return true;
321 }
322
323 @Override
324 public Integer next() {
325 return 1;
326 }
327 });
328
329 Maybe.just(1)
330 .flattenStreamAsObservable(v -> stream)
331 .test()
332 .assertFailure(TestException.class, 1);
333 }
334
335 @Test
336 public void nextThrowsInDrain() {
337 @SuppressWarnings("unchecked")
338 Stream<Integer> stream = mock(Stream.class);
339 when(stream.iterator()).thenReturn(new Iterator<Integer>() {
340
341 @Override
342 public boolean hasNext() {
343 return true;
344 }
345
346 @Override
347 public Integer next() {
348 throw new TestException();
349 }
350 });
351
352 Maybe.just(1)
353 .flattenStreamAsObservable(v -> stream)
354 .test()
355 .assertFailure(TestException.class);
356 }
357
358 @Test
359 public void cancelAfterHasNextInDrain() {
360 @SuppressWarnings("unchecked")
361 Stream<Integer> stream = mock(Stream.class);
362
363 TestObserver<Integer> to = new TestObserver<>();
364
365 when(stream.iterator()).thenReturn(new Iterator<Integer>() {
366
367 int count;
368
369 @Override
370 public boolean hasNext() {
371 if (count++ > 0) {
372 to.dispose();
373 }
374 return true;
375 }
376
377 @Override
378 public Integer next() {
379 return 1;
380 }
381 });
382
383 Maybe.just(1)
384 .flattenStreamAsObservable(v -> stream)
385 .subscribeWith(to)
386 .assertValuesOnly(1);
387 }
388
389 @Test
390 public void cancelAfterNextInDrain() {
391 @SuppressWarnings("unchecked")
392 Stream<Integer> stream = mock(Stream.class);
393
394 TestObserver<Integer> to = new TestObserver<>();
395
396 when(stream.iterator()).thenReturn(new Iterator<Integer>() {
397
398 @Override
399 public boolean hasNext() {
400 return true;
401 }
402
403 @Override
404 public Integer next() {
405 to.dispose();
406 return 1;
407 }
408 });
409
410 Maybe.just(1)
411 .flattenStreamAsObservable(v -> stream)
412 .subscribeWith(to)
413 .assertEmpty();
414 }
415
416 @Test
417 public void cancelSuccessRace() {
418 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
419 MaybeSubject<Integer> ms = MaybeSubject.create();
420
421 TestObserver<Integer> to = new TestObserver<>();
422
423 ms.flattenStreamAsObservable(Stream::of)
424 .subscribe(to);
425
426 Runnable r1 = () -> ms.onSuccess(1);
427 Runnable r2 = () -> to.dispose();
428
429 TestHelper.race(r1, r2);
430 }
431 }
432 }