Debian Codegraph @

src/test/java/io/reactivex/rxjava3/disposables/CompositeDisposableTest.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.disposables;
15
16 import static org.junit.Assert.*;
17
18 import java.io.IOException;
19 import java.util.*;
20 import java.util.concurrent.CountDownLatch;
21 import java.util.concurrent.atomic.AtomicInteger;
22
23 import org.junit.Test;
24
25 import io.reactivex.rxjava3.core.RxJavaTest;
26 import io.reactivex.rxjava3.exceptions.CompositeException;
27 import io.reactivex.rxjava3.functions.Action;
28 import io.reactivex.rxjava3.testsupport.TestHelper;
29
30 public class CompositeDisposableTest extends RxJavaTest {
31
32 @Test
33 public void success() {
34 final AtomicInteger counter = new AtomicInteger();
35 CompositeDisposable cd = new CompositeDisposable();
36 cd.add(Disposable.fromRunnable(new Runnable() {
37
38 @Override
39 public void run() {
40 counter.incrementAndGet();
41 }
42
43 }));
44
45 cd.add(Disposable.fromRunnable(new Runnable() {
46
47 @Override
48 public void run() {
49 counter.incrementAndGet();
50 }
51 }));
52
53 cd.dispose();
54
55 assertEquals(2, counter.get());
56 }
57
58 @Test
59 public void shouldUnsubscribeAll() throws InterruptedException {
60 final AtomicInteger counter = new AtomicInteger();
61 final CompositeDisposable cd = new CompositeDisposable();
62
63 final int count = 10;
64 final CountDownLatch start = new CountDownLatch(1);
65 for (int i = 0; i < count; i++) {
66 cd.add(Disposable.fromRunnable(new Runnable() {
67
68 @Override
69 public void run() {
70 counter.incrementAndGet();
71 }
72 }));
73 }
74
75 final List<Thread> threads = new ArrayList<>();
76 for (int i = 0; i < count; i++) {
77 final Thread t = new Thread() {
78 @Override
79 public void run() {
80 try {
81 start.await();
82 cd.dispose();
83 } catch (final InterruptedException e) {
84 fail(e.getMessage());
85 }
86 }
87 };
88 t.start();
89 threads.add(t);
90 }
91
92 start.countDown();
93 for (final Thread t : threads) {
94 t.join();
95 }
96
97 assertEquals(count, counter.get());
98 }
99
100 @Test
101 public void exception() {
102 final AtomicInteger counter = new AtomicInteger();
103 CompositeDisposable cd = new CompositeDisposable();
104 cd.add(Disposable.fromRunnable(new Runnable() {
105
106 @Override
107 public void run() {
108 throw new RuntimeException("failed on first one");
109 }
110
111 }));
112
113 cd.add(Disposable.fromRunnable(new Runnable() {
114
115 @Override
116 public void run() {
117 counter.incrementAndGet();
118 }
119
120 }));
121
122 try {
123 cd.dispose();
124 fail("Expecting an exception");
125 } catch (RuntimeException e) {
126 // we expect this
127 assertEquals(e.getMessage(), "failed on first one");
128 }
129
130 // we should still have disposed to the second one
131 assertEquals(1, counter.get());
132 }
133
134 @Test
135 public void compositeException() {
136 final AtomicInteger counter = new AtomicInteger();
137 CompositeDisposable cd = new CompositeDisposable();
138 cd.add(Disposable.fromRunnable(new Runnable() {
139
140 @Override
141 public void run() {
142 throw new RuntimeException("failed on first one");
143 }
144
145 }));
146
147 cd.add(Disposable.fromRunnable(new Runnable() {
148
149 @Override
150 public void run() {
151 throw new RuntimeException("failed on second one too");
152 }
153 }));
154
155 cd.add(Disposable.fromRunnable(new Runnable() {
156
157 @Override
158 public void run() {
159 counter.incrementAndGet();
160 }
161
162 }));
163
164 try {
165 cd.dispose();
166 fail("Expecting an exception");
167 } catch (CompositeException e) {
168 // we expect this
169 assertEquals(e.getExceptions().size(), 2);
170 }
171
172 // we should still have disposed to the second one
173 assertEquals(1, counter.get());
174 }
175
176 @Test
177 public void removeUnsubscribes() {
178 Disposable d1 = Disposable.empty();
179 Disposable d2 = Disposable.empty();
180
181 CompositeDisposable cd = new CompositeDisposable();
182 cd.add(d1);
183 cd.add(d2);
184
185 cd.remove(d1);
186
187 assertTrue(d1.isDisposed());
188 assertFalse(d2.isDisposed());
189 }
190
191 @Test
192 public void clear() {
193 Disposable d1 = Disposable.empty();
194 Disposable d2 = Disposable.empty();
195
196 CompositeDisposable cd = new CompositeDisposable();
197 cd.add(d1);
198 cd.add(d2);
199
200 assertFalse(d1.isDisposed());
201 assertFalse(d2.isDisposed());
202
203 cd.clear();
204
205 assertTrue(d1.isDisposed());
206 assertTrue(d2.isDisposed());
207 assertFalse(cd.isDisposed());
208
209 Disposable d3 = Disposable.empty();
210
211 cd.add(d3);
212 cd.dispose();
213
214 assertTrue(d3.isDisposed());
215 assertTrue(cd.isDisposed());
216 }
217
218 @Test
219 public void unsubscribeIdempotence() {
220 final AtomicInteger counter = new AtomicInteger();
221 CompositeDisposable cd = new CompositeDisposable();
222 cd.add(Disposable.fromRunnable(new Runnable() {
223
224 @Override
225 public void run() {
226 counter.incrementAndGet();
227 }
228
229 }));
230
231 cd.dispose();
232 cd.dispose();
233 cd.dispose();
234
235 // we should have only disposed once
236 assertEquals(1, counter.get());
237 }
238
239 @Test
240 public void unsubscribeIdempotenceConcurrently()
241 throws InterruptedException {
242 final AtomicInteger counter = new AtomicInteger();
243 final CompositeDisposable cd = new CompositeDisposable();
244
245 final int count = 10;
246 final CountDownLatch start = new CountDownLatch(1);
247 cd.add(Disposable.fromRunnable(new Runnable() {
248
249 @Override
250 public void run() {
251 counter.incrementAndGet();
252 }
253
254 }));
255
256 final List<Thread> threads = new ArrayList<>();
257 for (int i = 0; i < count; i++) {
258 final Thread t = new Thread() {
259 @Override
260 public void run() {
261 try {
262 start.await();
263 cd.dispose();
264 } catch (final InterruptedException e) {
265 fail(e.getMessage());
266 }
267 }
268 };
269 t.start();
270 threads.add(t);
271 }
272
273 start.countDown();
274 for (final Thread t : threads) {
275 t.join();
276 }
277
278 // we should have only disposed once
279 assertEquals(1, counter.get());
280 }
281
282 @Test
283 public void tryRemoveIfNotIn() {
284 CompositeDisposable cd = new CompositeDisposable();
285
286 CompositeDisposable cd1 = new CompositeDisposable();
287 CompositeDisposable cd2 = new CompositeDisposable();
288
289 cd.add(cd1);
290 cd.remove(cd1);
291 cd.add(cd2);
292
293 cd.remove(cd1); // try removing agian
294 }
295
296 @Test(expected = NullPointerException.class)
297 public void addingNullDisposableIllegal() {
298 CompositeDisposable cd = new CompositeDisposable();
299 cd.add(null);
300 }
301
302 @Test
303 public void initializeVarargs() {
304 Disposable d1 = Disposable.empty();
305 Disposable d2 = Disposable.empty();
306
307 CompositeDisposable cd = new CompositeDisposable(d1, d2);
308
309 assertEquals(2, cd.size());
310
311 cd.clear();
312
313 assertEquals(0, cd.size());
314
315 assertTrue(d1.isDisposed());
316 assertTrue(d2.isDisposed());
317
318 Disposable d3 = Disposable.empty();
319 Disposable d4 = Disposable.empty();
320
321 cd = new CompositeDisposable(d3, d4);
322
323 cd.dispose();
324
325 assertTrue(d3.isDisposed());
326 assertTrue(d4.isDisposed());
327
328 assertEquals(0, cd.size());
329 }
330
331 @Test
332 public void initializeIterable() {
333 Disposable d1 = Disposable.empty();
334 Disposable d2 = Disposable.empty();
335
336 CompositeDisposable cd = new CompositeDisposable(Arrays.asList(d1, d2));
337
338 assertEquals(2, cd.size());
339
340 cd.clear();
341
342 assertEquals(0, cd.size());
343
344 assertTrue(d1.isDisposed());
345 assertTrue(d2.isDisposed());
346
347 Disposable d3 = Disposable.empty();
348 Disposable d4 = Disposable.empty();
349
350 cd = new CompositeDisposable(Arrays.asList(d3, d4));
351
352 assertEquals(2, cd.size());
353
354 cd.dispose();
355
356 assertTrue(d3.isDisposed());
357 assertTrue(d4.isDisposed());
358
359 assertEquals(0, cd.size());
360 }
361
362 @Test
363 public void addAll() {
364 CompositeDisposable cd = new CompositeDisposable();
365
366 Disposable d1 = Disposable.empty();
367 Disposable d2 = Disposable.empty();
368 Disposable d3 = Disposable.empty();
369
370 cd.addAll(d1, d2);
371 cd.addAll(d3);
372
373 assertFalse(d1.isDisposed());
374 assertFalse(d2.isDisposed());
375 assertFalse(d3.isDisposed());
376
377 cd.clear();
378
379 assertTrue(d1.isDisposed());
380 assertTrue(d2.isDisposed());
381
382 d1 = Disposable.empty();
383 d2 = Disposable.empty();
384
385 cd = new CompositeDisposable();
386
387 cd.addAll(d1, d2);
388
389 assertFalse(d1.isDisposed());
390 assertFalse(d2.isDisposed());
391
392 cd.dispose();
393
394 assertTrue(d1.isDisposed());
395 assertTrue(d2.isDisposed());
396
397 assertEquals(0, cd.size());
398
399 cd.clear();
400
401 assertEquals(0, cd.size());
402 }
403
404 @Test
405 public void addAfterDisposed() {
406 CompositeDisposable cd = new CompositeDisposable();
407 cd.dispose();
408
409 Disposable d1 = Disposable.empty();
410
411 assertFalse(cd.add(d1));
412
413 assertTrue(d1.isDisposed());
414
415 d1 = Disposable.empty();
416 Disposable d2 = Disposable.empty();
417
418 assertFalse(cd.addAll(d1, d2));
419
420 assertTrue(d1.isDisposed());
421 assertTrue(d2.isDisposed());
422
423 }
424
425 @Test
426 public void delete() {
427
428 CompositeDisposable cd = new CompositeDisposable();
429
430 Disposable d1 = Disposable.empty();
431
432 assertFalse(cd.delete(d1));
433
434 Disposable d2 = Disposable.empty();
435
436 cd.add(d2);
437
438 assertFalse(cd.delete(d1));
439
440 cd.dispose();
441
442 assertFalse(cd.delete(d1));
443 }
444
445 @Test
446 public void disposeRace() {
447 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
448 final CompositeDisposable cd = new CompositeDisposable();
449
450 Runnable run = new Runnable() {
451 @Override
452 public void run() {
453 cd.dispose();
454 }
455 };
456
457 TestHelper.race(run, run);
458 }
459 }
460
461 @Test
462 public void addRace() {
463 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
464 final CompositeDisposable cd = new CompositeDisposable();
465
466 Runnable run = new Runnable() {
467 @Override
468 public void run() {
469 cd.add(Disposable.empty());
470 }
471 };
472
473 TestHelper.race(run, run);
474 }
475 }
476
477 @Test
478 public void addAllRace() {
479 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
480 final CompositeDisposable cd = new CompositeDisposable();
481
482 Runnable run = new Runnable() {
483 @Override
484 public void run() {
485 cd.addAll(Disposable.empty());
486 }
487 };
488
489 TestHelper.race(run, run);
490 }
491 }
492
493 @Test
494 public void removeRace() {
495 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
496 final CompositeDisposable cd = new CompositeDisposable();
497
498 final Disposable d1 = Disposable.empty();
499
500 cd.add(d1);
501
502 Runnable run = new Runnable() {
503 @Override
504 public void run() {
505 cd.remove(d1);
506 }
507 };
508
509 TestHelper.race(run, run);
510 }
511 }
512
513 @Test
514 public void deleteRace() {
515 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
516 final CompositeDisposable cd = new CompositeDisposable();
517
518 final Disposable d1 = Disposable.empty();
519
520 cd.add(d1);
521
522 Runnable run = new Runnable() {
523 @Override
524 public void run() {
525 cd.delete(d1);
526 }
527 };
528
529 TestHelper.race(run, run);
530 }
531 }
532
533 @Test
534 public void clearRace() {
535 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
536 final CompositeDisposable cd = new CompositeDisposable();
537
538 final Disposable d1 = Disposable.empty();
539
540 cd.add(d1);
541
542 Runnable run = new Runnable() {
543 @Override
544 public void run() {
545 cd.clear();
546 }
547 };
548
549 TestHelper.race(run, run);
550 }
551 }
552
553 @Test
554 public void addDisposeRace() {
555 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
556 final CompositeDisposable cd = new CompositeDisposable();
557
558 Runnable run = new Runnable() {
559 @Override
560 public void run() {
561 cd.dispose();
562 }
563 };
564
565 Runnable run2 = new Runnable() {
566 @Override
567 public void run() {
568 cd.add(Disposable.empty());
569 }
570 };
571
572 TestHelper.race(run, run2);
573 }
574 }
575
576 @Test
577 public void addAllDisposeRace() {
578 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
579 final CompositeDisposable cd = new CompositeDisposable();
580
581 Runnable run = new Runnable() {
582 @Override
583 public void run() {
584 cd.dispose();
585 }
586 };
587
588 Runnable run2 = new Runnable() {
589 @Override
590 public void run() {
591 cd.addAll(Disposable.empty());
592 }
593 };
594
595 TestHelper.race(run, run2);
596 }
597 }
598
599 @Test
600 public void removeDisposeRace() {
601 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
602 final CompositeDisposable cd = new CompositeDisposable();
603
604 final Disposable d1 = Disposable.empty();
605
606 cd.add(d1);
607
608 Runnable run = new Runnable() {
609 @Override
610 public void run() {
611 cd.dispose();
612 }
613 };
614
615 Runnable run2 = new Runnable() {
616 @Override
617 public void run() {
618 cd.remove(d1);
619 }
620 };
621
622 TestHelper.race(run, run2);
623 }
624 }
625
626 @Test
627 public void deleteDisposeRace() {
628 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
629 final CompositeDisposable cd = new CompositeDisposable();
630
631 final Disposable d1 = Disposable.empty();
632
633 cd.add(d1);
634
635 Runnable run = new Runnable() {
636 @Override
637 public void run() {
638 cd.dispose();
639 }
640 };
641
642 Runnable run2 = new Runnable() {
643 @Override
644 public void run() {
645 cd.delete(d1);
646 }
647 };
648
649 TestHelper.race(run, run2);
650 }
651 }
652
653 @Test
654 public void clearDisposeRace() {
655 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
656 final CompositeDisposable cd = new CompositeDisposable();
657
658 final Disposable d1 = Disposable.empty();
659
660 cd.add(d1);
661
662 Runnable run = new Runnable() {
663 @Override
664 public void run() {
665 cd.dispose();
666 }
667 };
668
669 Runnable run2 = new Runnable() {
670 @Override
671 public void run() {
672 cd.clear();
673 }
674 };
675
676 TestHelper.race(run, run2);
677 }
678 }
679
680 @Test
681 public void sizeDisposeRace() {
682 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
683 final CompositeDisposable cd = new CompositeDisposable();
684
685 final Disposable d1 = Disposable.empty();
686
687 cd.add(d1);
688
689 Runnable run = new Runnable() {
690 @Override
691 public void run() {
692 cd.dispose();
693 }
694 };
695
696 Runnable run2 = new Runnable() {
697 @Override
698 public void run() {
699 cd.size();
700 }
701 };
702
703 TestHelper.race(run, run2);
704 }
705 }
706
707 @Test
708 public void disposeThrowsIAE() {
709 CompositeDisposable cd = new CompositeDisposable();
710
711 cd.add(Disposable.fromAction(new Action() {
712 @Override
713 public void run() throws Exception {
714 throw new IllegalArgumentException();
715 }
716 }));
717
718 Disposable d1 = Disposable.empty();
719
720 cd.add(d1);
721
722 try {
723 cd.dispose();
724 fail("Failed to throw");
725 } catch (IllegalArgumentException ex) {
726 // expected
727 }
728
729 assertTrue(d1.isDisposed());
730 }
731
732 @Test
733 public void disposeThrowsError() {
734 CompositeDisposable cd = new CompositeDisposable();
735
736 cd.add(Disposable.fromAction(new Action() {
737 @Override
738 public void run() throws Exception {
739 throw new AssertionError();
740 }
741 }));
742
743 Disposable d1 = Disposable.empty();
744
745 cd.add(d1);
746
747 try {
748 cd.dispose();
749 fail("Failed to throw");
750 } catch (AssertionError ex) {
751 // expected
752 }
753
754 assertTrue(d1.isDisposed());
755 }
756
757 @Test
758 public void disposeThrowsCheckedException() {
759 CompositeDisposable cd = new CompositeDisposable();
760
761 cd.add(Disposable.fromAction(new Action() {
762 @Override
763 public void run() throws Exception {
764 throw new IOException();
765 }
766 }));
767
768 Disposable d1 = Disposable.empty();
769
770 cd.add(d1);
771
772 try {
773 cd.dispose();
774 fail("Failed to throw");
775 } catch (RuntimeException ex) {
776 // expected
777 if (!(ex.getCause() instanceof IOException)) {
778 fail(ex.toString() + " should have thrown RuntimeException(IOException)");
779 }
780 }
781
782 assertTrue(d1.isDisposed());
783 }
784
785 @SuppressWarnings("unchecked")
786 static <E extends Throwable> void throwSneaky() throws E {
787 throw (E)new IOException();
788 }
789
790 @Test
791 public void disposeThrowsCheckedExceptionSneaky() {
792 CompositeDisposable cd = new CompositeDisposable();
793
794 cd.add(new Disposable() {
795 @Override
796 public void dispose() {
797 CompositeDisposableTest.<RuntimeException>throwSneaky();
798 }
799
800 @Override
801 public boolean isDisposed() {
802 // TODO Auto-generated method stub
803 return false;
804 }
805 });
806
807 Disposable d1 = Disposable.empty();
808
809 cd.add(d1);
810
811 try {
812 cd.dispose();
813 fail("Failed to throw");
814 } catch (RuntimeException ex) {
815 // expected
816 if (!(ex.getCause() instanceof IOException)) {
817 fail(ex.toString() + " should have thrown RuntimeException(IOException)");
818 }
819 }
820
821 assertTrue(d1.isDisposed());
822 }
823 }