Debian Codegraph @

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