Debian Codegraph @

src/test/java/io/reactivex/rxjava3/processors/UnicastProcessorTest.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.processors;
15
16 import static org.junit.Assert.*;
17
18 import java.util.List;
19 import java.util.concurrent.TimeUnit;
20 import java.util.concurrent.atomic.AtomicBoolean;
21
22 import org.junit.Test;
23
24 import io.reactivex.rxjava3.core.Observable;
25 import io.reactivex.rxjava3.disposables.Disposable;
26 import io.reactivex.rxjava3.exceptions.*;
27 import io.reactivex.rxjava3.internal.functions.Functions;
28 import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
29 import io.reactivex.rxjava3.observers.TestObserver;
30 import io.reactivex.rxjava3.operators.QueueFuseable;
31 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
32 import io.reactivex.rxjava3.schedulers.Schedulers;
33 import io.reactivex.rxjava3.subscribers.TestSubscriber;
34 import io.reactivex.rxjava3.testsupport.*;
35
36 public class UnicastProcessorTest extends FlowableProcessorTest<Object> {
37
38 @Override
39 protected FlowableProcessor<Object> create() {
40 return UnicastProcessor.create();
41 }
42
43 @Test
44 public void fusionLive() {
45 UnicastProcessor<Integer> ap = UnicastProcessor.create();
46
47 TestSubscriberEx<Integer> ts = new TestSubscriberEx<Integer>().setInitialFusionMode(QueueFuseable.ANY);
48
49 ap.subscribe(ts);
50
51 ts
52 .assertFuseable()
53 .assertFusionMode(QueueFuseable.ASYNC);
54
55 ts.assertNoValues().assertNoErrors().assertNotComplete();
56
57 ap.onNext(1);
58
59 ts.assertValue(1).assertNoErrors().assertNotComplete();
60
61 ap.onComplete();
62
63 ts.assertResult(1);
64 }
65
66 @Test
67 public void fusionOfflie() {
68 UnicastProcessor<Integer> ap = UnicastProcessor.create();
69 ap.onNext(1);
70 ap.onComplete();
71
72 TestSubscriberEx<Integer> ts = new TestSubscriberEx<Integer>().setInitialFusionMode(QueueFuseable.ANY);
73
74 ap.subscribe(ts);
75
76 ts
77 .assertFuseable()
78 .assertFusionMode(QueueFuseable.ASYNC)
79 .assertResult(1);
80 }
81
82 @Test
83 public void failFast() {
84 UnicastProcessor<Integer> ap = UnicastProcessor.create(false);
85 ap.onNext(1);
86 ap.onError(new RuntimeException());
87
88 TestSubscriber<Integer> ts = TestSubscriber.create();
89
90 ap.subscribe(ts);
91
92 ts
93 .assertValueCount(0)
94 .assertError(RuntimeException.class);
95 }
96
97 @Test
98 public void failFastFusionOffline() {
99 UnicastProcessor<Integer> ap = UnicastProcessor.create(false);
100 ap.onNext(1);
101 ap.onError(new RuntimeException());
102
103 TestSubscriberEx<Integer> ts = new TestSubscriberEx<Integer>().setInitialFusionMode(QueueFuseable.ANY);
104
105 ap.subscribe(ts);
106 ts
107 .assertValueCount(0)
108 .assertError(RuntimeException.class);
109 }
110
111 @Test
112 public void threeArgsFactory() {
113 Runnable noop = new Runnable() {
114 @Override
115 public void run() {
116 }
117 };
118 UnicastProcessor<Integer> ap = UnicastProcessor.create(16, noop, false);
119 ap.onNext(1);
120 ap.onError(new RuntimeException());
121
122 TestSubscriber<Integer> ts = TestSubscriber.create();
123
124 ap.subscribe(ts);
125 ts
126 .assertValueCount(0)
127 .assertError(RuntimeException.class);
128 }
129
130 @Test
131 public void onTerminateCalledWhenOnError() {
132 final AtomicBoolean didRunOnTerminate = new AtomicBoolean();
133
134 UnicastProcessor<Integer> up = UnicastProcessor.create(Observable.bufferSize(), new Runnable() {
135 @Override public void run() {
136 didRunOnTerminate.set(true);
137 }
138 });
139
140 assertFalse(didRunOnTerminate.get());
141 up.onError(new RuntimeException("some error"));
142 assertTrue(didRunOnTerminate.get());
143 }
144
145 @Test
146 public void onTerminateCalledWhenOnComplete() {
147 final AtomicBoolean didRunOnTerminate = new AtomicBoolean();
148
149 UnicastProcessor<Integer> up = UnicastProcessor.create(Observable.bufferSize(), new Runnable() {
150 @Override public void run() {
151 didRunOnTerminate.set(true);
152 }
153 });
154
155 assertFalse(didRunOnTerminate.get());
156 up.onComplete();
157 assertTrue(didRunOnTerminate.get());
158 }
159
160 @Test
161 public void onTerminateCalledWhenCanceled() {
162 final AtomicBoolean didRunOnTerminate = new AtomicBoolean();
163
164 UnicastProcessor<Integer> up = UnicastProcessor.create(Observable.bufferSize(), new Runnable() {
165 @Override public void run() {
166 didRunOnTerminate.set(true);
167 }
168 });
169
170 final Disposable subscribe = up.subscribe();
171
172 assertFalse(didRunOnTerminate.get());
173 subscribe.dispose();
174 assertTrue(didRunOnTerminate.get());
175 }
176
177 @Test(expected = NullPointerException.class)
178 public void nullOnTerminate() {
179 UnicastProcessor.create(5, null);
180 }
181
182 @Test(expected = IllegalArgumentException.class)
183 public void negativeCapacityHint() {
184 UnicastProcessor.create(-1);
185 }
186
187 @Test(expected = IllegalArgumentException.class)
188 public void zeroCapacityHint() {
189 UnicastProcessor.create(0);
190 }
191
192 @Test
193 public void completeCancelRace() {
194 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
195 final int[] calls = { 0 };
196 final UnicastProcessor<Object> up = UnicastProcessor.create(100, new Runnable() {
197 @Override
198 public void run() {
199 calls[0]++;
200 }
201 });
202
203 final TestSubscriber<Object> ts = up.test();
204
205 Runnable r1 = new Runnable() {
206 @Override
207 public void run() {
208 ts.cancel();
209 }
210 };
211
212 Runnable r2 = new Runnable() {
213 @Override
214 public void run() {
215 up.onComplete();
216 }
217 };
218
219 TestHelper.race(r1, r2);
220
221 assertEquals(1, calls[0]);
222 }
223 }
224
225 @Test
226 public void afterDone() {
227 UnicastProcessor<Object> p = UnicastProcessor.create();
228 p.onComplete();
229
230 BooleanSubscription bs = new BooleanSubscription();
231 p.onSubscribe(bs);
232
233 p.onNext(1);
234 List<Throwable> errors = TestHelper.trackPluginErrors();
235 try {
236 p.onError(new TestException());
237
238 TestHelper.assertUndeliverable(errors, 0, TestException.class);
239 } finally {
240 RxJavaPlugins.reset();
241 }
242 p.onComplete();
243
244 p.test().assertResult();
245
246 assertNull(p.getThrowable());
247 assertTrue(p.hasComplete());
248 assertFalse(p.hasThrowable());
249 }
250
251 @Test
252 public void onErrorStatePeeking() {
253 UnicastProcessor<Object> p = UnicastProcessor.create();
254
255 assertFalse(p.hasComplete());
256 assertFalse(p.hasThrowable());
257 assertNull(p.getThrowable());
258
259 TestException ex = new TestException();
260 p.onError(ex);
261
262 assertFalse(p.hasComplete());
263 assertTrue(p.hasThrowable());
264 assertSame(ex, p.getThrowable());
265 }
266
267 @Test
268 public void rejectSyncFusion() {
269 UnicastProcessor<Object> p = UnicastProcessor.create();
270
271 TestSubscriberEx<Object> ts = new TestSubscriberEx<>().setInitialFusionMode(QueueFuseable.SYNC);
272
273 p.subscribe(ts);
274
275 ts.assertFusionMode(QueueFuseable.NONE);
276 }
277
278 @Test
279 public void cancelOnArrival() {
280 UnicastProcessor.create()
281 .test(0L, true)
282 .assertEmpty();
283 }
284
285 @Test
286 public void multiSubscriber() {
287 UnicastProcessor<Object> p = UnicastProcessor.create();
288
289 TestSubscriber<Object> ts = p.test();
290
291 p.test()
292 .assertFailure(IllegalStateException.class);
293
294 p.onNext(1);
295 p.onComplete();
296
297 ts.assertResult(1);
298 }
299
300 @Test
301 public void fusedDrainCancel() {
302 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
303 final UnicastProcessor<Object> p = UnicastProcessor.create();
304
305 final TestSubscriberEx<Object> ts = new TestSubscriberEx<>().setInitialFusionMode(QueueFuseable.ANY);
306
307 p.subscribe(ts);
308
309 Runnable r1 = new Runnable() {
310 @Override
311 public void run() {
312 p.onNext(1);
313 }
314 };
315
316 Runnable r2 = new Runnable() {
317 @Override
318 public void run() {
319 ts.cancel();
320 }
321 };
322
323 TestHelper.race(r1, r2);
324 }
325 }
326
327 @Test
328 public void subscribeRace() {
329 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
330 final UnicastProcessor<Integer> up = UnicastProcessor.create();
331
332 final TestSubscriberEx<Integer> ts1 = new TestSubscriberEx<>();
333 final TestSubscriberEx<Integer> ts2 = new TestSubscriberEx<>();
334
335 Runnable r1 = new Runnable() {
336 @Override
337 public void run() {
338 up.subscribe(ts1);
339 }
340 };
341
342 Runnable r2 = new Runnable() {
343 @Override
344 public void run() {
345 up.subscribe(ts2);
346 }
347 };
348
349 TestHelper.race(r1, r2);
350
351 if (ts1.errors().size() == 0) {
352 ts2.assertFailure(IllegalStateException.class);
353 } else
354 if (ts2.errors().size() == 0) {
355 ts1.assertFailure(IllegalStateException.class);
356 } else {
357 fail("Neither TestObserver failed");
358 }
359 }
360 }
361
362 @Test
363 public void hasObservers() {
364 UnicastProcessor<Integer> up = UnicastProcessor.create();
365
366 assertFalse(up.hasSubscribers());
367
368 TestSubscriber<Integer> ts = up.test();
369
370 assertTrue(up.hasSubscribers());
371
372 ts.cancel();
373
374 assertFalse(up.hasSubscribers());
375 }
376
377 @Test
378 public void drainFusedFailFast() {
379 UnicastProcessor<Integer> up = UnicastProcessor.create(false);
380
381 TestSubscriberEx<Integer> ts = up.to(TestHelper.<Integer>testSubscriber(1, QueueFuseable.ANY, false));
382
383 up.done = true;
384 up.drainFused(ts);
385
386 ts.assertResult();
387 }
388
389 @Test
390 public void drainFusedFailFastEmpty() {
391 UnicastProcessor<Integer> up = UnicastProcessor.create(false);
392
393 TestSubscriberEx<Integer> ts = up.to(TestHelper.<Integer>testSubscriber(1, QueueFuseable.ANY, false));
394
395 up.drainFused(ts);
396
397 ts.assertEmpty();
398 }
399
400 @Test
401 public void checkTerminatedFailFastEmpty() {
402 UnicastProcessor<Integer> up = UnicastProcessor.create(false);
403
404 TestSubscriberEx<Integer> ts = up.to(TestHelper.<Integer>testSubscriber(1, QueueFuseable.ANY, false));
405
406 up.checkTerminated(true, true, false, ts, up.queue);
407
408 ts.assertEmpty();
409 }
410
411 @Test
412 public void alreadyCancelled() {
413 UnicastProcessor<Integer> up = UnicastProcessor.create(false);
414
415 up.test().cancel();
416
417 BooleanSubscription bs = new BooleanSubscription();
418 up.onSubscribe(bs);
419
420 assertTrue(bs.isCancelled());
421
422 List<Throwable> errors = TestHelper.trackPluginErrors();
423 try {
424 up.onError(new TestException());
425
426 TestHelper.assertUndeliverable(errors, 0, TestException.class);
427 } finally {
428 RxJavaPlugins.reset();
429 }
430 }
431
432 @Test
433 public void unicastSubscriptionBadRequest() {
434 UnicastProcessor<Integer> up = UnicastProcessor.create(false);
435
436 UnicastProcessor<Integer>.UnicastQueueSubscription usc = (UnicastProcessor<Integer>.UnicastQueueSubscription)up.wip;
437
438 List<Throwable> errors = TestHelper.trackPluginErrors();
439 try {
440 usc.request(-1);
441 TestHelper.assertError(errors, 0, IllegalArgumentException.class);
442 } finally {
443 RxJavaPlugins.reset();
444 }
445 }
446
447 @Test
448 public void fusedNoConcurrentCleanDueToCancel() {
449 for (int j = 0; j < TestHelper.RACE_LONG_LOOPS; j++) {
450 List<Throwable> errors = TestHelper.trackPluginErrors();
451 try {
452 final UnicastProcessor<Integer> up = UnicastProcessor.create();
453
454 TestObserver<Integer> to = up
455 .observeOn(Schedulers.io())
456 .map(Functions.<Integer>identity())
457 .observeOn(Schedulers.single())
458 .firstOrError()
459 .test();
460
461 for (int i = 0; up.hasSubscribers(); i++) {
462 up.onNext(i);
463 }
464
465 to
466 .awaitDone(5, TimeUnit.SECONDS)
467 ;
468
469 if (!errors.isEmpty()) {
470 throw new CompositeException(errors);
471 }
472
473 to.assertResult(0);
474 } finally {
475 RxJavaPlugins.reset();
476 }
477 }
478 }
479 }