Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/subscribers/LambdaSubscriberTest.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.subscribers;
15
16 import static org.junit.Assert.*;
17
18 import java.util.*;
19
20 import org.junit.Test;
21 import org.reactivestreams.*;
22
23 import io.reactivex.rxjava3.core.*;
24 import io.reactivex.rxjava3.exceptions.*;
25 import io.reactivex.rxjava3.functions.*;
26 import io.reactivex.rxjava3.internal.functions.Functions;
27 import io.reactivex.rxjava3.internal.operators.flowable.FlowableInternalHelper;
28 import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
29 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
30 import io.reactivex.rxjava3.processors.PublishProcessor;
31 import io.reactivex.rxjava3.testsupport.*;
32
33 public class LambdaSubscriberTest extends RxJavaTest {
34
35 @Test
36 public void onSubscribeThrows() {
37 final List<Object> received = new ArrayList<>();
38
39 LambdaSubscriber<Object> subscriber = new LambdaSubscriber<>(new Consumer<Object>() {
40 @Override
41 public void accept(Object v) throws Exception {
42 received.add(v);
43 }
44 },
45 new Consumer<Throwable>() {
46 @Override
47 public void accept(Throwable e) throws Exception {
48 received.add(e);
49 }
50 }, new Action() {
51 @Override
52 public void run() throws Exception {
53 received.add(100);
54 }
55 }, new Consumer<Subscription>() {
56 @Override
57 public void accept(Subscription s) throws Exception {
58 throw new TestException();
59 }
60 });
61
62 assertFalse(subscriber.isDisposed());
63
64 Flowable.just(1).subscribe(subscriber);
65
66 assertTrue(received.toString(), received.get(0) instanceof TestException);
67 assertEquals(received.toString(), 1, received.size());
68
69 assertTrue(subscriber.isDisposed());
70 }
71
72 @Test
73 public void onNextThrows() {
74 final List<Object> received = new ArrayList<>();
75
76 LambdaSubscriber<Object> subscriber = new LambdaSubscriber<>(new Consumer<Object>() {
77 @Override
78 public void accept(Object v) throws Exception {
79 throw new TestException();
80 }
81 },
82 new Consumer<Throwable>() {
83 @Override
84 public void accept(Throwable e) throws Exception {
85 received.add(e);
86 }
87 }, new Action() {
88 @Override
89 public void run() throws Exception {
90 received.add(100);
91 }
92 }, new Consumer<Subscription>() {
93 @Override
94 public void accept(Subscription s) throws Exception {
95 s.request(Long.MAX_VALUE);
96 }
97 });
98
99 assertFalse(subscriber.isDisposed());
100
101 Flowable.just(1).subscribe(subscriber);
102
103 assertTrue(received.toString(), received.get(0) instanceof TestException);
104 assertEquals(received.toString(), 1, received.size());
105
106 assertTrue(subscriber.isDisposed());
107 }
108
109 @Test
110 public void onErrorThrows() {
111 List<Throwable> errors = TestHelper.trackPluginErrors();
112
113 try {
114 final List<Object> received = new ArrayList<>();
115
116 LambdaSubscriber<Object> subscriber = new LambdaSubscriber<>(new Consumer<Object>() {
117 @Override
118 public void accept(Object v) throws Exception {
119 received.add(v);
120 }
121 },
122 new Consumer<Throwable>() {
123 @Override
124 public void accept(Throwable e) throws Exception {
125 throw new TestException("Inner");
126 }
127 }, new Action() {
128 @Override
129 public void run() throws Exception {
130 received.add(100);
131 }
132 }, new Consumer<Subscription>() {
133 @Override
134 public void accept(Subscription s) throws Exception {
135 s.request(Long.MAX_VALUE);
136 }
137 });
138
139 assertFalse(subscriber.isDisposed());
140
141 Flowable.<Integer>error(new TestException("Outer")).subscribe(subscriber);
142
143 assertTrue(received.toString(), received.isEmpty());
144
145 assertTrue(subscriber.isDisposed());
146
147 TestHelper.assertError(errors, 0, CompositeException.class);
148 List<Throwable> ce = TestHelper.compositeList(errors.get(0));
149 TestHelper.assertError(ce, 0, TestException.class, "Outer");
150 TestHelper.assertError(ce, 1, TestException.class, "Inner");
151 } finally {
152 RxJavaPlugins.reset();
153 }
154 }
155
156 @Test
157 public void onCompleteThrows() {
158 List<Throwable> errors = TestHelper.trackPluginErrors();
159
160 try {
161 final List<Object> received = new ArrayList<>();
162
163 LambdaSubscriber<Object> subscriber = new LambdaSubscriber<>(new Consumer<Object>() {
164 @Override
165 public void accept(Object v) throws Exception {
166 received.add(v);
167 }
168 },
169 new Consumer<Throwable>() {
170 @Override
171 public void accept(Throwable e) throws Exception {
172 received.add(e);
173 }
174 }, new Action() {
175 @Override
176 public void run() throws Exception {
177 throw new TestException();
178 }
179 }, new Consumer<Subscription>() {
180 @Override
181 public void accept(Subscription s) throws Exception {
182 s.request(Long.MAX_VALUE);
183 }
184 });
185
186 assertFalse(subscriber.isDisposed());
187
188 Flowable.<Integer>empty().subscribe(subscriber);
189
190 assertTrue(received.toString(), received.isEmpty());
191
192 assertTrue(subscriber.isDisposed());
193
194 TestHelper.assertUndeliverable(errors, 0, TestException.class);
195 } finally {
196 RxJavaPlugins.reset();
197 }
198 }
199
200 @Test
201 public void badSourceOnSubscribe() {
202 Flowable<Integer> source = Flowable.fromPublisher(new Publisher<Integer>() {
203 @Override
204 public void subscribe(Subscriber<? super Integer> s) {
205 BooleanSubscription s1 = new BooleanSubscription();
206 s.onSubscribe(s1);
207 BooleanSubscription s2 = new BooleanSubscription();
208 s.onSubscribe(s2);
209
210 assertFalse(s1.isCancelled());
211 assertTrue(s2.isCancelled());
212
213 s.onNext(1);
214 s.onComplete();
215 }
216 });
217
218 final List<Object> received = new ArrayList<>();
219
220 LambdaSubscriber<Object> subscriber = new LambdaSubscriber<>(new Consumer<Object>() {
221 @Override
222 public void accept(Object v) throws Exception {
223 received.add(v);
224 }
225 },
226 new Consumer<Throwable>() {
227 @Override
228 public void accept(Throwable e) throws Exception {
229 received.add(e);
230 }
231 }, new Action() {
232 @Override
233 public void run() throws Exception {
234 received.add(100);
235 }
236 }, new Consumer<Subscription>() {
237 @Override
238 public void accept(Subscription s) throws Exception {
239 s.request(Long.MAX_VALUE);
240 }
241 });
242
243 source.subscribe(subscriber);
244
245 assertEquals(Arrays.asList(1, 100), received);
246 }
247
248 @Test
249 @SuppressUndeliverable
250 public void badSourceEmitAfterDone() {
251 Flowable<Integer> source = Flowable.fromPublisher(new Publisher<Integer>() {
252 @Override
253 public void subscribe(Subscriber<? super Integer> s) {
254 BooleanSubscription s1 = new BooleanSubscription();
255 s.onSubscribe(s1);
256
257 s.onNext(1);
258 s.onComplete();
259 s.onNext(2);
260 s.onError(new TestException());
261 s.onComplete();
262 }
263 });
264
265 final List<Object> received = new ArrayList<>();
266
267 LambdaSubscriber<Object> subscriber = new LambdaSubscriber<>(new Consumer<Object>() {
268 @Override
269 public void accept(Object v) throws Exception {
270 received.add(v);
271 }
272 },
273 new Consumer<Throwable>() {
274 @Override
275 public void accept(Throwable e) throws Exception {
276 received.add(e);
277 }
278 }, new Action() {
279 @Override
280 public void run() throws Exception {
281 received.add(100);
282 }
283 }, new Consumer<Subscription>() {
284 @Override
285 public void accept(Subscription s) throws Exception {
286 s.request(Long.MAX_VALUE);
287 }
288 });
289
290 source.subscribe(subscriber);
291
292 assertEquals(Arrays.asList(1, 100), received);
293 }
294
295 @Test
296 public void onNextThrowsCancelsUpstream() {
297 PublishProcessor<Integer> pp = PublishProcessor.create();
298
299 final List<Throwable> errors = new ArrayList<>();
300
301 pp.subscribe(new Consumer<Integer>() {
302 @Override
303 public void accept(Integer v) throws Exception {
304 throw new TestException();
305 }
306 }, new Consumer<Throwable>() {
307 @Override
308 public void accept(Throwable e) throws Exception {
309 errors.add(e);
310 }
311 });
312
313 assertTrue("No observers?!", pp.hasSubscribers());
314 assertTrue("Has errors already?!", errors.isEmpty());
315
316 pp.onNext(1);
317
318 assertFalse("Has observers?!", pp.hasSubscribers());
319 assertFalse("No errors?!", errors.isEmpty());
320
321 assertTrue(errors.toString(), errors.get(0) instanceof TestException);
322 }
323
324 @Test
325 public void onSubscribeThrowsCancelsUpstream() {
326 PublishProcessor<Integer> pp = PublishProcessor.create();
327
328 final List<Throwable> errors = new ArrayList<>();
329
330 pp.subscribe(new LambdaSubscriber<>(new Consumer<Integer>() {
331 @Override
332 public void accept(Integer v) throws Exception {
333 }
334 }, new Consumer<Throwable>() {
335 @Override
336 public void accept(Throwable e) throws Exception {
337 errors.add(e);
338 }
339 }, new Action() {
340 @Override
341 public void run() throws Exception {
342 }
343 }, new Consumer<Subscription>() {
344 @Override
345 public void accept(Subscription s) throws Exception {
346 throw new TestException();
347 }
348 }));
349
350 assertFalse("Has observers?!", pp.hasSubscribers());
351 assertFalse("No errors?!", errors.isEmpty());
352
353 assertTrue(errors.toString(), errors.get(0) instanceof TestException);
354 }
355
356 @Test
357 public void onErrorMissingShouldReportNoCustomOnError() {
358 LambdaSubscriber<Integer> subscriber = new LambdaSubscriber<>(Functions.<Integer>emptyConsumer(),
359 Functions.ON_ERROR_MISSING,
360 Functions.EMPTY_ACTION,
361 FlowableInternalHelper.RequestMax.INSTANCE);
362
363 assertFalse(subscriber.hasCustomOnError());
364 }
365
366 @Test
367 public void customOnErrorShouldReportCustomOnError() {
368 LambdaSubscriber<Integer> subscriber = new LambdaSubscriber<>(Functions.<Integer>emptyConsumer(),
369 Functions.<Throwable>emptyConsumer(),
370 Functions.EMPTY_ACTION,
371 FlowableInternalHelper.RequestMax.INSTANCE);
372
373 assertTrue(subscriber.hasCustomOnError());
374 }
375 }