Debian Codegraph @

src/test/java/io/reactivex/rxjava3/schedulers/TestSchedulerTest.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 import static org.mockito.ArgumentMatchers.anyLong;
18 import static org.mockito.Mockito.*;
19
20 import java.util.concurrent.TimeUnit;
21 import java.util.concurrent.atomic.AtomicInteger;
22
23 import org.junit.Test;
24 import org.mockito.*;
25 import org.reactivestreams.*;
26
27 import io.reactivex.rxjava3.core.*;
28 import io.reactivex.rxjava3.core.Scheduler.Worker;
29 import io.reactivex.rxjava3.disposables.Disposable;
30 import io.reactivex.rxjava3.functions.Function;
31 import io.reactivex.rxjava3.internal.subscriptions.BooleanSubscription;
32 import io.reactivex.rxjava3.internal.util.ExceptionHelper;
33 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
34 import io.reactivex.rxjava3.schedulers.TestScheduler.*;
35
36 public class TestSchedulerTest extends RxJavaTest {
37
38 @SuppressWarnings("unchecked")
39 // mocking is unchecked, unfortunately
40 @Test
41 public final void periodicScheduling() throws Throwable {
42 final Function<Long, Void> calledOp = mock(Function.class);
43
44 final TestScheduler scheduler = new TestScheduler();
45 final Scheduler.Worker inner = scheduler.createWorker();
46
47 try {
48 inner.schedulePeriodically(new Runnable() {
49 @Override
50 public void run() {
51 System.out.println(scheduler.now(TimeUnit.MILLISECONDS));
52 try {
53 calledOp.apply(scheduler.now(TimeUnit.MILLISECONDS));
54 } catch (Throwable ex) {
55 ExceptionHelper.wrapOrThrow(ex);
56 }
57 }
58 }, 1, 2, TimeUnit.SECONDS);
59
60 verify(calledOp, never()).apply(anyLong());
61
62 InOrder inOrder = Mockito.inOrder(calledOp);
63
64 scheduler.advanceTimeBy(999L, TimeUnit.MILLISECONDS);
65 inOrder.verify(calledOp, never()).apply(anyLong());
66
67 scheduler.advanceTimeBy(1L, TimeUnit.MILLISECONDS);
68 inOrder.verify(calledOp, times(1)).apply(1000L);
69
70 scheduler.advanceTimeBy(1999L, TimeUnit.MILLISECONDS);
71 inOrder.verify(calledOp, never()).apply(3000L);
72
73 scheduler.advanceTimeBy(1L, TimeUnit.MILLISECONDS);
74 inOrder.verify(calledOp, times(1)).apply(3000L);
75
76 scheduler.advanceTimeBy(5L, TimeUnit.SECONDS);
77 inOrder.verify(calledOp, times(1)).apply(5000L);
78 inOrder.verify(calledOp, times(1)).apply(7000L);
79
80 inner.dispose();
81 scheduler.advanceTimeBy(11L, TimeUnit.SECONDS);
82 inOrder.verify(calledOp, never()).apply(anyLong());
83 } finally {
84 inner.dispose();
85 }
86 }
87
88 @SuppressWarnings("unchecked")
89 // mocking is unchecked, unfortunately
90 @Test
91 public final void periodicSchedulingUnsubscription() throws Throwable {
92 final Function<Long, Void> calledOp = mock(Function.class);
93
94 final TestScheduler scheduler = new TestScheduler();
95 final Scheduler.Worker inner = scheduler.createWorker();
96
97 try {
98 final Disposable subscription = inner.schedulePeriodically(new Runnable() {
99 @Override
100 public void run() {
101 System.out.println(scheduler.now(TimeUnit.MILLISECONDS));
102 try {
103 calledOp.apply(scheduler.now(TimeUnit.MILLISECONDS));
104 } catch (Throwable ex) {
105 ExceptionHelper.wrapOrThrow(ex);
106 }
107 }
108 }, 1, 2, TimeUnit.SECONDS);
109
110 verify(calledOp, never()).apply(anyLong());
111
112 InOrder inOrder = Mockito.inOrder(calledOp);
113
114 scheduler.advanceTimeBy(999L, TimeUnit.MILLISECONDS);
115 inOrder.verify(calledOp, never()).apply(anyLong());
116
117 scheduler.advanceTimeBy(1L, TimeUnit.MILLISECONDS);
118 inOrder.verify(calledOp, times(1)).apply(1000L);
119
120 scheduler.advanceTimeBy(1999L, TimeUnit.MILLISECONDS);
121 inOrder.verify(calledOp, never()).apply(3000L);
122
123 scheduler.advanceTimeBy(1L, TimeUnit.MILLISECONDS);
124 inOrder.verify(calledOp, times(1)).apply(3000L);
125
126 scheduler.advanceTimeBy(5L, TimeUnit.SECONDS);
127 inOrder.verify(calledOp, times(1)).apply(5000L);
128 inOrder.verify(calledOp, times(1)).apply(7000L);
129
130 subscription.dispose();
131 scheduler.advanceTimeBy(11L, TimeUnit.SECONDS);
132 inOrder.verify(calledOp, never()).apply(anyLong());
133 } finally {
134 inner.dispose();
135 }
136 }
137
138 @Test
139 public final void immediateUnsubscribes() {
140 TestScheduler s = new TestScheduler();
141 final Scheduler.Worker inner = s.createWorker();
142 final AtomicInteger counter = new AtomicInteger(0);
143
144 try {
145 inner.schedule(new Runnable() {
146
147 @Override
148 public void run() {
149 counter.incrementAndGet();
150 System.out.println("counter: " + counter.get());
151 inner.schedule(this);
152 }
153
154 });
155 inner.dispose();
156 assertEquals(0, counter.get());
157 } finally {
158 inner.dispose();
159 }
160 }
161
162 @Test
163 public final void immediateUnsubscribes2() {
164 TestScheduler s = new TestScheduler();
165 final Scheduler.Worker inner = s.createWorker();
166 try {
167 final AtomicInteger counter = new AtomicInteger(0);
168
169 final Disposable subscription = inner.schedule(new Runnable() {
170
171 @Override
172 public void run() {
173 counter.incrementAndGet();
174 System.out.println("counter: " + counter.get());
175 inner.schedule(this);
176 }
177
178 });
179 subscription.dispose();
180 assertEquals(0, counter.get());
181 } finally {
182 inner.dispose();
183 }
184 }
185
186 @Test
187 public final void nestedSchedule() {
188 final TestScheduler scheduler = new TestScheduler();
189 final Scheduler.Worker inner = scheduler.createWorker();
190
191 try {
192 final Runnable calledOp = mock(Runnable.class);
193
194 Flowable<Object> poller;
195 poller = Flowable.unsafeCreate(new Publisher<Object>() {
196 @Override
197 public void subscribe(final Subscriber<? super Object> aSubscriber) {
198 final BooleanSubscription bs = new BooleanSubscription();
199 aSubscriber.onSubscribe(bs);
200 inner.schedule(new Runnable() {
201 @Override
202 public void run() {
203 if (!bs.isCancelled()) {
204 calledOp.run();
205 inner.schedule(this, 5, TimeUnit.SECONDS);
206 }
207 }
208 });
209 }
210 });
211
212 InOrder inOrder = Mockito.inOrder(calledOp);
213
214 Disposable sub;
215 sub = poller.subscribe();
216
217 scheduler.advanceTimeTo(6, TimeUnit.SECONDS);
218 inOrder.verify(calledOp, times(2)).run();
219
220 sub.dispose();
221 scheduler.advanceTimeTo(11, TimeUnit.SECONDS);
222 inOrder.verify(calledOp, never()).run();
223
224 sub = poller.subscribe();
225 scheduler.advanceTimeTo(12, TimeUnit.SECONDS);
226 inOrder.verify(calledOp, times(1)).run();
227 } finally {
228 inner.dispose();
229 }
230 }
231
232 @Test
233 public void timedRunnableToString() {
234 TimedRunnable r = new TimedRunnable((TestWorker) new TestScheduler().createWorker(), 5, new Runnable() {
235 @Override
236 public void run() {
237 // deliberately no-op
238 }
239
240 @Override
241 public String toString() {
242 return "Runnable";
243 }
244 }, 1);
245
246 assertEquals("TimedRunnable(time = 5, run = Runnable)", r.toString());
247 }
248
249 @Test
250 public void workerDisposed() {
251 TestScheduler scheduler = new TestScheduler();
252
253 Worker w = scheduler.createWorker();
254 w.dispose();
255 assertTrue(w.isDisposed());
256 }
257
258 @Test
259 public void constructorTimeSetsTime() {
260 TestScheduler ts = new TestScheduler(5, TimeUnit.SECONDS);
261 assertEquals(5, ts.now(TimeUnit.SECONDS));
262 assertEquals(5000, ts.now(TimeUnit.MILLISECONDS));
263 }
264
265 @Test
266 public void withOnScheduleHook() {
267 AtomicInteger run = new AtomicInteger();
268 AtomicInteger counter = new AtomicInteger();
269 RxJavaPlugins.setScheduleHandler(r -> {
270 counter.getAndIncrement();
271 return r;
272 });
273 try {
274 Runnable r = () -> run.getAndIncrement();
275 TestScheduler ts = new TestScheduler(true);
276
277 ts.createWorker().schedule(r);
278 ts.createWorker().schedule(r, 1, TimeUnit.SECONDS);
279
280 ts.advanceTimeBy(1, TimeUnit.SECONDS);
281
282 assertEquals(2, run.get());
283 assertEquals(2, counter.get());
284
285 ts = new TestScheduler();
286
287 ts.createWorker().schedule(r);
288 ts.createWorker().schedule(r, 1, TimeUnit.SECONDS);
289
290 ts.advanceTimeBy(1, TimeUnit.SECONDS);
291
292 assertEquals(4, run.get());
293 assertEquals(2, counter.get());
294 } finally {
295 RxJavaPlugins.setScheduleHandler(null);
296 }
297 }
298
299 @Test
300 public void withOnScheduleHookInitialTime() {
301 AtomicInteger run = new AtomicInteger();
302 AtomicInteger counter = new AtomicInteger();
303 RxJavaPlugins.setScheduleHandler(r -> {
304 counter.getAndIncrement();
305 return r;
306 });
307 try {
308 Runnable r = () -> run.getAndIncrement();
309 TestScheduler ts = new TestScheduler(1, TimeUnit.HOURS, true);
310
311 ts.createWorker().schedule(r);
312 ts.createWorker().schedule(r, 1, TimeUnit.SECONDS);
313
314 ts.advanceTimeBy(1, TimeUnit.SECONDS);
315
316 assertEquals(2, run.get());
317 assertEquals(2, counter.get());
318
319 ts = new TestScheduler(1, TimeUnit.HOURS);
320
321 ts.createWorker().schedule(r);
322 ts.createWorker().schedule(r, 1, TimeUnit.SECONDS);
323
324 ts.advanceTimeBy(1, TimeUnit.SECONDS);
325
326 assertEquals(4, run.get());
327 assertEquals(2, counter.get());
328 } finally {
329 RxJavaPlugins.setScheduleHandler(null);
330 }
331 }
332
333 @Test
334 public void disposeWork() {
335 AtomicInteger run = new AtomicInteger();
336 Runnable r = () -> run.getAndIncrement();
337 TestScheduler ts = new TestScheduler(1, TimeUnit.HOURS, true);
338
339 Disposable d = ts.createWorker().schedule(r);
340
341 assertFalse(d.isDisposed());
342
343 d.dispose();
344
345 assertTrue(d.isDisposed());
346
347 d.dispose();
348
349 assertTrue(d.isDisposed());
350
351 ts.advanceTimeBy(1, TimeUnit.SECONDS);
352
353 assertEquals(0, run.get());
354 }
355 }