Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/maybe/MaybeFlatMapIterableObservableTest.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.maybe;
15
16 import static org.junit.Assert.*;
17
18 import java.util.*;
19 import java.util.concurrent.TimeUnit;
20
21 import org.junit.Test;
22
23 import io.reactivex.rxjava3.core.*;
24 import io.reactivex.rxjava3.core.Observer;
25 import io.reactivex.rxjava3.disposables.Disposable;
26 import io.reactivex.rxjava3.exceptions.TestException;
27 import io.reactivex.rxjava3.functions.Function;
28 import io.reactivex.rxjava3.internal.util.CrashingIterable;
29 import io.reactivex.rxjava3.operators.QueueDisposable;
30 import io.reactivex.rxjava3.operators.QueueFuseable;
31 import io.reactivex.rxjava3.schedulers.Schedulers;
32 import io.reactivex.rxjava3.testsupport.*;
33
34 public class MaybeFlatMapIterableObservableTest extends RxJavaTest {
35
36 @Test
37 public void normal() {
38
39 Maybe.just(1).flattenAsObservable(new Function<Integer, Iterable<Integer>>() {
40 @Override
41 public Iterable<Integer> apply(Integer v) throws Exception {
42 return Arrays.asList(v, v + 1);
43 }
44 })
45 .test()
46 .assertResult(1, 2);
47 }
48
49 @Test
50 public void emptyIterable() {
51
52 Maybe.just(1).flattenAsObservable(new Function<Integer, Iterable<Integer>>() {
53 @Override
54 public Iterable<Integer> apply(Integer v) throws Exception {
55 return Collections.<Integer>emptyList();
56 }
57 })
58 .test()
59 .assertResult();
60 }
61
62 @Test
63 public void error() {
64
65 Maybe.<Integer>error(new TestException()).flattenAsObservable(new Function<Integer, Iterable<Integer>>() {
66 @Override
67 public Iterable<Integer> apply(Integer v) throws Exception {
68 return Arrays.asList(v, v + 1);
69 }
70 })
71 .test()
72 .assertFailure(TestException.class);
73 }
74
75 @Test
76 public void empty() {
77
78 Maybe.<Integer>empty().flattenAsObservable(new Function<Integer, Iterable<Integer>>() {
79 @Override
80 public Iterable<Integer> apply(Integer v) throws Exception {
81 return Arrays.asList(v, v + 1);
82 }
83 })
84 .test()
85 .assertResult();
86 }
87
88 @Test
89 public void take() {
90 Maybe.just(1).flattenAsObservable(new Function<Integer, Iterable<Integer>>() {
91 @Override
92 public Iterable<Integer> apply(Integer v) throws Exception {
93 return Arrays.asList(v, v + 1);
94 }
95 })
96 .take(1)
97 .test()
98 .assertResult(1);
99 }
100
101 @Test
102 public void fused() {
103 TestObserverEx<Integer> to = new TestObserverEx<>(QueueFuseable.ANY);
104
105 Maybe.just(1).flattenAsObservable(new Function<Integer, Iterable<Integer>>() {
106 @Override
107 public Iterable<Integer> apply(Integer v) throws Exception {
108 return Arrays.asList(v, v + 1);
109 }
110 })
111 .subscribe(to);
112
113 to.assertFuseable()
114 .assertFusionMode(QueueFuseable.ASYNC)
115 .assertResult(1, 2);
116 ;
117 }
118
119 @Test
120 public void fusedNoSync() {
121 TestObserverEx<Integer> to = new TestObserverEx<>(QueueFuseable.SYNC);
122
123 Maybe.just(1).flattenAsObservable(new Function<Integer, Iterable<Integer>>() {
124 @Override
125 public Iterable<Integer> apply(Integer v) throws Exception {
126 return Arrays.asList(v, v + 1);
127 }
128 })
129 .subscribe(to);
130
131 to.assertFuseable()
132 .assertFusionMode(QueueFuseable.NONE)
133 .assertResult(1, 2)
134 ;
135 }
136
137 @Test
138 public void iteratorCrash() {
139
140 Maybe.just(1).flattenAsObservable(new Function<Integer, Iterable<Integer>>() {
141 @Override
142 public Iterable<Integer> apply(Integer v) throws Exception {
143 return new CrashingIterable(1, 100, 100);
144 }
145 })
146 .to(TestHelper.<Integer>testConsumer())
147 .assertFailureAndMessage(TestException.class, "iterator()");
148 }
149
150 @Test
151 public void hasNextCrash() {
152
153 Maybe.just(1).flattenAsObservable(new Function<Integer, Iterable<Integer>>() {
154 @Override
155 public Iterable<Integer> apply(Integer v) throws Exception {
156 return new CrashingIterable(100, 1, 100);
157 }
158 })
159 .to(TestHelper.<Integer>testConsumer())
160 .assertFailureAndMessage(TestException.class, "hasNext()");
161 }
162
163 @Test
164 public void nextCrash() {
165
166 Maybe.just(1).flattenAsObservable(new Function<Integer, Iterable<Integer>>() {
167 @Override
168 public Iterable<Integer> apply(Integer v) throws Exception {
169 return new CrashingIterable(100, 100, 1);
170 }
171 })
172 .to(TestHelper.<Integer>testConsumer())
173 .assertFailureAndMessage(TestException.class, "next()");
174 }
175
176 @Test
177 public void hasNextCrash2() {
178
179 Maybe.just(1).flattenAsObservable(new Function<Integer, Iterable<Integer>>() {
180 @Override
181 public Iterable<Integer> apply(Integer v) throws Exception {
182 return new CrashingIterable(100, 2, 100);
183 }
184 })
185 .to(TestHelper.<Integer>testConsumer())
186 .assertFailureAndMessage(TestException.class, "hasNext()", 0);
187 }
188
189 @Test
190 public void doubleOnSubscribe() {
191 TestHelper.checkDoubleOnSubscribeMaybeToObservable(new Function<Maybe<Object>, ObservableSource<Integer>>() {
192 @Override
193 public ObservableSource<Integer> apply(Maybe<Object> o) throws Exception {
194 return o.flattenAsObservable(new Function<Object, Iterable<Integer>>() {
195 @Override
196 public Iterable<Integer> apply(Object v) throws Exception {
197 return Collections.singleton(1);
198 }
199 });
200 }
201 });
202 }
203
204 @Test
205 public void dispose() {
206 TestHelper.checkDisposed(Maybe.just(1).flattenAsObservable(new Function<Object, Iterable<Integer>>() {
207 @Override
208 public Iterable<Integer> apply(Object v) throws Exception {
209 return Collections.singleton(1);
210 }
211 }));
212 }
213
214 @Test
215 public void async1() {
216 Maybe.just(1)
217 .flattenAsObservable(new Function<Object, Iterable<Integer>>() {
218 @Override
219 public Iterable<Integer> apply(Object v) throws Exception {
220 Integer[] array = new Integer[1000 * 1000];
221 Arrays.fill(array, 1);
222 return Arrays.asList(array);
223 }
224 })
225 .hide()
226 .observeOn(Schedulers.single())
227 .to(TestHelper.<Integer>testConsumer())
228 .awaitDone(5, TimeUnit.SECONDS)
229 .assertSubscribed()
230 .assertValueCount(1000 * 1000)
231 .assertNoErrors()
232 .assertComplete();
233 }
234
235 @Test
236 public void async2() {
237 Maybe.just(1)
238 .flattenAsObservable(new Function<Object, Iterable<Integer>>() {
239 @Override
240 public Iterable<Integer> apply(Object v) throws Exception {
241 Integer[] array = new Integer[1000 * 1000];
242 Arrays.fill(array, 1);
243 return Arrays.asList(array);
244 }
245 })
246 .observeOn(Schedulers.single())
247 .to(TestHelper.<Integer>testConsumer())
248 .awaitDone(5, TimeUnit.SECONDS)
249 .assertSubscribed()
250 .assertValueCount(1000 * 1000)
251 .assertNoErrors()
252 .assertComplete();
253 }
254
255 @Test
256 public void async3() {
257 Maybe.just(1)
258 .flattenAsObservable(new Function<Object, Iterable<Integer>>() {
259 @Override
260 public Iterable<Integer> apply(Object v) throws Exception {
261 Integer[] array = new Integer[1000 * 1000];
262 Arrays.fill(array, 1);
263 return Arrays.asList(array);
264 }
265 })
266 .take(500 * 1000)
267 .observeOn(Schedulers.single())
268 .to(TestHelper.<Integer>testConsumer())
269 .awaitDone(5, TimeUnit.SECONDS)
270 .assertSubscribed()
271 .assertValueCount(500 * 1000)
272 .assertNoErrors()
273 .assertComplete();
274 }
275
276 @Test
277 public void async4() {
278 Maybe.just(1)
279 .flattenAsObservable(new Function<Object, Iterable<Integer>>() {
280 @Override
281 public Iterable<Integer> apply(Object v) throws Exception {
282 Integer[] array = new Integer[1000 * 1000];
283 Arrays.fill(array, 1);
284 return Arrays.asList(array);
285 }
286 })
287 .observeOn(Schedulers.single())
288 .take(500 * 1000)
289 .to(TestHelper.<Integer>testConsumer())
290 .awaitDone(5, TimeUnit.SECONDS)
291 .assertSubscribed()
292 .assertValueCount(500 * 1000)
293 .assertNoErrors()
294 .assertComplete();
295 }
296
297 @Test
298 public void fusedEmptyCheck() {
299 Maybe.just(1)
300 .flattenAsObservable(new Function<Object, Iterable<Integer>>() {
301 @Override
302 public Iterable<Integer> apply(Object v) throws Exception {
303 return Arrays.asList(1, 2, 3);
304 }
305 }).subscribe(new Observer<Integer>() {
306 QueueDisposable<Integer> qd;
307 @SuppressWarnings("unchecked")
308 @Override
309 public void onSubscribe(Disposable d) {
310 qd = (QueueDisposable<Integer>)d;
311
312 assertEquals(QueueFuseable.ASYNC, qd.requestFusion(QueueFuseable.ANY));
313 }
314
315 @Override
316 public void onNext(Integer value) {
317 assertFalse(qd.isEmpty());
318
319 qd.clear();
320
321 assertTrue(qd.isEmpty());
322
323 qd.dispose();
324 }
325
326 @Override
327 public void onError(Throwable e) {
328 }
329
330 @Override
331 public void onComplete() {
332 }
333 });
334 }
335 }