Debian Codegraph @

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