Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/schedulers/ScheduledRunnableTest.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.schedulers;
15
16 import static org.junit.Assert.*;
17
18 import java.lang.Thread.UncaughtExceptionHandler;
19 import java.util.List;
20 import java.util.concurrent.FutureTask;
21 import java.util.concurrent.atomic.*;
22
23 import org.junit.Test;
24
25 import io.reactivex.rxjava3.core.RxJavaTest;
26 import io.reactivex.rxjava3.disposables.CompositeDisposable;
27 import io.reactivex.rxjava3.exceptions.TestException;
28 import io.reactivex.rxjava3.internal.functions.Functions;
29 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
30 import io.reactivex.rxjava3.testsupport.TestHelper;
31
32 public class ScheduledRunnableTest extends RxJavaTest {
33
34 @Test
35 public void dispose() {
36 CompositeDisposable set = new CompositeDisposable();
37 ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, set);
38 set.add(run);
39
40 assertFalse(run.isDisposed());
41
42 set.dispose();
43
44 assertTrue(run.isDisposed());
45 }
46
47 @Test
48 public void disposeRun() {
49 CompositeDisposable set = new CompositeDisposable();
50 ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, set);
51 set.add(run);
52
53 assertFalse(run.isDisposed());
54
55 run.dispose();
56 run.dispose();
57
58 assertTrue(run.isDisposed());
59 }
60
61 @Test
62 public void setFutureCancelRace() {
63 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
64 CompositeDisposable set = new CompositeDisposable();
65 final ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, set);
66 set.add(run);
67
68 final FutureTask<Object> ft = new FutureTask<>(Functions.EMPTY_RUNNABLE, 0);
69
70 Runnable r1 = new Runnable() {
71 @Override
72 public void run() {
73 run.setFuture(ft);
74 }
75 };
76
77 Runnable r2 = new Runnable() {
78 @Override
79 public void run() {
80 run.dispose();
81 }
82 };
83
84 TestHelper.race(r1, r2);
85
86 assertEquals(0, set.size());
87 }
88 }
89
90 @Test
91 public void setFutureRunRace() {
92 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
93 CompositeDisposable set = new CompositeDisposable();
94 final ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, set);
95 set.add(run);
96
97 final FutureTask<Object> ft = new FutureTask<>(Functions.EMPTY_RUNNABLE, 0);
98
99 Runnable r1 = new Runnable() {
100 @Override
101 public void run() {
102 run.setFuture(ft);
103 }
104 };
105
106 Runnable r2 = new Runnable() {
107 @Override
108 public void run() {
109 run.run();
110 }
111 };
112
113 TestHelper.race(r1, r2);
114
115 assertEquals(0, set.size());
116 }
117 }
118
119 @Test
120 public void disposeRace() {
121 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
122 CompositeDisposable set = new CompositeDisposable();
123 final ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, set);
124 set.add(run);
125
126 Runnable r1 = new Runnable() {
127 @Override
128 public void run() {
129 run.dispose();
130 }
131 };
132
133 TestHelper.race(r1, r1);
134
135 assertEquals(0, set.size());
136 }
137 }
138
139 @Test
140 public void runDispose() {
141 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
142 CompositeDisposable set = new CompositeDisposable();
143 final ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, set);
144 set.add(run);
145
146 Runnable r1 = new Runnable() {
147 @Override
148 public void run() {
149 run.call();
150 }
151 };
152
153 Runnable r2 = new Runnable() {
154 @Override
155 public void run() {
156 run.dispose();
157 }
158 };
159
160 TestHelper.race(r1, r2);
161
162 assertEquals(0, set.size());
163 }
164 }
165
166 @Test
167 public void pluginCrash() {
168 Thread.currentThread().setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
169 @Override
170 public void uncaughtException(Thread t, Throwable e) {
171 throw new TestException("Second");
172 }
173 });
174
175 CompositeDisposable set = new CompositeDisposable();
176 final ScheduledRunnable run = new ScheduledRunnable(new Runnable() {
177 @Override
178 public void run() {
179 throw new TestException("First");
180 }
181 }, set);
182 set.add(run);
183
184 try {
185 run.run();
186
187 fail("Should have thrown!");
188 } catch (TestException ex) {
189 assertEquals("Second", ex.getMessage());
190 } finally {
191 Thread.currentThread().setUncaughtExceptionHandler(null);
192 }
193 assertTrue(run.isDisposed());
194
195 assertEquals(0, set.size());
196 }
197
198 @Test
199 public void crashReported() {
200 List<Throwable> errors = TestHelper.trackPluginErrors();
201 try {
202 CompositeDisposable set = new CompositeDisposable();
203 final ScheduledRunnable run = new ScheduledRunnable(new Runnable() {
204 @Override
205 public void run() {
206 throw new TestException("First");
207 }
208 }, set);
209 set.add(run);
210
211 try {
212 run.run();
213 fail("Should have thrown!");
214 } catch (TestException expected) {
215 // expected
216 }
217
218 assertTrue(run.isDisposed());
219
220 assertEquals(0, set.size());
221
222 TestHelper.assertUndeliverable(errors, 0, TestException.class, "First");
223 } finally {
224 RxJavaPlugins.reset();
225 }
226 }
227
228 @Test
229 public void withoutParentDisposed() {
230 ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, null);
231 run.dispose();
232 run.call();
233 }
234
235 @Test
236 public void withParentDisposed() {
237 ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, new CompositeDisposable());
238 run.dispose();
239 run.call();
240 }
241
242 @Test
243 public void withFutureDisposed() {
244 ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, null);
245 run.setFuture(new FutureTask<Void>(Functions.EMPTY_RUNNABLE, null));
246 run.dispose();
247 run.call();
248 }
249
250 @Test
251 public void withFutureDisposed2() {
252 ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, null);
253 run.dispose();
254 run.setFuture(new FutureTask<Void>(Functions.EMPTY_RUNNABLE, null));
255 run.call();
256 }
257
258 @Test
259 public void withFutureDisposed3() {
260 ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, null);
261 run.dispose();
262 run.set(2, Thread.currentThread());
263 run.setFuture(new FutureTask<Void>(Functions.EMPTY_RUNNABLE, null));
264 run.call();
265 }
266
267 @Test
268 public void runFuture() {
269 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
270 CompositeDisposable set = new CompositeDisposable();
271 final ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, set);
272 set.add(run);
273
274 final FutureTask<Void> ft = new FutureTask<>(Functions.EMPTY_RUNNABLE, null);
275
276 Runnable r1 = new Runnable() {
277 @Override
278 public void run() {
279 run.call();
280 }
281 };
282
283 Runnable r2 = new Runnable() {
284 @Override
285 public void run() {
286 run.setFuture(ft);
287 }
288 };
289
290 TestHelper.race(r1, r2);
291 }
292 }
293
294 @Test
295 public void syncWorkerCancelRace() {
296 for (int i = 0; i < TestHelper.RACE_LONG_LOOPS; i++) {
297 final CompositeDisposable set = new CompositeDisposable();
298 final AtomicBoolean interrupted = new AtomicBoolean();
299 final AtomicInteger sync = new AtomicInteger(2);
300 final AtomicInteger syncb = new AtomicInteger(2);
301
302 Runnable r0 = new Runnable() {
303 @Override
304 public void run() {
305 set.dispose();
306 if (sync.decrementAndGet() != 0) {
307 while (sync.get() != 0) { }
308 }
309 if (syncb.decrementAndGet() != 0) {
310 while (syncb.get() != 0) { }
311 }
312 for (int j = 0; j < 1000; j++) {
313 if (Thread.currentThread().isInterrupted()) {
314 interrupted.set(true);
315 break;
316 }
317 }
318 }
319 };
320
321 final ScheduledRunnable run = new ScheduledRunnable(r0, set);
322 set.add(run);
323
324 final FutureTask<Void> ft = new FutureTask<>(run, null);
325
326 Runnable r2 = new Runnable() {
327 @Override
328 public void run() {
329 if (sync.decrementAndGet() != 0) {
330 while (sync.get() != 0) { }
331 }
332 run.setFuture(ft);
333 if (syncb.decrementAndGet() != 0) {
334 while (syncb.get() != 0) { }
335 }
336 }
337 };
338
339 TestHelper.race(ft, r2);
340
341 assertFalse("The task was interrupted", interrupted.get());
342 }
343 }
344
345 @Test
346 public void disposeAfterRun() {
347 final ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, null);
348
349 run.run();
350 assertEquals(ScheduledRunnable.DONE, run.get(ScheduledRunnable.FUTURE_INDEX));
351
352 run.dispose();
353 assertEquals(ScheduledRunnable.DONE, run.get(ScheduledRunnable.FUTURE_INDEX));
354 }
355
356 @Test
357 public void syncDisposeIdempotent() {
358 final ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, null);
359 run.set(ScheduledRunnable.THREAD_INDEX, Thread.currentThread());
360
361 run.dispose();
362 assertEquals(ScheduledRunnable.SYNC_DISPOSED, run.get(ScheduledRunnable.FUTURE_INDEX));
363 run.dispose();
364 assertEquals(ScheduledRunnable.SYNC_DISPOSED, run.get(ScheduledRunnable.FUTURE_INDEX));
365 run.run();
366 assertEquals(ScheduledRunnable.SYNC_DISPOSED, run.get(ScheduledRunnable.FUTURE_INDEX));
367 }
368
369 @Test
370 public void asyncDisposeIdempotent() {
371 final ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, null);
372
373 run.dispose();
374 assertEquals(ScheduledRunnable.ASYNC_DISPOSED, run.get(ScheduledRunnable.FUTURE_INDEX));
375 run.dispose();
376 assertEquals(ScheduledRunnable.ASYNC_DISPOSED, run.get(ScheduledRunnable.FUTURE_INDEX));
377 run.run();
378 assertEquals(ScheduledRunnable.ASYNC_DISPOSED, run.get(ScheduledRunnable.FUTURE_INDEX));
379 }
380
381 @Test
382 public void noParentIsDisposed() {
383 ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, null);
384 assertFalse(run.isDisposed());
385 run.run();
386 assertTrue(run.isDisposed());
387 }
388
389 @Test
390 public void withParentIsDisposed() {
391 CompositeDisposable set = new CompositeDisposable();
392 ScheduledRunnable run = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, set);
393 set.add(run);
394
395 assertFalse(run.isDisposed());
396
397 run.run();
398 assertTrue(run.isDisposed());
399
400 assertFalse(set.remove(run));
401 }
402
403 @Test
404 public void toStringStates() {
405 CompositeDisposable set = new CompositeDisposable();
406 ScheduledRunnable task = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, set);
407
408 assertEquals("ScheduledRunnable[Waiting]", task.toString());
409
410 task.set(ScheduledRunnable.THREAD_INDEX, Thread.currentThread());
411
412 assertEquals("ScheduledRunnable[Running on " + Thread.currentThread() + "]", task.toString());
413
414 task.dispose();
415
416 assertEquals("ScheduledRunnable[Disposed(Sync)]", task.toString());
417
418 task.set(ScheduledRunnable.FUTURE_INDEX, ScheduledRunnable.DONE);
419
420 assertEquals("ScheduledRunnable[Finished]", task.toString());
421
422 task = new ScheduledRunnable(Functions.EMPTY_RUNNABLE, set);
423 task.dispose();
424
425 assertEquals("ScheduledRunnable[Disposed(Async)]", task.toString());
426 }
427 }