ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ScheduledExecutorSubclassTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ScheduledExecutorSubclassTest.java (file contents):
Revision 1.59 by jsr166, Sun Oct 25 02:58:25 2015 UTC vs.
Revision 1.62 by jsr166, Wed Aug 24 22:22:39 2016 UTC

# Line 5 | Line 5
5   */
6  
7   import static java.util.concurrent.TimeUnit.MILLISECONDS;
8 + import static java.util.concurrent.TimeUnit.NANOSECONDS;
9   import static java.util.concurrent.TimeUnit.SECONDS;
10  
11   import java.util.ArrayList;
# Line 16 | Line 17 | import java.util.concurrent.Cancellation
17   import java.util.concurrent.CountDownLatch;
18   import java.util.concurrent.Delayed;
19   import java.util.concurrent.ExecutionException;
19 – import java.util.concurrent.Executors;
20   import java.util.concurrent.ExecutorService;
21   import java.util.concurrent.Future;
22   import java.util.concurrent.RejectedExecutionException;
# Line 28 | Line 28 | import java.util.concurrent.ThreadFactor
28   import java.util.concurrent.ThreadPoolExecutor;
29   import java.util.concurrent.TimeoutException;
30   import java.util.concurrent.TimeUnit;
31 + import java.util.concurrent.atomic.AtomicBoolean;
32   import java.util.concurrent.atomic.AtomicInteger;
33 + import java.util.concurrent.atomic.AtomicLong;
34  
35   import junit.framework.Test;
36   import junit.framework.TestSuite;
# Line 199 | Line 201 | public class ScheduledExecutorSubclassTe
201      }
202  
203      /**
204 <     * scheduleAtFixedRate executes series of tasks at given rate
204 >     * scheduleAtFixedRate executes series of tasks at given rate.
205 >     * Eventually, it must hold that:
206 >     *   cycles - 1 <= elapsedMillis/delay < cycles
207       */
208      public void testFixedRateSequence() throws InterruptedException {
209          final CustomExecutor p = new CustomExecutor(1);
210          try (PoolCleaner cleaner = cleaner(p)) {
211              for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) {
212 <                long startTime = System.nanoTime();
213 <                int cycles = 10;
212 >                final long startTime = System.nanoTime();
213 >                final int cycles = 8;
214                  final CountDownLatch done = new CountDownLatch(cycles);
215 <                Runnable task = new CheckedRunnable() {
215 >                final Runnable task = new CheckedRunnable() {
216                      public void realRun() { done.countDown(); }};
217 <                ScheduledFuture h =
217 >                final ScheduledFuture periodicTask =
218                      p.scheduleAtFixedRate(task, 0, delay, MILLISECONDS);
219 <                await(done);
220 <                h.cancel(true);
221 <                double normalizedTime =
222 <                    (double) millisElapsedSince(startTime) / delay;
223 <                if (normalizedTime >= cycles - 1 &&
224 <                    normalizedTime <= cycles)
219 >                final int totalDelayMillis = (cycles - 1) * delay;
220 >                await(done, totalDelayMillis + LONG_DELAY_MS);
221 >                periodicTask.cancel(true);
222 >                final long elapsedMillis = millisElapsedSince(startTime);
223 >                assertTrue(elapsedMillis >= totalDelayMillis);
224 >                if (elapsedMillis <= cycles * delay)
225                      return;
226 +                // else retry with longer delay
227              }
228              fail("unexpected execution rate");
229          }
230      }
231  
232      /**
233 <     * scheduleWithFixedDelay executes series of tasks with given period
233 >     * scheduleWithFixedDelay executes series of tasks with given period.
234 >     * Eventually, it must hold that each task starts at least delay and at
235 >     * most 2 * delay after the termination of the previous task.
236       */
237      public void testFixedDelaySequence() throws InterruptedException {
238          final CustomExecutor p = new CustomExecutor(1);
239          try (PoolCleaner cleaner = cleaner(p)) {
240              for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) {
241 <                long startTime = System.nanoTime();
242 <                int cycles = 10;
241 >                final long startTime = System.nanoTime();
242 >                final AtomicLong previous = new AtomicLong(startTime);
243 >                final AtomicBoolean tryLongerDelay = new AtomicBoolean(false);
244 >                final int cycles = 8;
245                  final CountDownLatch done = new CountDownLatch(cycles);
246 <                Runnable task = new CheckedRunnable() {
247 <                    public void realRun() { done.countDown(); }};
248 <                ScheduledFuture h =
246 >                final int d = delay;
247 >                final Runnable task = new CheckedRunnable() {
248 >                    public void realRun() {
249 >                        long now = System.nanoTime();
250 >                        long elapsedMillis
251 >                            = NANOSECONDS.toMillis(now - previous.get());
252 >                        if (done.getCount() == cycles) { // first execution
253 >                            if (elapsedMillis >= d)
254 >                                tryLongerDelay.set(true);
255 >                        } else {
256 >                            assertTrue(elapsedMillis >= d);
257 >                            if (elapsedMillis >= 2 * d)
258 >                                tryLongerDelay.set(true);
259 >                        }
260 >                        previous.set(now);
261 >                        done.countDown();
262 >                    }};
263 >                final ScheduledFuture periodicTask =
264                      p.scheduleWithFixedDelay(task, 0, delay, MILLISECONDS);
265 <                await(done);
266 <                h.cancel(true);
267 <                double normalizedTime =
268 <                    (double) millisElapsedSince(startTime) / delay;
269 <                if (normalizedTime >= cycles - 1 &&
270 <                    normalizedTime <= cycles)
265 >                final int totalDelayMillis = (cycles - 1) * delay;
266 >                await(done, totalDelayMillis + cycles * LONG_DELAY_MS);
267 >                periodicTask.cancel(true);
268 >                final long elapsedMillis = millisElapsedSince(startTime);
269 >                assertTrue(elapsedMillis >= totalDelayMillis);
270 >                if (!tryLongerDelay.get())
271                      return;
272 +                // else retry with longer delay
273              }
274              fail("unexpected execution rate");
275          }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines