Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableAllTest.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.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
25 import io.reactivex.rxjava3.core.*;
26 import io.reactivex.rxjava3.disposables.*;
27 import io.reactivex.rxjava3.exceptions.TestException;
28 import io.reactivex.rxjava3.functions.*;
29 import io.reactivex.rxjava3.internal.functions.Functions;
30 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
31 import io.reactivex.rxjava3.testsupport.*;
32
33 public class ObservableAllTest extends RxJavaTest {
34
35 @Test
36 public void allObservable() {
37 Observable<String> obs = Observable.just("one", "two", "six");
38
39 Observer <Boolean> observer = TestHelper.mockObserver();
40
41 obs.all(new Predicate<String>() {
42 @Override
43 public boolean test(String s) {
44 return s.length() == 3;
45 }
46 }).toObservable()
47 .subscribe(observer);
48
49 verify(observer).onSubscribe((Disposable)any());
50 verify(observer).onNext(true);
51 verify(observer).onComplete();
52 verifyNoMoreInteractions(observer);
53 }
54
55 @Test
56 public void notAllObservable() {
57 Observable<String> obs = Observable.just("one", "two", "three", "six");
58
59 Observer <Boolean> observer = TestHelper.mockObserver();
60
61 obs.all(new Predicate<String>() {
62 @Override
63 public boolean test(String s) {
64 return s.length() == 3;
65 }
66 }).toObservable()
67 .subscribe(observer);
68
69 verify(observer).onSubscribe((Disposable)any());
70 verify(observer).onNext(false);
71 verify(observer).onComplete();
72 verifyNoMoreInteractions(observer);
73 }
74
75 @Test
76 public void emptyObservable() {
77 Observable<String> obs = Observable.empty();
78
79 Observer <Boolean> observer = TestHelper.mockObserver();
80
81 obs.all(new Predicate<String>() {
82 @Override
83 public boolean test(String s) {
84 return s.length() == 3;
85 }
86 }).toObservable()
87 .subscribe(observer);
88
89 verify(observer).onSubscribe((Disposable)any());
90 verify(observer).onNext(true);
91 verify(observer).onComplete();
92 verifyNoMoreInteractions(observer);
93 }
94
95 @Test
96 public void errorObservable() {
97 Throwable error = new Throwable();
98 Observable<String> obs = Observable.error(error);
99
100 Observer <Boolean> observer = TestHelper.mockObserver();
101
102 obs.all(new Predicate<String>() {
103 @Override
104 public boolean test(String s) {
105 return s.length() == 3;
106 }
107 }).toObservable()
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 followingFirstObservable() {
117 Observable<Integer> o = Observable.fromArray(1, 3, 5, 6);
118 Observable<Boolean> allOdd = o.all(new Predicate<Integer>() {
119 @Override
120 public boolean test(Integer i) {
121 return i % 2 == 1;
122 }
123 }).toObservable();
124
125 assertFalse(allOdd.blockingFirst());
126 }
127
128 @Test
129 public void issue1935NoUnsubscribeDownstreamObservable() {
130 Observable<Integer> source = Observable.just(1)
131 .all(new Predicate<Integer>() {
132 @Override
133 public boolean test(Integer t1) {
134 return false;
135 }
136 }).toObservable()
137 .flatMap(new Function<Boolean, Observable<Integer>>() {
138 @Override
139 public Observable<Integer> apply(Boolean t1) {
140 return Observable.just(2).delay(500, TimeUnit.MILLISECONDS);
141 }
142 });
143
144 assertEquals((Object)2, source.blockingFirst());
145 }
146
147 @Test
148 public void predicateThrowsExceptionAndValueInCauseMessageObservable() {
149 TestObserverEx<Boolean> to = new TestObserverEx<>();
150
151 final IllegalArgumentException ex = new IllegalArgumentException();
152
153 Observable.just("Boo!").all(new Predicate<String>() {
154 @Override
155 public boolean test(String v) {
156 throw ex;
157 }
158 })
159 .subscribe(to);
160
161 to.assertTerminated();
162 to.assertNoValues();
163 to.assertNotComplete();
164 to.assertError(ex);
165 // FIXME need to decide about adding the value that probably caused the crash in some way
166 // assertTrue(ex.getCause().getMessage().contains("Boo!"));
167 }
168
169 @Test
170 public void all() {
171 Observable<String> obs = Observable.just("one", "two", "six");
172
173 SingleObserver<Boolean> observer = TestHelper.mockSingleObserver();
174
175 obs.all(new Predicate<String>() {
176 @Override
177 public boolean test(String s) {
178 return s.length() == 3;
179 }
180 })
181 .subscribe(observer);
182
183 verify(observer).onSubscribe((Disposable)any());
184 verify(observer).onSuccess(true);
185 verifyNoMoreInteractions(observer);
186 }
187
188 @Test
189 public void notAll() {
190 Observable<String> obs = Observable.just("one", "two", "three", "six");
191
192 SingleObserver <Boolean> observer = TestHelper.mockSingleObserver();
193
194 obs.all(new Predicate<String>() {
195 @Override
196 public boolean test(String s) {
197 return s.length() == 3;
198 }
199 })
200 .subscribe(observer);
201
202 verify(observer).onSubscribe((Disposable)any());
203 verify(observer).onSuccess(false);
204 verifyNoMoreInteractions(observer);
205 }
206
207 @Test
208 public void empty() {
209 Observable<String> obs = Observable.empty();
210
211 SingleObserver <Boolean> observer = TestHelper.mockSingleObserver();
212
213 obs.all(new Predicate<String>() {
214 @Override
215 public boolean test(String s) {
216 return s.length() == 3;
217 }
218 })
219 .subscribe(observer);
220
221 verify(observer).onSubscribe((Disposable)any());
222 verify(observer).onSuccess(true);
223 verifyNoMoreInteractions(observer);
224 }
225
226 @Test
227 public void error() {
228 Throwable error = new Throwable();
229 Observable<String> obs = Observable.error(error);
230
231 SingleObserver <Boolean> observer = TestHelper.mockSingleObserver();
232
233 obs.all(new Predicate<String>() {
234 @Override
235 public boolean test(String s) {
236 return s.length() == 3;
237 }
238 })
239 .subscribe(observer);
240
241 verify(observer).onSubscribe((Disposable)any());
242 verify(observer).onError(error);
243 verifyNoMoreInteractions(observer);
244 }
245
246 @Test
247 public void followingFirst() {
248 Observable<Integer> o = Observable.fromArray(1, 3, 5, 6);
249 Single<Boolean> allOdd = o.all(new Predicate<Integer>() {
250 @Override
251 public boolean test(Integer i) {
252 return i % 2 == 1;
253 }
254 });
255
256 assertFalse(allOdd.blockingGet());
257 }
258
259 @Test
260 public void issue1935NoUnsubscribeDownstream() {
261 Observable<Integer> source = Observable.just(1)
262 .all(new Predicate<Integer>() {
263 @Override
264 public boolean test(Integer t1) {
265 return false;
266 }
267 })
268 .flatMapObservable(new Function<Boolean, Observable<Integer>>() {
269 @Override
270 public Observable<Integer> apply(Boolean t1) {
271 return Observable.just(2).delay(500, TimeUnit.MILLISECONDS);
272 }
273 });
274
275 assertEquals((Object)2, source.blockingFirst());
276 }
277
278 @Test
279 public void predicateThrowsExceptionAndValueInCauseMessage() {
280 TestObserverEx<Boolean> to = new TestObserverEx<>();
281
282 final IllegalArgumentException ex = new IllegalArgumentException();
283
284 Observable.just("Boo!").all(new Predicate<String>() {
285 @Override
286 public boolean test(String v) {
287 throw ex;
288 }
289 })
290 .subscribe(to);
291
292 to.assertTerminated();
293 to.assertNoValues();
294 to.assertNotComplete();
295 to.assertError(ex);
296 // FIXME need to decide about adding the value that probably caused the crash in some way
297 // assertTrue(ex.getCause().getMessage().contains("Boo!"));
298 }
299
300 @Test
301 public void dispose() {
302 TestHelper.checkDisposed(Observable.just(1).all(Functions.alwaysTrue()).toObservable());
303
304 TestHelper.checkDisposed(Observable.just(1).all(Functions.alwaysTrue()));
305 }
306
307 @Test
308 public void predicateThrowsObservable() {
309 List<Throwable> errors = TestHelper.trackPluginErrors();
310 try {
311 new Observable<Integer>() {
312 @Override
313 protected void subscribeActual(Observer<? super Integer> observer) {
314 observer.onSubscribe(Disposable.empty());
315
316 observer.onNext(1);
317 observer.onNext(2);
318 observer.onError(new TestException());
319 observer.onComplete();
320 }
321 }
322 .all(new Predicate<Integer>() {
323 @Override
324 public boolean test(Integer v) throws Exception {
325 throw new TestException();
326 }
327 })
328 .toObservable()
329 .test()
330 .assertFailure(TestException.class);
331
332 TestHelper.assertUndeliverable(errors, 0, TestException.class);
333 } finally {
334 RxJavaPlugins.reset();
335 }
336 }
337
338 @Test
339 public void predicateThrows() {
340 List<Throwable> errors = TestHelper.trackPluginErrors();
341 try {
342 new Observable<Integer>() {
343 @Override
344 protected void subscribeActual(Observer<? super Integer> observer) {
345 observer.onSubscribe(Disposable.empty());
346
347 observer.onNext(1);
348 observer.onNext(2);
349 observer.onError(new TestException());
350 observer.onComplete();
351 }
352 }
353 .all(new Predicate<Integer>() {
354 @Override
355 public boolean test(Integer v) throws Exception {
356 throw new TestException();
357 }
358 })
359 .test()
360 .assertFailure(TestException.class);
361
362 TestHelper.assertUndeliverable(errors, 0, TestException.class);
363 } finally {
364 RxJavaPlugins.reset();
365 }
366 }
367
368 @Test
369 public void doubleOnSubscribe() {
370 TestHelper.checkDoubleOnSubscribeObservableToSingle(o -> o.all(v -> true));
371 }
372
373 @Test
374 public void doubleOnSubscribeObservable() {
375 TestHelper.checkDoubleOnSubscribeObservable(o -> o.all(v -> true).toObservable());
376 }
377 }