Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableFromCallableTest.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.assertEquals;
17 import static org.mockito.ArgumentMatchers.any;
18 import static org.mockito.Mockito.*;
19
20 import java.util.List;
21 import java.util.concurrent.*;
22
23 import org.junit.Test;
24 import org.mockito.invocation.InvocationOnMock;
25 import org.mockito.stubbing.Answer;
26
27 import io.reactivex.rxjava3.core.*;
28 import io.reactivex.rxjava3.disposables.Disposable;
29 import io.reactivex.rxjava3.exceptions.TestException;
30 import io.reactivex.rxjava3.functions.Function;
31 import io.reactivex.rxjava3.observers.TestObserver;
32 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
33 import io.reactivex.rxjava3.schedulers.Schedulers;
34 import io.reactivex.rxjava3.testsupport.TestHelper;
35
36 public class ObservableFromCallableTest extends RxJavaTest {
37
38 @SuppressWarnings("unchecked")
39 @Test
40 public void shouldNotInvokeFuncUntilSubscription() throws Exception {
41 Callable<Object> func = mock(Callable.class);
42
43 when(func.call()).thenReturn(new Object());
44
45 Observable<Object> fromCallableObservable = Observable.fromCallable(func);
46
47 verifyNoInteractions(func);
48
49 fromCallableObservable.subscribe();
50
51 verify(func).call();
52 }
53
54 @SuppressWarnings("unchecked")
55 @Test
56 public void shouldCallOnNextAndOnCompleted() throws Exception {
57 Callable<String> func = mock(Callable.class);
58
59 when(func.call()).thenReturn("test_value");
60
61 Observable<String> fromCallableObservable = Observable.fromCallable(func);
62
63 Observer<Object> observer = TestHelper.mockObserver();
64
65 fromCallableObservable.subscribe(observer);
66
67 verify(observer).onNext("test_value");
68 verify(observer).onComplete();
69 verify(observer, never()).onError(any(Throwable.class));
70 }
71
72 @SuppressWarnings("unchecked")
73 @Test
74 public void shouldCallOnError() throws Exception {
75 Callable<Object> func = mock(Callable.class);
76
77 Throwable throwable = new IllegalStateException("Test exception");
78 when(func.call()).thenThrow(throwable);
79
80 Observable<Object> fromCallableObservable = Observable.fromCallable(func);
81
82 Observer<Object> observer = TestHelper.mockObserver();
83
84 fromCallableObservable.subscribe(observer);
85
86 verify(observer, never()).onNext(any());
87 verify(observer, never()).onComplete();
88 verify(observer).onError(throwable);
89 }
90
91 @SuppressWarnings("unchecked")
92 @Test
93 public void shouldNotDeliverResultIfSubscriberUnsubscribedBeforeEmission() throws Exception {
94 Callable<String> func = mock(Callable.class);
95
96 final CountDownLatch funcLatch = new CountDownLatch(1);
97 final CountDownLatch observerLatch = new CountDownLatch(1);
98
99 when(func.call()).thenAnswer(new Answer<String>() {
100 @Override
101 public String answer(InvocationOnMock invocation) throws Throwable {
102 observerLatch.countDown();
103
104 try {
105 funcLatch.await();
106 } catch (InterruptedException e) {
107 // It's okay, unsubscription causes Thread interruption
108
109 // Restoring interruption status of the Thread
110 Thread.currentThread().interrupt();
111 }
112
113 return "should_not_be_delivered";
114 }
115 });
116
117 Observable<String> fromCallableObservable = Observable.fromCallable(func);
118
119 Observer<Object> observer = TestHelper.mockObserver();
120
121 TestObserver<String> outer = new TestObserver<>(observer);
122
123 fromCallableObservable
124 .subscribeOn(Schedulers.computation())
125 .subscribe(outer);
126
127 // Wait until func will be invoked
128 observerLatch.await();
129
130 // Unsubscribing before emission
131 outer.dispose();
132
133 // Emitting result
134 funcLatch.countDown();
135
136 // func must be invoked
137 verify(func).call();
138
139 // Observer must not be notified at all
140 verify(observer).onSubscribe(any(Disposable.class));
141 verifyNoMoreInteractions(observer);
142 }
143
144 @Test
145 public void shouldAllowToThrowCheckedException() {
146 final Exception checkedException = new Exception("test exception");
147
148 Observable<Object> fromCallableObservable = Observable.fromCallable(new Callable<Object>() {
149 @Override
150 public Object call() throws Exception {
151 throw checkedException;
152 }
153 });
154
155 Observer<Object> observer = TestHelper.mockObserver();
156
157 fromCallableObservable.subscribe(observer);
158
159 verify(observer).onSubscribe(any(Disposable.class));
160 verify(observer).onError(checkedException);
161 verifyNoMoreInteractions(observer);
162 }
163
164 @Test
165 public void fusedFlatMapExecution() {
166 final int[] calls = { 0 };
167
168 Observable.just(1).flatMap(new Function<Integer, ObservableSource<? extends Object>>() {
169 @Override
170 public ObservableSource<? extends Object> apply(Integer v)
171 throws Exception {
172 return Observable.fromCallable(new Callable<Object>() {
173 @Override
174 public Object call() throws Exception {
175 return ++calls[0];
176 }
177 });
178 }
179 })
180 .test()
181 .assertResult(1);
182
183 assertEquals(1, calls[0]);
184 }
185
186 @Test
187 public void fusedFlatMapExecutionHidden() {
188 final int[] calls = { 0 };
189
190 Observable.just(1).hide().flatMap(new Function<Integer, ObservableSource<? extends Object>>() {
191 @Override
192 public ObservableSource<? extends Object> apply(Integer v)
193 throws Exception {
194 return Observable.fromCallable(new Callable<Object>() {
195 @Override
196 public Object call() throws Exception {
197 return ++calls[0];
198 }
199 });
200 }
201 })
202 .test()
203 .assertResult(1);
204
205 assertEquals(1, calls[0]);
206 }
207
208 @Test
209 public void fusedFlatMapNull() {
210 Observable.just(1).flatMap(new Function<Integer, ObservableSource<? extends Object>>() {
211 @Override
212 public ObservableSource<? extends Object> apply(Integer v)
213 throws Exception {
214 return Observable.fromCallable(new Callable<Object>() {
215 @Override
216 public Object call() throws Exception {
217 return null;
218 }
219 });
220 }
221 })
222 .test()
223 .assertFailure(NullPointerException.class);
224 }
225
226 @Test
227 public void fusedFlatMapNullHidden() {
228 Observable.just(1).hide().flatMap(new Function<Integer, ObservableSource<? extends Object>>() {
229 @Override
230 public ObservableSource<? extends Object> apply(Integer v)
231 throws Exception {
232 return Observable.fromCallable(new Callable<Object>() {
233 @Override
234 public Object call() throws Exception {
235 return null;
236 }
237 });
238 }
239 })
240 .test()
241 .assertFailure(NullPointerException.class);
242 }
243
244 @Test
245 public void disposedOnArrival() {
246 final int[] count = { 0 };
247 Observable.fromCallable(new Callable<Object>() {
248 @Override
249 public Object call() throws Exception {
250 count[0]++;
251 return 1;
252 }
253 })
254 .test(true)
255 .assertEmpty();
256
257 assertEquals(0, count[0]);
258 }
259
260 @Test
261 public void disposedOnCall() {
262 final TestObserver<Integer> to = new TestObserver<>();
263
264 Observable.fromCallable(new Callable<Integer>() {
265 @Override
266 public Integer call() throws Exception {
267 to.dispose();
268 return 1;
269 }
270 })
271 .subscribe(to);
272
273 to.assertEmpty();
274 }
275
276 @Test
277 public void disposedOnCallThrows() {
278 List<Throwable> errors = TestHelper.trackPluginErrors();
279 try {
280 final TestObserver<Integer> to = new TestObserver<>();
281
282 Observable.fromCallable(new Callable<Integer>() {
283 @Override
284 public Integer call() throws Exception {
285 to.dispose();
286 throw new TestException();
287 }
288 })
289 .subscribe(to);
290
291 to.assertEmpty();
292
293 TestHelper.assertUndeliverable(errors, 0, TestException.class);
294 } finally {
295 RxJavaPlugins.reset();
296 }
297 }
298
299 @Test
300 public void take() {
301 Observable.fromCallable(new Callable<Object>() {
302 @Override
303 public Object call() throws Exception {
304 return 1;
305 }
306 })
307 .take(1)
308 .test()
309 .assertResult(1);
310 }
311 }