Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/disposables/ListCompositeDisposableTest.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.disposables;
15
16 import static org.junit.Assert.*;
17
18 import java.util.*;
19
20 import org.junit.Test;
21
22 import io.reactivex.rxjava3.core.RxJavaTest;
23 import io.reactivex.rxjava3.disposables.*;
24 import io.reactivex.rxjava3.exceptions.*;
25 import io.reactivex.rxjava3.testsupport.TestHelper;
26
27 public class ListCompositeDisposableTest extends RxJavaTest {
28
29 @Test
30 public void constructorAndAddVarargs() {
31 Disposable d1 = Disposable.empty();
32 Disposable d2 = Disposable.empty();
33
34 ListCompositeDisposable lcd = new ListCompositeDisposable(d1, d2);
35
36 lcd.clear();
37
38 assertFalse(lcd.isDisposed());
39
40 assertTrue(d1.isDisposed());
41 assertTrue(d2.isDisposed());
42
43 d1 = Disposable.empty();
44 d2 = Disposable.empty();
45
46 lcd.addAll(d1, d2);
47
48 lcd.dispose();
49
50 assertTrue(lcd.isDisposed());
51 assertTrue(d1.isDisposed());
52 assertTrue(d2.isDisposed());
53 }
54
55 @Test
56 public void constructorIterable() {
57 Disposable d1 = Disposable.empty();
58 Disposable d2 = Disposable.empty();
59
60 ListCompositeDisposable lcd = new ListCompositeDisposable(Arrays.asList(d1, d2));
61
62 lcd.clear();
63
64 assertFalse(lcd.isDisposed());
65
66 assertTrue(d1.isDisposed());
67 assertTrue(d2.isDisposed());
68
69 d1 = Disposable.empty();
70 d2 = Disposable.empty();
71
72 lcd.add(d1);
73 lcd.addAll(d2);
74
75 lcd.dispose();
76
77 assertTrue(lcd.isDisposed());
78 assertTrue(d1.isDisposed());
79 assertTrue(d2.isDisposed());
80 }
81
82 @Test
83 public void empty() {
84 ListCompositeDisposable lcd = new ListCompositeDisposable();
85
86 assertFalse(lcd.isDisposed());
87
88 lcd.clear();
89
90 assertFalse(lcd.isDisposed());
91
92 lcd.dispose();
93
94 lcd.dispose();
95
96 lcd.clear();
97
98 assertTrue(lcd.isDisposed());
99 }
100
101 @Test
102 public void afterDispose() {
103 ListCompositeDisposable lcd = new ListCompositeDisposable();
104 lcd.dispose();
105
106 Disposable d = Disposable.empty();
107 assertFalse(lcd.add(d));
108 assertTrue(d.isDisposed());
109
110 d = Disposable.empty();
111 assertFalse(lcd.addAll(d));
112 assertTrue(d.isDisposed());
113 }
114
115 @Test
116 public void disposeThrows() {
117 Disposable d = new Disposable() {
118
119 @Override
120 public void dispose() {
121 throw new TestException();
122 }
123
124 @Override
125 public boolean isDisposed() {
126 return false;
127 }
128
129 };
130
131 ListCompositeDisposable lcd = new ListCompositeDisposable(d, d);
132
133 try {
134 lcd.dispose();
135 fail("Should have thrown!");
136 } catch (CompositeException ex) {
137 List<Throwable> list = ex.getExceptions();
138 TestHelper.assertError(list, 0, TestException.class);
139 TestHelper.assertError(list, 1, TestException.class);
140 }
141
142 lcd = new ListCompositeDisposable(d);
143
144 try {
145 lcd.dispose();
146 fail("Should have thrown!");
147 } catch (TestException ex) {
148 // expected
149 }
150 }
151
152 @Test
153 public void remove() {
154 ListCompositeDisposable lcd = new ListCompositeDisposable();
155 Disposable d = Disposable.empty();
156
157 lcd.add(d);
158
159 assertTrue(lcd.delete(d));
160
161 assertFalse(d.isDisposed());
162
163 lcd.add(d);
164
165 assertTrue(lcd.remove(d));
166
167 assertTrue(d.isDisposed());
168
169 assertFalse(lcd.remove(d));
170
171 assertFalse(lcd.delete(d));
172
173 lcd = new ListCompositeDisposable();
174
175 assertFalse(lcd.remove(d));
176
177 assertFalse(lcd.delete(d));
178 }
179
180 @Test
181 public void disposeRace() {
182 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
183 final ListCompositeDisposable cd = new ListCompositeDisposable();
184
185 Runnable run = new Runnable() {
186 @Override
187 public void run() {
188 cd.dispose();
189 }
190 };
191
192 TestHelper.race(run, run);
193 }
194 }
195
196 @Test
197 public void addRace() {
198 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
199 final ListCompositeDisposable cd = new ListCompositeDisposable();
200
201 Runnable run = new Runnable() {
202 @Override
203 public void run() {
204 cd.add(Disposable.empty());
205 }
206 };
207
208 TestHelper.race(run, run);
209 }
210 }
211
212 @Test
213 public void addAllRace() {
214 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
215 final ListCompositeDisposable cd = new ListCompositeDisposable();
216
217 Runnable run = new Runnable() {
218 @Override
219 public void run() {
220 cd.addAll(Disposable.empty());
221 }
222 };
223
224 TestHelper.race(run, run);
225 }
226 }
227
228 @Test
229 public void removeRace() {
230 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
231 final ListCompositeDisposable cd = new ListCompositeDisposable();
232
233 final Disposable d1 = Disposable.empty();
234
235 cd.add(d1);
236
237 Runnable run = new Runnable() {
238 @Override
239 public void run() {
240 cd.remove(d1);
241 }
242 };
243
244 TestHelper.race(run, run);
245 }
246 }
247
248 @Test
249 public void deleteRace() {
250 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
251 final ListCompositeDisposable cd = new ListCompositeDisposable();
252
253 final Disposable d1 = Disposable.empty();
254
255 cd.add(d1);
256
257 Runnable run = new Runnable() {
258 @Override
259 public void run() {
260 cd.delete(d1);
261 }
262 };
263
264 TestHelper.race(run, run);
265 }
266 }
267
268 @Test
269 public void clearRace() {
270 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
271 final ListCompositeDisposable cd = new ListCompositeDisposable();
272
273 final Disposable d1 = Disposable.empty();
274
275 cd.add(d1);
276
277 Runnable run = new Runnable() {
278 @Override
279 public void run() {
280 cd.clear();
281 }
282 };
283
284 TestHelper.race(run, run);
285 }
286 }
287
288 @Test
289 public void addDisposeRace() {
290 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
291 final ListCompositeDisposable cd = new ListCompositeDisposable();
292
293 Runnable run = new Runnable() {
294 @Override
295 public void run() {
296 cd.dispose();
297 }
298 };
299
300 Runnable run2 = new Runnable() {
301 @Override
302 public void run() {
303 cd.add(Disposable.empty());
304 }
305 };
306
307 TestHelper.race(run, run2);
308 }
309 }
310
311 @Test
312 public void addAllDisposeRace() {
313 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
314 final ListCompositeDisposable cd = new ListCompositeDisposable();
315
316 Runnable run = new Runnable() {
317 @Override
318 public void run() {
319 cd.dispose();
320 }
321 };
322
323 Runnable run2 = new Runnable() {
324 @Override
325 public void run() {
326 cd.addAll(Disposable.empty());
327 }
328 };
329
330 TestHelper.race(run, run2);
331 }
332 }
333
334 @Test
335 public void removeDisposeRace() {
336 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
337 final ListCompositeDisposable cd = new ListCompositeDisposable();
338
339 final Disposable d1 = Disposable.empty();
340
341 cd.add(d1);
342
343 Runnable run = new Runnable() {
344 @Override
345 public void run() {
346 cd.dispose();
347 }
348 };
349
350 Runnable run2 = new Runnable() {
351 @Override
352 public void run() {
353 cd.remove(d1);
354 }
355 };
356
357 TestHelper.race(run, run2);
358 }
359 }
360
361 @Test
362 public void deleteDisposeRace() {
363 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
364 final ListCompositeDisposable cd = new ListCompositeDisposable();
365
366 final Disposable d1 = Disposable.empty();
367
368 cd.add(d1);
369
370 Runnable run = new Runnable() {
371 @Override
372 public void run() {
373 cd.dispose();
374 }
375 };
376
377 Runnable run2 = new Runnable() {
378 @Override
379 public void run() {
380 cd.delete(d1);
381 }
382 };
383
384 TestHelper.race(run, run2);
385 }
386 }
387
388 @Test
389 public void clearDisposeRace() {
390 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
391 final ListCompositeDisposable cd = new ListCompositeDisposable();
392
393 final Disposable d1 = Disposable.empty();
394
395 cd.add(d1);
396
397 Runnable run = new Runnable() {
398 @Override
399 public void run() {
400 cd.dispose();
401 }
402 };
403
404 Runnable run2 = new Runnable() {
405 @Override
406 public void run() {
407 cd.clear();
408 }
409 };
410
411 TestHelper.race(run, run2);
412 }
413 }
414 }