Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/jdk8/ObservableCollectWithCollectorTest.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.io.IOException;
19 import java.util.*;
20 import java.util.function.*;
21 import java.util.stream.*;
22
23 import org.junit.Test;
24
25 import io.reactivex.rxjava3.core.Observable;
26 import io.reactivex.rxjava3.core.Observer;
27 import io.reactivex.rxjava3.core.RxJavaTest;
28 import io.reactivex.rxjava3.disposables.Disposable;
29 import io.reactivex.rxjava3.exceptions.TestException;
30 import io.reactivex.rxjava3.observers.TestObserver;
31 import io.reactivex.rxjava3.processors.*;
32 import io.reactivex.rxjava3.subjects.PublishSubject;
33 import io.reactivex.rxjava3.testsupport.TestHelper;
34
35 public class ObservableCollectWithCollectorTest extends RxJavaTest {
36
37 @Test
38 public void basic() {
39 Observable.range(1, 5)
40 .collect(Collectors.toList())
41 .test()
42 .assertResult(Arrays.asList(1, 2, 3, 4, 5));
43 }
44
45 @Test
46 public void empty() {
47 Observable.empty()
48 .collect(Collectors.toList())
49 .test()
50 .assertResult(Collections.emptyList());
51 }
52
53 @Test
54 public void error() {
55 Observable.error(new TestException())
56 .collect(Collectors.toList())
57 .test()
58 .assertFailure(TestException.class);
59 }
60
61 @Test
62 public void collectorSupplierCrash() {
63 Observable.range(1, 5)
64 .collect(new Collector<Integer, Integer, Integer>() {
65
66 @Override
67 public Supplier<Integer> supplier() {
68 throw new TestException();
69 }
70
71 @Override
72 public BiConsumer<Integer, Integer> accumulator() {
73 return (a, b) -> { };
74 }
75
76 @Override
77 public BinaryOperator<Integer> combiner() {
78 return (a, b) -> a + b;
79 }
80
81 @Override
82 public Function<Integer, Integer> finisher() {
83 return a -> a;
84 }
85
86 @Override
87 public Set<Characteristics> characteristics() {
88 return Collections.emptySet();
89 }
90 })
91 .test()
92 .assertFailure(TestException.class);
93 }
94
95 @Test
96 public void collectorAccumulatorCrash() {
97 BehaviorProcessor<Integer> source = BehaviorProcessor.createDefault(1);
98
99 source
100 .collect(new Collector<Integer, Integer, Integer>() {
101
102 @Override
103 public Supplier<Integer> supplier() {
104 return () -> 1;
105 }
106
107 @Override
108 public BiConsumer<Integer, Integer> accumulator() {
109 return (a, b) -> { throw new TestException(); };
110 }
111
112 @Override
113 public BinaryOperator<Integer> combiner() {
114 return (a, b) -> a + b;
115 }
116
117 @Override
118 public Function<Integer, Integer> finisher() {
119 return a -> a;
120 }
121
122 @Override
123 public Set<Characteristics> characteristics() {
124 return Collections.emptySet();
125 }
126 })
127 .test()
128 .assertFailure(TestException.class);
129
130 assertFalse(source.hasSubscribers());
131 }
132
133 @Test
134 public void collectorFinisherCrash() {
135 Observable.range(1, 5)
136 .collect(new Collector<Integer, Integer, Integer>() {
137
138 @Override
139 public Supplier<Integer> supplier() {
140 return () -> 1;
141 }
142
143 @Override
144 public BiConsumer<Integer, Integer> accumulator() {
145 return (a, b) -> { };
146 }
147
148 @Override
149 public BinaryOperator<Integer> combiner() {
150 return (a, b) -> a + b;
151 }
152
153 @Override
154 public Function<Integer, Integer> finisher() {
155 return a -> { throw new TestException(); };
156 }
157
158 @Override
159 public Set<Characteristics> characteristics() {
160 return Collections.emptySet();
161 }
162 })
163 .test()
164 .assertFailure(TestException.class);
165 }
166
167 @Test
168 public void collectorAccumulatorDropSignals() throws Throwable {
169 TestHelper.withErrorTracking(errors -> {
170 Observable<Integer> source = new Observable<Integer>() {
171 @Override
172 protected void subscribeActual(Observer<? super Integer> observer) {
173 observer.onSubscribe(Disposable.empty());
174 observer.onNext(1);
175 observer.onNext(2);
176 observer.onError(new IOException());
177 observer.onComplete();
178 }
179 };
180
181 source
182 .collect(new Collector<Integer, Integer, Integer>() {
183
184 @Override
185 public Supplier<Integer> supplier() {
186 return () -> 1;
187 }
188
189 @Override
190 public BiConsumer<Integer, Integer> accumulator() {
191 return (a, b) -> { throw new TestException(); };
192 }
193
194 @Override
195 public BinaryOperator<Integer> combiner() {
196 return (a, b) -> a + b;
197 }
198
199 @Override
200 public Function<Integer, Integer> finisher() {
201 return a -> a;
202 }
203
204 @Override
205 public Set<Characteristics> characteristics() {
206 return Collections.emptySet();
207 }
208 })
209 .test()
210 .assertFailure(TestException.class);
211
212 TestHelper.assertUndeliverable(errors, 0, IOException.class);
213 });
214 }
215
216 @Test
217 public void dispose() {
218 TestHelper.checkDisposed(PublishSubject.create()
219 .collect(Collectors.toList()));
220 }
221
222 @Test
223 public void onSubscribe() {
224 TestHelper.checkDoubleOnSubscribeObservableToSingle(f -> f.collect(Collectors.toList()));
225 }
226
227 @Test
228 public void basicToObservable() {
229 Observable.range(1, 5)
230 .collect(Collectors.toList())
231 .toObservable()
232 .test()
233 .assertResult(Arrays.asList(1, 2, 3, 4, 5));
234 }
235
236 @Test
237 public void emptyToObservable() {
238 Observable.empty()
239 .collect(Collectors.toList())
240 .toObservable()
241 .test()
242 .assertResult(Collections.emptyList());
243 }
244
245 @Test
246 public void errorToObservable() {
247 Observable.error(new TestException())
248 .collect(Collectors.toList())
249 .toObservable()
250 .test()
251 .assertFailure(TestException.class);
252 }
253
254 @Test
255 public void collectorSupplierCrashToObservable() {
256 Observable.range(1, 5)
257 .collect(new Collector<Integer, Integer, Integer>() {
258
259 @Override
260 public Supplier<Integer> supplier() {
261 throw new TestException();
262 }
263
264 @Override
265 public BiConsumer<Integer, Integer> accumulator() {
266 return (a, b) -> { };
267 }
268
269 @Override
270 public BinaryOperator<Integer> combiner() {
271 return (a, b) -> a + b;
272 }
273
274 @Override
275 public Function<Integer, Integer> finisher() {
276 return a -> a;
277 }
278
279 @Override
280 public Set<Characteristics> characteristics() {
281 return Collections.emptySet();
282 }
283 })
284 .toObservable()
285 .test()
286 .assertFailure(TestException.class);
287 }
288
289 @Test
290 public void collectorAccumulatorCrashToObservable() {
291 BehaviorProcessor<Integer> source = BehaviorProcessor.createDefault(1);
292
293 source
294 .collect(new Collector<Integer, Integer, Integer>() {
295
296 @Override
297 public Supplier<Integer> supplier() {
298 return () -> 1;
299 }
300
301 @Override
302 public BiConsumer<Integer, Integer> accumulator() {
303 return (a, b) -> { throw new TestException(); };
304 }
305
306 @Override
307 public BinaryOperator<Integer> combiner() {
308 return (a, b) -> a + b;
309 }
310
311 @Override
312 public Function<Integer, Integer> finisher() {
313 return a -> a;
314 }
315
316 @Override
317 public Set<Characteristics> characteristics() {
318 return Collections.emptySet();
319 }
320 })
321 .toObservable()
322 .test()
323 .assertFailure(TestException.class);
324
325 assertFalse(source.hasSubscribers());
326 }
327
328 @Test
329 public void collectorFinisherCrashToObservable() {
330 Observable.range(1, 5)
331 .collect(new Collector<Integer, Integer, Integer>() {
332
333 @Override
334 public Supplier<Integer> supplier() {
335 return () -> 1;
336 }
337
338 @Override
339 public BiConsumer<Integer, Integer> accumulator() {
340 return (a, b) -> { };
341 }
342
343 @Override
344 public BinaryOperator<Integer> combiner() {
345 return (a, b) -> a + b;
346 }
347
348 @Override
349 public Function<Integer, Integer> finisher() {
350 return a -> { throw new TestException(); };
351 }
352
353 @Override
354 public Set<Characteristics> characteristics() {
355 return Collections.emptySet();
356 }
357 })
358 .toObservable()
359 .test()
360 .assertFailure(TestException.class);
361 }
362
363 @Test
364 public void collectorAccumulatorDropSignalsToObservable() throws Throwable {
365 TestHelper.withErrorTracking(errors -> {
366 Observable<Integer> source = new Observable<Integer>() {
367 @Override
368 protected void subscribeActual(Observer<? super Integer> observer) {
369 observer.onSubscribe(Disposable.empty());
370 observer.onNext(1);
371 observer.onNext(2);
372 observer.onError(new IOException());
373 observer.onComplete();
374 }
375 };
376
377 source
378 .collect(new Collector<Integer, Integer, Integer>() {
379
380 @Override
381 public Supplier<Integer> supplier() {
382 return () -> 1;
383 }
384
385 @Override
386 public BiConsumer<Integer, Integer> accumulator() {
387 return (a, b) -> { throw new TestException(); };
388 }
389
390 @Override
391 public BinaryOperator<Integer> combiner() {
392 return (a, b) -> a + b;
393 }
394
395 @Override
396 public Function<Integer, Integer> finisher() {
397 return a -> a;
398 }
399
400 @Override
401 public Set<Characteristics> characteristics() {
402 return Collections.emptySet();
403 }
404 })
405 .toObservable()
406 .test()
407 .assertFailure(TestException.class);
408
409 TestHelper.assertUndeliverable(errors, 0, IOException.class);
410 });
411 }
412
413 @Test
414 public void disposeToObservable() {
415 TestHelper.checkDisposed(PublishProcessor.create()
416 .collect(Collectors.toList()).toObservable());
417 }
418
419 @Test
420 public void onSubscribeToObservable() {
421 TestHelper.checkDoubleOnSubscribeObservable(f -> f.collect(Collectors.toList()).toObservable());
422 }
423
424 @Test
425 public void toObservableTake() {
426 Observable.range(1, 5)
427 .collect(Collectors.toList())
428 .toObservable()
429 .take(1)
430 .test()
431 .assertResult(Arrays.asList(1, 2, 3, 4, 5));
432 }
433
434 @Test
435 public void disposeBeforeEnd() {
436 TestObserver<List<Integer>> to = Observable.range(1, 5).concatWith(Observable.never())
437 .collect(Collectors.toList())
438 .test();
439
440 to.dispose();
441
442 to.assertEmpty();
443 }
444 }