Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableScanTest.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.observable;
15
16 import static org.junit.Assert.*;
17 import static org.mockito.ArgumentMatchers.*;
18 import static org.mockito.Mockito.*;
19
20 import java.util.*;
21 import java.util.concurrent.CopyOnWriteArrayList;
22 import java.util.concurrent.atomic.AtomicInteger;
23
24 import org.junit.Test;
25
26 import io.reactivex.rxjava3.core.*;
27 import io.reactivex.rxjava3.core.Observable;
28 import io.reactivex.rxjava3.core.Observer;
29 import io.reactivex.rxjava3.disposables.*;
30 import io.reactivex.rxjava3.exceptions.TestException;
31 import io.reactivex.rxjava3.functions.*;
32 import io.reactivex.rxjava3.observers.*;
33 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
34 import io.reactivex.rxjava3.subjects.PublishSubject;
35 import io.reactivex.rxjava3.testsupport.*;
36
37 public class ObservableScanTest extends RxJavaTest {
38
39 @Test
40 public void scanIntegersWithInitialValue() {
41 Observer<String> observer = TestHelper.mockObserver();
42
43 Observable<Integer> o = Observable.just(1, 2, 3);
44
45 Observable<String> m = o.scan("", new BiFunction<String, Integer, String>() {
46
47 @Override
48 public String apply(String s, Integer n) {
49 return s + n.toString();
50 }
51
52 });
53 m.subscribe(observer);
54
55 verify(observer, never()).onError(any(Throwable.class));
56 verify(observer, times(1)).onNext("");
57 verify(observer, times(1)).onNext("1");
58 verify(observer, times(1)).onNext("12");
59 verify(observer, times(1)).onNext("123");
60 verify(observer, times(4)).onNext(anyString());
61 verify(observer, times(1)).onComplete();
62 verify(observer, never()).onError(any(Throwable.class));
63 }
64
65 @Test
66 public void scanIntegersWithoutInitialValue() {
67 Observer<Integer> observer = TestHelper.mockObserver();
68
69 Observable<Integer> o = Observable.just(1, 2, 3);
70
71 Observable<Integer> m = o.scan(new BiFunction<Integer, Integer, Integer>() {
72
73 @Override
74 public Integer apply(Integer t1, Integer t2) {
75 return t1 + t2;
76 }
77
78 });
79 m.subscribe(observer);
80
81 verify(observer, never()).onError(any(Throwable.class));
82 verify(observer, never()).onNext(0);
83 verify(observer, times(1)).onNext(1);
84 verify(observer, times(1)).onNext(3);
85 verify(observer, times(1)).onNext(6);
86 verify(observer, times(3)).onNext(anyInt());
87 verify(observer, times(1)).onComplete();
88 verify(observer, never()).onError(any(Throwable.class));
89 }
90
91 @Test
92 public void scanIntegersWithoutInitialValueAndOnlyOneValue() {
93 Observer<Integer> observer = TestHelper.mockObserver();
94
95 Observable<Integer> o = Observable.just(1);
96
97 Observable<Integer> m = o.scan(new BiFunction<Integer, Integer, Integer>() {
98
99 @Override
100 public Integer apply(Integer t1, Integer t2) {
101 return t1 + t2;
102 }
103
104 });
105 m.subscribe(observer);
106
107 verify(observer, never()).onError(any(Throwable.class));
108 verify(observer, never()).onNext(0);
109 verify(observer, times(1)).onNext(1);
110 verify(observer, times(1)).onNext(anyInt());
111 verify(observer, times(1)).onComplete();
112 verify(observer, never()).onError(any(Throwable.class));
113 }
114
115 @Test
116 public void shouldNotEmitUntilAfterSubscription() {
117 TestObserver<Integer> to = new TestObserver<>();
118 Observable.range(1, 100).scan(0, new BiFunction<Integer, Integer, Integer>() {
119
120 @Override
121 public Integer apply(Integer t1, Integer t2) {
122 return t1 + t2;
123 }
124
125 }).filter(new Predicate<Integer>() {
126
127 @Override
128 public boolean test(Integer t1) {
129 // this will cause request(1) when 0 is emitted
130 return t1 > 0;
131 }
132
133 }).subscribe(to);
134
135 assertEquals(100, to.values().size());
136 }
137
138 @Test
139 public void noBackpressureWithInitialValue() {
140 final AtomicInteger count = new AtomicInteger();
141 Observable.range(1, 100)
142 .scan(0, new BiFunction<Integer, Integer, Integer>() {
143
144 @Override
145 public Integer apply(Integer t1, Integer t2) {
146 return t1 + t2;
147 }
148
149 })
150 .subscribe(new DefaultObserver<Integer>() {
151
152 @Override
153 public void onComplete() {
154
155 }
156
157 @Override
158 public void onError(Throwable e) {
159 fail(e.getMessage());
160 e.printStackTrace();
161 }
162
163 @Override
164 public void onNext(Integer t) {
165 count.incrementAndGet();
166 }
167
168 });
169
170 // we only expect to receive 101 as we'll receive all 100 + the initial value
171 assertEquals(101, count.get());
172 }
173
174 /**
175 * This uses the public API collect which uses scan under the covers.
176 */
177 @Test
178 public void seedFactory() {
179 Observable<List<Integer>> o = Observable.range(1, 10)
180 .collect(new Supplier<List<Integer>>() {
181
182 @Override
183 public List<Integer> get() {
184 return new ArrayList<>();
185 }
186
187 }, new BiConsumer<List<Integer>, Integer>() {
188
189 @Override
190 public void accept(List<Integer> list, Integer t2) {
191 list.add(t2);
192 }
193
194 }).toObservable().takeLast(1);
195
196 assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), o.blockingSingle());
197 assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10), o.blockingSingle());
198 }
199
200 @Test
201 public void scanWithRequestOne() {
202 Observable<Integer> o = Observable.just(1, 2).scan(0, new BiFunction<Integer, Integer, Integer>() {
203
204 @Override
205 public Integer apply(Integer t1, Integer t2) {
206 return t1 + t2;
207 }
208
209 }).take(1);
210
211 TestObserverEx<Integer> observer = new TestObserverEx<>();
212
213 o.subscribe(observer);
214 observer.assertValue(0);
215 observer.assertTerminated();
216 observer.assertNoErrors();
217 }
218
219 @Test
220 public void initialValueEmittedNoProducer() {
221 PublishSubject<Integer> source = PublishSubject.create();
222
223 TestObserver<Integer> to = new TestObserver<>();
224
225 source.scan(0, new BiFunction<Integer, Integer, Integer>() {
226 @Override
227 public Integer apply(Integer t1, Integer t2) {
228 return t1 + t2;
229 }
230 }).subscribe(to);
231
232 to.assertNoErrors();
233 to.assertNotComplete();
234 to.assertValue(0);
235 }
236
237 @Test
238 public void dispose() {
239 TestHelper.checkDisposed(PublishSubject.create().scan(new BiFunction<Object, Object, Object>() {
240 @Override
241 public Object apply(Object a, Object b) throws Exception {
242 return a;
243 }
244 }));
245
246 TestHelper.checkDisposed(PublishSubject.<Integer>create().scan(0, new BiFunction<Integer, Integer, Integer>() {
247 @Override
248 public Integer apply(Integer a, Integer b) throws Exception {
249 return a + b;
250 }
251 }));
252 }
253
254 @Test
255 public void doubleOnSubscribe() {
256 TestHelper.checkDoubleOnSubscribeObservable(new Function<Observable<Object>, ObservableSource<Object>>() {
257 @Override
258 public ObservableSource<Object> apply(Observable<Object> o) throws Exception {
259 return o.scan(new BiFunction<Object, Object, Object>() {
260 @Override
261 public Object apply(Object a, Object b) throws Exception {
262 return a;
263 }
264 });
265 }
266 });
267
268 TestHelper.checkDoubleOnSubscribeObservable(new Function<Observable<Object>, ObservableSource<Object>>() {
269 @Override
270 public ObservableSource<Object> apply(Observable<Object> o) throws Exception {
271 return o.scan(0, new BiFunction<Object, Object, Object>() {
272 @Override
273 public Object apply(Object a, Object b) throws Exception {
274 return a;
275 }
276 });
277 }
278 });
279 }
280
281 @Test
282 public void error() {
283 Observable.error(new TestException())
284 .scan(new BiFunction<Object, Object, Object>() {
285 @Override
286 public Object apply(Object a, Object b) throws Exception {
287 return a;
288 }
289 })
290 .test()
291 .assertFailure(TestException.class);
292 }
293
294 @Test
295 public void badSource() {
296 TestHelper.checkBadSourceObservable(new Function<Observable<Object>, Object>() {
297 @Override
298 public Object apply(Observable<Object> o) throws Exception {
299 return o.scan(0, new BiFunction<Object, Object, Object>() {
300 @Override
301 public Object apply(Object a, Object b) throws Exception {
302 return a;
303 }
304 });
305 }
306 }, false, 1, 1, 0, 0);
307 }
308
309 @Test
310 public void scanFunctionThrowsAndUpstreamErrorsDoesNotResultInTwoTerminalEvents() {
311 final RuntimeException err = new RuntimeException();
312 final RuntimeException err2 = new RuntimeException();
313 final List<Throwable> list = new CopyOnWriteArrayList<>();
314 final Consumer<Throwable> errorConsumer = new Consumer<Throwable>() {
315 @Override
316 public void accept(Throwable t) throws Exception {
317 list.add(t);
318 }};
319 try {
320 RxJavaPlugins.setErrorHandler(errorConsumer);
321 Observable.unsafeCreate(new ObservableSource<Integer>() {
322 @Override
323 public void subscribe(Observer<? super Integer> o) {
324 Disposable d = Disposable.empty();
325 o.onSubscribe(d);
326 o.onNext(1);
327 o.onNext(2);
328 o.onError(err2);
329 }})
330 .scan(new BiFunction<Integer, Integer, Integer>() {
331 @Override
332 public Integer apply(Integer t1, Integer t2) throws Exception {
333 throw err;
334 }})
335 .test()
336 .assertError(err)
337 .assertValue(1);
338 } finally {
339 RxJavaPlugins.reset();
340 }
341 }
342
343 @Test
344 public void scanFunctionThrowsAndUpstreamCompletesDoesNotResultInTwoTerminalEvents() {
345 final RuntimeException err = new RuntimeException();
346 Observable.unsafeCreate(new ObservableSource<Integer>() {
347 @Override
348 public void subscribe(Observer<? super Integer> o) {
349 Disposable d = Disposable.empty();
350 o.onSubscribe(d);
351 o.onNext(1);
352 o.onNext(2);
353 o.onComplete();
354 }})
355 .scan(new BiFunction<Integer, Integer, Integer>() {
356 @Override
357 public Integer apply(Integer t1, Integer t2) throws Exception {
358 throw err;
359 }})
360 .test()
361 .assertError(err)
362 .assertValue(1);
363 }
364
365 @Test
366 public void scanFunctionThrowsAndUpstreamEmitsOnNextResultsInScanFunctionBeingCalledOnlyOnce() {
367 final RuntimeException err = new RuntimeException();
368 final AtomicInteger count = new AtomicInteger();
369 Observable.unsafeCreate(new ObservableSource<Integer>() {
370 @Override
371 public void subscribe(Observer<? super Integer> o) {
372 Disposable d = Disposable.empty();
373 o.onSubscribe(d);
374 o.onNext(1);
375 o.onNext(2);
376 o.onNext(3);
377 }})
378 .scan(new BiFunction<Integer, Integer, Integer>() {
379 @Override
380 public Integer apply(Integer t1, Integer t2) throws Exception {
381 count.incrementAndGet();
382 throw err;
383 }})
384 .test()
385 .assertError(err)
386 .assertValue(1);
387 assertEquals(1, count.get());
388 }
389 }