Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableAllTest.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.flowable;
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.List;
21 import java.util.concurrent.TimeUnit;
22
23 import org.junit.Test;
24 import org.reactivestreams.*;
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.*;
30 import io.reactivex.rxjava3.internal.functions.Functions;
31 import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
32 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
33 import io.reactivex.rxjava3.subscribers.TestSubscriber;
34 import io.reactivex.rxjava3.testsupport.*;
35
36 public class FlowableAllTest extends RxJavaTest {
37
38 @Test
39 public void all() {
40 Flowable<String> obs = Flowable.just("one", "two", "six");
41
42 SingleObserver<Boolean> observer = TestHelper.mockSingleObserver();
43
44 obs.all(new Predicate<String>() {
45 @Override
46 public boolean test(String s) {
47 return s.length() == 3;
48 }
49 })
50 .subscribe(observer);
51
52 verify(observer).onSubscribe((Disposable)any());
53 verify(observer).onSuccess(true);
54 verifyNoMoreInteractions(observer);
55 }
56
57 @Test
58 public void notAll() {
59 Flowable<String> obs = Flowable.just("one", "two", "three", "six");
60
61 SingleObserver<Boolean> observer = TestHelper.mockSingleObserver();
62
63 obs.all(new Predicate<String>() {
64 @Override
65 public boolean test(String s) {
66 return s.length() == 3;
67 }
68 })
69 .subscribe(observer);
70
71 verify(observer).onSubscribe((Disposable)any());
72 verify(observer).onSuccess(false);
73 verifyNoMoreInteractions(observer);
74 }
75
76 @Test
77 public void empty() {
78 Flowable<String> obs = Flowable.empty();
79
80 SingleObserver<Boolean> observer = TestHelper.mockSingleObserver();
81
82 obs.all(new Predicate<String>() {
83 @Override
84 public boolean test(String s) {
85 return s.length() == 3;
86 }
87 })
88 .subscribe(observer);
89
90 verify(observer).onSubscribe((Disposable)any());
91 verify(observer).onSuccess(true);
92 verifyNoMoreInteractions(observer);
93 }
94
95 @Test
96 public void error() {
97 Throwable error = new Throwable();
98 Flowable<String> obs = Flowable.error(error);
99
100 SingleObserver<Boolean> observer = TestHelper.mockSingleObserver();
101
102 obs.all(new Predicate<String>() {
103 @Override
104 public boolean test(String s) {
105 return s.length() == 3;
106 }
107 })
108 .subscribe(observer);
109
110 verify(observer).onSubscribe((Disposable)any());
111 verify(observer).onError(error);
112 verifyNoMoreInteractions(observer);
113 }
114
115 @Test
116 public void followingFirst() {
117 Flowable<Integer> f = Flowable.fromArray(1, 3, 5, 6);
118 Single<Boolean> allOdd = f.all(new Predicate<Integer>() {
119 @Override
120 public boolean test(Integer i) {
121 return i % 2 == 1;
122 }
123 });
124
125 assertFalse(allOdd.blockingGet());
126 }
127
128 @Test
129 public void issue1935NoUnsubscribeDownstream() {
130 Flowable<Integer> source = Flowable.just(1)
131 .all(new Predicate<Integer>() {
132 @Override
133 public boolean test(Integer t1) {
134 return false;
135 }
136 })
137 .flatMapPublisher(new Function<Boolean, Publisher<Integer>>() {
138 @Override
139 public Publisher<Integer> apply(Boolean t1) {
140 return Flowable.just(2).delay(500, TimeUnit.MILLISECONDS);
141 }
142 });
143
144 assertEquals((Object)2, source.blockingFirst());
145 }
146
147 @Test
148 public void backpressureIfOneRequestedOneShouldBeDelivered() {
149 TestObserverEx<Boolean> to = new TestObserverEx<>();
150
151 Flowable.empty().all(new Predicate<Object>() {
152 @Override
153 public boolean test(Object t) {
154 return false;
155 }
156 }).subscribe(to);
157
158 to.assertTerminated();
159 to.assertNoErrors();
160 to.assertComplete();
161
162 to.assertValue(true);
163 }
164
165 @Test
166 public void predicateThrowsExceptionAndValueInCauseMessage() {
167 TestObserverEx<Boolean> to = new TestObserverEx<>();
168
169 final IllegalArgumentException ex = new IllegalArgumentException();
170
171 Flowable.just("Boo!").all(new Predicate<String>() {
172 @Override
173 public boolean test(String v) {
174 throw ex;
175 }
176 })
177 .subscribe(to);
178
179 to.assertTerminated();
180 to.assertNoValues();
181 to.assertNotComplete();
182 to.assertError(ex);
183 // FIXME need to decide about adding the value that probably caused the crash in some way
184 // assertTrue(ex.getCause().getMessage().contains("Boo!"));
185 }
186
187 @Test
188 public void allFlowable() {
189 Flowable<String> obs = Flowable.just("one", "two", "six");
190
191 Subscriber<Boolean> subscriber = TestHelper.mockSubscriber();
192
193 obs.all(new Predicate<String>() {
194 @Override
195 public boolean test(String s) {
196 return s.length() == 3;
197 }
198 })
199 .toFlowable()
200 .subscribe(subscriber);
201
202 verify(subscriber).onSubscribe((Subscription)any());
203 verify(subscriber).onNext(true);
204 verify(subscriber).onComplete();
205 verifyNoMoreInteractions(subscriber);
206 }
207
208 @Test
209 public void notAllFlowable() {
210 Flowable<String> obs = Flowable.just("one", "two", "three", "six");
211
212 Subscriber <Boolean> subscriber = TestHelper.mockSubscriber();
213
214 obs.all(new Predicate<String>() {
215 @Override
216 public boolean test(String s) {
217 return s.length() == 3;
218 }
219 })
220 .toFlowable()
221 .subscribe(subscriber);
222
223 verify(subscriber).onSubscribe((Subscription)any());
224 verify(subscriber).onNext(false);
225 verify(subscriber).onComplete();
226 verifyNoMoreInteractions(subscriber);
227 }
228
229 @Test
230 public void emptyFlowable() {
231 Flowable<String> obs = Flowable.empty();
232
233 Subscriber <Boolean> subscriber = TestHelper.mockSubscriber();
234
235 obs.all(new Predicate<String>() {
236 @Override
237 public boolean test(String s) {
238 return s.length() == 3;
239 }
240 })
241 .toFlowable()
242 .subscribe(subscriber);
243
244 verify(subscriber).onSubscribe((Subscription)any());
245 verify(subscriber).onNext(true);
246 verify(subscriber).onComplete();
247 verifyNoMoreInteractions(subscriber);
248 }
249
250 @Test
251 public void errorFlowable() {
252 Throwable error = new Throwable();
253 Flowable<String> obs = Flowable.error(error);
254
255 Subscriber <Boolean> subscriber = TestHelper.mockSubscriber();
256
257 obs.all(new Predicate<String>() {
258 @Override
259 public boolean test(String s) {
260 return s.length() == 3;
261 }
262 })
263 .toFlowable()
264 .subscribe(subscriber);
265
266 verify(subscriber).onSubscribe((Subscription)any());
267 verify(subscriber).onError(error);
268 verifyNoMoreInteractions(subscriber);
269 }
270
271 @Test
272 public void followingFirstFlowable() {
273 Flowable<Integer> f = Flowable.fromArray(1, 3, 5, 6);
274 Flowable<Boolean> allOdd = f.all(new Predicate<Integer>() {
275 @Override
276 public boolean test(Integer i) {
277 return i % 2 == 1;
278 }
279 })
280 .toFlowable()
281 ;
282
283 assertFalse(allOdd.blockingFirst());
284 }
285
286 @Test
287 public void issue1935NoUnsubscribeDownstreamFlowable() {
288 Flowable<Integer> source = Flowable.just(1)
289 .all(new Predicate<Integer>() {
290 @Override
291 public boolean test(Integer t1) {
292 return false;
293 }
294 })
295 .toFlowable()
296 .flatMap(new Function<Boolean, Publisher<Integer>>() {
297 @Override
298 public Publisher<Integer> apply(Boolean t1) {
299 return Flowable.just(2).delay(500, TimeUnit.MILLISECONDS);
300 }
301 })
302 ;
303
304 assertEquals((Object)2, source.blockingFirst());
305 }
306
307 @Test
308 public void backpressureIfNoneRequestedNoneShouldBeDeliveredFlowable() {
309 TestSubscriber<Boolean> ts = new TestSubscriber<>(0L);
310 Flowable.empty().all(new Predicate<Object>() {
311 @Override
312 public boolean test(Object t1) {
313 return false;
314 }
315 })
316 .toFlowable()
317 .subscribe(ts);
318
319 ts.assertNoValues();
320 ts.assertNoErrors();
321 ts.assertNotComplete();
322 }
323
324 @Test
325 public void backpressureIfOneRequestedOneShouldBeDeliveredFlowable() {
326 TestSubscriberEx<Boolean> ts = new TestSubscriberEx<>(1L);
327
328 Flowable.empty().all(new Predicate<Object>() {
329 @Override
330 public boolean test(Object t) {
331 return false;
332 }
333 })
334 .toFlowable()
335 .subscribe(ts);
336
337 ts.assertTerminated();
338 ts.assertNoErrors();
339 ts.assertComplete();
340
341 ts.assertValue(true);
342 }
343
344 @Test
345 public void predicateThrowsExceptionAndValueInCauseMessageFlowable() {
346 TestSubscriberEx<Boolean> ts = new TestSubscriberEx<>();
347
348 final IllegalArgumentException ex = new IllegalArgumentException();
349
350 Flowable.just("Boo!").all(new Predicate<String>() {
351 @Override
352 public boolean test(String v) {
353 throw ex;
354 }
355 })
356 .toFlowable()
357 .subscribe(ts);
358
359 ts.assertTerminated();
360 ts.assertNoValues();
361 ts.assertNotComplete();
362 ts.assertError(ex);
363 // FIXME need to decide about adding the value that probably caused the crash in some way
364 // assertTrue(ex.getCause().getMessage().contains("Boo!"));
365 }
366
367 @Test
368 public void dispose() {
369 TestHelper.checkDisposed(Flowable.just(1).all(Functions.alwaysTrue()).toFlowable());
370
371 TestHelper.checkDisposed(Flowable.just(1).all(Functions.alwaysTrue()));
372 }
373
374 @Test
375 public void predicateThrows() {
376 List<Throwable> errors = TestHelper.trackPluginErrors();
377 try {
378 new Flowable<Integer>() {
379 @Override
380 protected void subscribeActual(Subscriber<? super Integer> subscriber) {
381 subscriber.onSubscribe(new BooleanSubscription());
382
383 subscriber.onNext(1);
384 subscriber.onNext(2);
385 subscriber.onError(new TestException());
386 subscriber.onComplete();
387 }
388 }
389 .all(new Predicate<Integer>() {
390 @Override
391 public boolean test(Integer v) throws Exception {
392 throw new TestException();
393 }
394 })
395 .toFlowable()
396 .test()
397 .assertFailure(TestException.class);
398
399 TestHelper.assertUndeliverable(errors, 0, TestException.class);
400 } finally {
401 RxJavaPlugins.reset();
402 }
403 }
404
405 @Test
406 public void predicateThrowsObservable() {
407 List<Throwable> errors = TestHelper.trackPluginErrors();
408 try {
409 new Flowable<Integer>() {
410 @Override
411 protected void subscribeActual(Subscriber<? super Integer> subscriber) {
412 subscriber.onSubscribe(new BooleanSubscription());
413
414 subscriber.onNext(1);
415 subscriber.onNext(2);
416 subscriber.onError(new TestException());
417 subscriber.onComplete();
418 }
419 }
420 .all(new Predicate<Integer>() {
421 @Override
422 public boolean test(Integer v) throws Exception {
423 throw new TestException();
424 }
425 })
426 .toFlowable()
427 .test()
428 .assertFailure(TestException.class);
429
430 TestHelper.assertUndeliverable(errors, 0, TestException.class);
431 } finally {
432 RxJavaPlugins.reset();
433 }
434 }
435
436 @Test
437 public void badSource() {
438 TestHelper.checkBadSourceFlowable(new Function<Flowable<Integer>, Object>() {
439 @Override
440 public Object apply(Flowable<Integer> f) throws Exception {
441 return f.all(Functions.alwaysTrue());
442 }
443 }, false, 1, 1, true);
444
445 TestHelper.checkBadSourceFlowable(new Function<Flowable<Integer>, Object>() {
446 @Override
447 public Object apply(Flowable<Integer> f) throws Exception {
448 return f.all(Functions.alwaysTrue()).toFlowable();
449 }
450 }, false, 1, 1, true);
451 }
452
453 @Test
454 public void doubleOnSubscribe() {
455 TestHelper.checkDoubleOnSubscribeFlowable(new Function<Flowable<Object>, Publisher<Boolean>>() {
456 @Override
457 public Publisher<Boolean> apply(Flowable<Object> f) throws Exception {
458 return f.all(Functions.alwaysTrue()).toFlowable();
459 }
460 });
461 TestHelper.checkDoubleOnSubscribeFlowableToSingle(new Function<Flowable<Object>, Single<Boolean>>() {
462 @Override
463 public Single<Boolean> apply(Flowable<Object> f) throws Exception {
464 return f.all(Functions.alwaysTrue());
465 }
466 });
467 }
468 }