Debian Codegraph @

src/test/java/io/reactivex/rxjava3/schedulers/SchedulerTest.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.schedulers;
15
16 import static org.junit.Assert.*;
17
18 import java.util.List;
19 import java.util.concurrent.TimeUnit;
20
21 import org.junit.Test;
22
23 import io.reactivex.rxjava3.annotations.NonNull;
24 import io.reactivex.rxjava3.core.*;
25 import io.reactivex.rxjava3.core.Scheduler.Worker;
26 import io.reactivex.rxjava3.disposables.Disposable;
27 import io.reactivex.rxjava3.exceptions.TestException;
28 import io.reactivex.rxjava3.internal.disposables.*;
29 import io.reactivex.rxjava3.internal.functions.Functions;
30 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
31 import io.reactivex.rxjava3.testsupport.TestHelper;
32
33 public class SchedulerTest extends RxJavaTest {
34
35 @Test
36 public void defaultPeriodicTask() {
37 final int[] count = { 0 };
38
39 TestScheduler scheduler = new TestScheduler();
40
41 Disposable d = scheduler.schedulePeriodicallyDirect(new Runnable() {
42 @Override
43 public void run() {
44 count[0]++;
45 }
46 }, 100, 100, TimeUnit.MILLISECONDS);
47
48 assertEquals(0, count[0]);
49 assertFalse(d.isDisposed());
50
51 scheduler.advanceTimeBy(200, TimeUnit.MILLISECONDS);
52
53 assertEquals(2, count[0]);
54
55 d.dispose();
56
57 assertTrue(d.isDisposed());
58
59 scheduler.advanceTimeBy(200, TimeUnit.MILLISECONDS);
60
61 assertEquals(2, count[0]);
62 }
63
64 @Test
65 public void periodicDirectThrows() throws Throwable {
66 TestHelper.withErrorTracking(errors -> {
67 TestScheduler scheduler = new TestScheduler();
68
69 try {
70 scheduler.schedulePeriodicallyDirect(new Runnable() {
71 @Override
72 public void run() {
73 throw new TestException();
74 }
75 }, 100, 100, TimeUnit.MILLISECONDS);
76
77 scheduler.advanceTimeBy(100, TimeUnit.MILLISECONDS);
78
79 fail("Should have thrown!");
80 } catch (TestException expected) {
81 // expected
82 }
83
84 TestHelper.assertUndeliverable(errors, 0, TestException.class);
85 });
86 }
87
88 @Test
89 public void disposePeriodicDirect() {
90 final int[] count = { 0 };
91
92 TestScheduler scheduler = new TestScheduler();
93
94 Disposable d = scheduler.schedulePeriodicallyDirect(new Runnable() {
95 @Override
96 public void run() {
97 count[0]++;
98 }
99 }, 100, 100, TimeUnit.MILLISECONDS);
100
101 d.dispose();
102
103 assertEquals(0, count[0]);
104 assertTrue(d.isDisposed());
105
106 scheduler.advanceTimeBy(200, TimeUnit.MILLISECONDS);
107
108 assertEquals(0, count[0]);
109 assertTrue(d.isDisposed());
110 }
111
112 @Test
113 public void scheduleDirect() {
114 final int[] count = { 0 };
115
116 TestScheduler scheduler = new TestScheduler();
117
118 scheduler.scheduleDirect(new Runnable() {
119 @Override
120 public void run() {
121 count[0]++;
122 }
123 }, 100, TimeUnit.MILLISECONDS);
124
125 assertEquals(0, count[0]);
126
127 scheduler.advanceTimeBy(200, TimeUnit.MILLISECONDS);
128
129 assertEquals(1, count[0]);
130 }
131
132 @Test
133 public void disposeSelfPeriodicDirect() {
134 final int[] count = { 0 };
135
136 TestScheduler scheduler = new TestScheduler();
137
138 final SequentialDisposable sd = new SequentialDisposable();
139
140 Disposable d = scheduler.schedulePeriodicallyDirect(new Runnable() {
141 @Override
142 public void run() {
143 count[0]++;
144 sd.dispose();
145 }
146 }, 100, 100, TimeUnit.MILLISECONDS);
147
148 sd.set(d);
149
150 assertEquals(0, count[0]);
151 assertFalse(d.isDisposed());
152
153 scheduler.advanceTimeBy(400, TimeUnit.MILLISECONDS);
154
155 assertEquals(1, count[0]);
156 assertTrue(d.isDisposed());
157 }
158
159 @Test
160 public void disposeSelfPeriodic() {
161 final int[] count = { 0 };
162
163 TestScheduler scheduler = new TestScheduler();
164
165 Worker worker = scheduler.createWorker();
166
167 try {
168 final SequentialDisposable sd = new SequentialDisposable();
169
170 Disposable d = worker.schedulePeriodically(new Runnable() {
171 @Override
172 public void run() {
173 count[0]++;
174 sd.dispose();
175 }
176 }, 100, 100, TimeUnit.MILLISECONDS);
177
178 sd.set(d);
179
180 assertEquals(0, count[0]);
181 assertFalse(d.isDisposed());
182
183 scheduler.advanceTimeBy(400, TimeUnit.MILLISECONDS);
184
185 assertEquals(1, count[0]);
186 assertTrue(d.isDisposed());
187 } finally {
188 worker.dispose();
189 }
190 }
191
192 @Test
193 public void periodicDirectTaskRace() {
194 final TestScheduler scheduler = new TestScheduler();
195
196 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
197 final Disposable d = scheduler.schedulePeriodicallyDirect(Functions.EMPTY_RUNNABLE, 1, 1, TimeUnit.MILLISECONDS);
198
199 Runnable r1 = new Runnable() {
200 @Override
201 public void run() {
202 d.dispose();
203 }
204 };
205
206 Runnable r2 = new Runnable() {
207 @Override
208 public void run() {
209 scheduler.advanceTimeBy(1, TimeUnit.SECONDS);
210 }
211 };
212
213 TestHelper.race(r1, r2);
214 }
215
216 }
217
218 @Test
219 public void periodicDirectTaskRaceIO() throws Exception {
220 final Scheduler scheduler = Schedulers.io();
221
222 for (int i = 0; i < 100; i++) {
223 final Disposable d = scheduler.schedulePeriodicallyDirect(
224 Functions.EMPTY_RUNNABLE, 0, 0, TimeUnit.MILLISECONDS);
225
226 Thread.sleep(1);
227
228 d.dispose();
229 }
230
231 }
232
233 @Test
234 public void scheduleDirectThrows() throws Exception {
235 List<Throwable> list = TestHelper.trackPluginErrors();
236 try {
237 Schedulers.io().scheduleDirect(new Runnable() {
238 @Override
239 public void run() {
240 throw new TestException();
241 }
242 });
243
244 Thread.sleep(250);
245
246 assertTrue(list.size() >= 1);
247 TestHelper.assertUndeliverable(list, 0, TestException.class, null);
248
249 } finally {
250 RxJavaPlugins.reset();
251 }
252 }
253
254 @Test
255 public void schedulersUtility() {
256 TestHelper.checkUtilityClass(Schedulers.class);
257 }
258
259 @Test
260 public void defaultSchedulePeriodicallyDirectRejects() {
261 Scheduler s = new Scheduler() {
262 @NonNull
263 @Override
264 public Worker createWorker() {
265 return new Worker() {
266 @NonNull
267 @Override
268 public Disposable schedule(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
269 return EmptyDisposable.INSTANCE;
270 }
271
272 @Override
273 public void dispose() {
274
275 }
276
277 @Override
278 public boolean isDisposed() {
279 return false;
280 }
281 };
282 }
283 };
284
285 assertSame(EmptyDisposable.INSTANCE, s.schedulePeriodicallyDirect(Functions.EMPTY_RUNNABLE, 1, 1, TimeUnit.MILLISECONDS));
286 }
287
288 @Test
289 public void holders() {
290 assertNotNull(new Schedulers.ComputationHolder());
291
292 assertNotNull(new Schedulers.IoHolder());
293
294 assertNotNull(new Schedulers.NewThreadHolder());
295
296 assertNotNull(new Schedulers.SingleHolder());
297 }
298
299 static final class CustomScheduler extends Scheduler {
300
301 @Override
302 public Worker createWorker() {
303 return Schedulers.single().createWorker();
304 }
305
306 }
307
308 @Test
309 public void customScheduleDirectDisposed() {
310 CustomScheduler scheduler = new CustomScheduler();
311
312 Disposable d = scheduler.scheduleDirect(Functions.EMPTY_RUNNABLE, 1, TimeUnit.MINUTES);
313
314 assertFalse(d.isDisposed());
315
316 d.dispose();
317
318 assertTrue(d.isDisposed());
319 }
320
321 @Test
322 public void unwrapDefaultPeriodicTask() {
323 TestScheduler scheduler = new TestScheduler();
324
325 Runnable runnable = new Runnable() {
326 @Override
327 public void run() {
328 }
329 };
330 SchedulerRunnableIntrospection wrapper = (SchedulerRunnableIntrospection) scheduler.schedulePeriodicallyDirect(runnable, 100, 100, TimeUnit.MILLISECONDS);
331
332 assertSame(runnable, wrapper.getWrappedRunnable());
333 }
334
335 @Test
336 public void unwrapScheduleDirectTask() {
337 TestScheduler scheduler = new TestScheduler();
338
339 Runnable runnable = new Runnable() {
340 @Override
341 public void run() {
342 }
343 };
344 SchedulerRunnableIntrospection wrapper = (SchedulerRunnableIntrospection) scheduler.scheduleDirect(runnable, 100, TimeUnit.MILLISECONDS);
345 assertSame(runnable, wrapper.getWrappedRunnable());
346 }
347
348 @Test
349 public void unwrapWorkerPeriodicTask() {
350 final Runnable runnable = new Runnable() {
351 @Override
352 public void run() {
353 }
354 };
355
356 Scheduler scheduler = new Scheduler() {
357 @Override
358 public Worker createWorker() {
359 return new Worker() {
360 @Override
361 public Disposable schedule(Runnable run, long delay, TimeUnit unit) {
362 SchedulerRunnableIntrospection outerWrapper = (SchedulerRunnableIntrospection) run;
363 SchedulerRunnableIntrospection innerWrapper = (SchedulerRunnableIntrospection) outerWrapper.getWrappedRunnable();
364 assertSame(runnable, innerWrapper.getWrappedRunnable());
365 return (Disposable) innerWrapper;
366 }
367
368 @Override
369 public void dispose() {
370 }
371
372 @Override
373 public boolean isDisposed() {
374 return false;
375 }
376 };
377 }
378 };
379
380 scheduler.schedulePeriodicallyDirect(runnable, 100, 100, TimeUnit.MILLISECONDS);
381 }
382 }