Debian Codegraph @

src/test/java/io/reactivex/rxjava3/schedulers/SchedulerWorkerTest.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.assertTrue;
17
18 import java.util.*;
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.disposables.Disposable;
26
27 public class SchedulerWorkerTest extends RxJavaTest {
28
29 static final class CustomDriftScheduler extends Scheduler {
30 public volatile long drift;
31 @NonNull
32 @Override
33 public Worker createWorker() {
34 final Worker w = Schedulers.computation().createWorker();
35 return new Worker() {
36
37 @Override
38 public void dispose() {
39 w.dispose();
40 }
41
42 @Override
43 public boolean isDisposed() {
44 return w.isDisposed();
45 }
46
47 @NonNull
48 @Override
49 public Disposable schedule(@NonNull Runnable action) {
50 return w.schedule(action);
51 }
52
53 @NonNull
54 @Override
55 public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
56 return w.schedule(action, delayTime, unit);
57 }
58
59 @Override
60 public long now(TimeUnit unit) {
61 return super.now(unit) + unit.convert(drift, TimeUnit.NANOSECONDS);
62 }
63 };
64 }
65
66 @Override
67 public long now(@NonNull TimeUnit unit) {
68 return super.now(unit) + unit.convert(drift, TimeUnit.NANOSECONDS);
69 }
70 }
71
72 @Test
73 public void currentTimeDriftBackwards() throws Exception {
74 CustomDriftScheduler s = new CustomDriftScheduler();
75
76 Scheduler.Worker w = s.createWorker();
77
78 try {
79 final List<Long> times = new ArrayList<>();
80
81 Disposable d = w.schedulePeriodically(new Runnable() {
82 @Override
83 public void run() {
84 times.add(System.currentTimeMillis());
85 }
86 }, 100, 100, TimeUnit.MILLISECONDS);
87
88 Thread.sleep(150);
89
90 s.drift = -TimeUnit.SECONDS.toNanos(1) - Scheduler.clockDriftTolerance();
91
92 Thread.sleep(400);
93
94 d.dispose();
95
96 Thread.sleep(150);
97
98 System.out.println("Runs: " + times.size());
99
100 for (int i = 0; i < times.size() - 1 ; i++) {
101 long diff = times.get(i + 1) - times.get(i);
102 System.out.println("Diff #" + i + ": " + diff);
103 assertTrue("" + i + ":" + diff, diff < 150 && diff > 50);
104 }
105
106 assertTrue("Too few invocations: " + times.size(), times.size() > 2);
107
108 } finally {
109 w.dispose();
110 }
111
112 }
113
114 @Test
115 public void currentTimeDriftForwards() throws Exception {
116 CustomDriftScheduler s = new CustomDriftScheduler();
117
118 Scheduler.Worker w = s.createWorker();
119
120 try {
121 final List<Long> times = new ArrayList<>();
122
123 Disposable d = w.schedulePeriodically(new Runnable() {
124 @Override
125 public void run() {
126 times.add(System.currentTimeMillis());
127 }
128 }, 100, 100, TimeUnit.MILLISECONDS);
129
130 Thread.sleep(150);
131
132 s.drift = TimeUnit.SECONDS.toNanos(1) + Scheduler.clockDriftTolerance();
133
134 Thread.sleep(400);
135
136 d.dispose();
137
138 Thread.sleep(150);
139
140 System.out.println("Runs: " + times.size());
141
142 assertTrue(times.size() > 2);
143
144 for (int i = 0; i < times.size() - 1 ; i++) {
145 long diff = times.get(i + 1) - times.get(i);
146 System.out.println("Diff #" + i + ": " + diff);
147 assertTrue("Diff out of range: " + diff, diff < 250 && diff > 50);
148 }
149
150 } finally {
151 w.dispose();
152 }
153
154 }
155 }