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

Comparing jsr166/src/test/tck/ScheduledExecutorTest.java (file contents):
Revision 1.62 by jsr166, Sun Oct 4 08:07:31 2015 UTC vs.
Revision 1.83 by jsr166, Wed Jan 4 06:09:58 2017 UTC

# Line 7 | Line 7
7   */
8  
9   import static java.util.concurrent.TimeUnit.MILLISECONDS;
10 + import static java.util.concurrent.TimeUnit.NANOSECONDS;
11   import static java.util.concurrent.TimeUnit.SECONDS;
12  
13   import java.util.ArrayList;
# Line 17 | Line 18 | import java.util.concurrent.Callable;
18   import java.util.concurrent.CancellationException;
19   import java.util.concurrent.CountDownLatch;
20   import java.util.concurrent.ExecutionException;
20 – import java.util.concurrent.Executors;
21   import java.util.concurrent.ExecutorService;
22   import java.util.concurrent.Future;
23   import java.util.concurrent.RejectedExecutionException;
# Line 25 | Line 25 | import java.util.concurrent.ScheduledFut
25   import java.util.concurrent.ScheduledThreadPoolExecutor;
26   import java.util.concurrent.ThreadFactory;
27   import java.util.concurrent.ThreadPoolExecutor;
28 + import java.util.concurrent.atomic.AtomicBoolean;
29   import java.util.concurrent.atomic.AtomicInteger;
30 + import java.util.concurrent.atomic.AtomicLong;
31  
32   import junit.framework.Test;
33   import junit.framework.TestSuite;
# Line 42 | Line 44 | public class ScheduledExecutorTest exten
44       * execute successfully executes a runnable
45       */
46      public void testExecute() throws InterruptedException {
47 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
47 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
48          try (PoolCleaner cleaner = cleaner(p)) {
49              final CountDownLatch done = new CountDownLatch(1);
50              final Runnable task = new CheckedRunnable() {
51                  public void realRun() { done.countDown(); }};
52              p.execute(task);
53 <            assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS));
53 >            assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
54          }
55      }
56  
# Line 56 | Line 58 | public class ScheduledExecutorTest exten
58       * delayed schedule of callable successfully executes after delay
59       */
60      public void testSchedule1() throws Exception {
61 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
61 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
62          try (PoolCleaner cleaner = cleaner(p)) {
63              final long startTime = System.nanoTime();
64              final CountDownLatch done = new CountDownLatch(1);
# Line 77 | Line 79 | public class ScheduledExecutorTest exten
79       * delayed schedule of runnable successfully executes after delay
80       */
81      public void testSchedule3() throws Exception {
82 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
82 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
83          try (PoolCleaner cleaner = cleaner(p)) {
84              final long startTime = System.nanoTime();
85              final CountDownLatch done = new CountDownLatch(1);
# Line 97 | Line 99 | public class ScheduledExecutorTest exten
99       * scheduleAtFixedRate executes runnable after given initial delay
100       */
101      public void testSchedule4() throws Exception {
102 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
102 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
103          try (PoolCleaner cleaner = cleaner(p)) {
104              final long startTime = System.nanoTime();
105              final CountDownLatch done = new CountDownLatch(1);
# Line 119 | Line 121 | public class ScheduledExecutorTest exten
121       * scheduleWithFixedDelay executes runnable after given initial delay
122       */
123      public void testSchedule5() throws Exception {
124 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
124 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
125          try (PoolCleaner cleaner = cleaner(p)) {
126              final long startTime = System.nanoTime();
127              final CountDownLatch done = new CountDownLatch(1);
# Line 143 | Line 145 | public class ScheduledExecutorTest exten
145      }
146  
147      /**
148 <     * scheduleAtFixedRate executes series of tasks at given rate
148 >     * scheduleAtFixedRate executes series of tasks at given rate.
149 >     * Eventually, it must hold that:
150 >     *   cycles - 1 <= elapsedMillis/delay < cycles
151       */
152      public void testFixedRateSequence() throws InterruptedException {
153 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
153 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
154          try (PoolCleaner cleaner = cleaner(p)) {
155              for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) {
156 <                long startTime = System.nanoTime();
157 <                int cycles = 10;
156 >                final long startTime = System.nanoTime();
157 >                final int cycles = 8;
158                  final CountDownLatch done = new CountDownLatch(cycles);
159 <                Runnable task = new CheckedRunnable() {
159 >                final Runnable task = new CheckedRunnable() {
160                      public void realRun() { done.countDown(); }};
161 <                ScheduledFuture h =
161 >                final ScheduledFuture periodicTask =
162                      p.scheduleAtFixedRate(task, 0, delay, MILLISECONDS);
163 <                done.await();
164 <                h.cancel(true);
165 <                double normalizedTime =
166 <                    (double) millisElapsedSince(startTime) / delay;
167 <                if (normalizedTime >= cycles - 1 &&
168 <                    normalizedTime <= cycles)
163 >                final int totalDelayMillis = (cycles - 1) * delay;
164 >                await(done, totalDelayMillis + LONG_DELAY_MS);
165 >                periodicTask.cancel(true);
166 >                final long elapsedMillis = millisElapsedSince(startTime);
167 >                assertTrue(elapsedMillis >= totalDelayMillis);
168 >                if (elapsedMillis <= cycles * delay)
169                      return;
170 +                // else retry with longer delay
171              }
172 <            throw new AssertionError("unexpected execution rate");
172 >            fail("unexpected execution rate");
173          }
174      }
175  
176      /**
177 <     * scheduleWithFixedDelay executes series of tasks with given period
177 >     * scheduleWithFixedDelay executes series of tasks with given period.
178 >     * Eventually, it must hold that each task starts at least delay and at
179 >     * most 2 * delay after the termination of the previous task.
180       */
181      public void testFixedDelaySequence() throws InterruptedException {
182 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
182 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
183          try (PoolCleaner cleaner = cleaner(p)) {
184              for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) {
185 <                long startTime = System.nanoTime();
186 <                int cycles = 10;
185 >                final long startTime = System.nanoTime();
186 >                final AtomicLong previous = new AtomicLong(startTime);
187 >                final AtomicBoolean tryLongerDelay = new AtomicBoolean(false);
188 >                final int cycles = 8;
189                  final CountDownLatch done = new CountDownLatch(cycles);
190 <                Runnable task = new CheckedRunnable() {
191 <                    public void realRun() { done.countDown(); }};
192 <                ScheduledFuture h =
190 >                final int d = delay;
191 >                final Runnable task = new CheckedRunnable() {
192 >                    public void realRun() {
193 >                        long now = System.nanoTime();
194 >                        long elapsedMillis
195 >                            = NANOSECONDS.toMillis(now - previous.get());
196 >                        if (done.getCount() == cycles) { // first execution
197 >                            if (elapsedMillis >= d)
198 >                                tryLongerDelay.set(true);
199 >                        } else {
200 >                            assertTrue(elapsedMillis >= d);
201 >                            if (elapsedMillis >= 2 * d)
202 >                                tryLongerDelay.set(true);
203 >                        }
204 >                        previous.set(now);
205 >                        done.countDown();
206 >                    }};
207 >                final ScheduledFuture periodicTask =
208                      p.scheduleWithFixedDelay(task, 0, delay, MILLISECONDS);
209 <                done.await();
210 <                h.cancel(true);
211 <                double normalizedTime =
212 <                    (double) millisElapsedSince(startTime) / delay;
213 <                if (normalizedTime >= cycles - 1 &&
214 <                    normalizedTime <= cycles)
209 >                final int totalDelayMillis = (cycles - 1) * delay;
210 >                await(done, totalDelayMillis + cycles * LONG_DELAY_MS);
211 >                periodicTask.cancel(true);
212 >                final long elapsedMillis = millisElapsedSince(startTime);
213 >                assertTrue(elapsedMillis >= totalDelayMillis);
214 >                if (!tryLongerDelay.get())
215                      return;
216 +                // else retry with longer delay
217              }
218 <            throw new AssertionError("unexpected execution rate");
218 >            fail("unexpected execution rate");
219          }
220      }
221  
# Line 198 | Line 223 | public class ScheduledExecutorTest exten
223       * execute(null) throws NPE
224       */
225      public void testExecuteNull() throws InterruptedException {
226 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
226 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
227          try (PoolCleaner cleaner = cleaner(p)) {
228              try {
229                  p.execute(null);
# Line 225 | Line 250 | public class ScheduledExecutorTest exten
250       * execute throws RejectedExecutionException if shutdown
251       */
252      public void testSchedule1_RejectedExecutionException() throws InterruptedException {
253 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
253 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
254          try (PoolCleaner cleaner = cleaner(p)) {
255              try {
256                  p.shutdown();
# Line 241 | Line 266 | public class ScheduledExecutorTest exten
266       * schedule throws RejectedExecutionException if shutdown
267       */
268      public void testSchedule2_RejectedExecutionException() throws InterruptedException {
269 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
269 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
270          try (PoolCleaner cleaner = cleaner(p)) {
271              try {
272                  p.shutdown();
# Line 257 | Line 282 | public class ScheduledExecutorTest exten
282       * schedule callable throws RejectedExecutionException if shutdown
283       */
284      public void testSchedule3_RejectedExecutionException() throws InterruptedException {
285 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
285 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
286          try (PoolCleaner cleaner = cleaner(p)) {
287              try {
288                  p.shutdown();
# Line 273 | Line 298 | public class ScheduledExecutorTest exten
298       * scheduleAtFixedRate throws RejectedExecutionException if shutdown
299       */
300      public void testScheduleAtFixedRate1_RejectedExecutionException() throws InterruptedException {
301 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
301 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
302          try (PoolCleaner cleaner = cleaner(p)) {
303              try {
304                  p.shutdown();
# Line 289 | Line 314 | public class ScheduledExecutorTest exten
314       * scheduleWithFixedDelay throws RejectedExecutionException if shutdown
315       */
316      public void testScheduleWithFixedDelay1_RejectedExecutionException() throws InterruptedException {
317 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
317 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
318          try (PoolCleaner cleaner = cleaner(p)) {
319              try {
320                  p.shutdown();
# Line 306 | Line 331 | public class ScheduledExecutorTest exten
331       * thread becomes active
332       */
333      public void testGetActiveCount() throws InterruptedException {
334 +        final CountDownLatch done = new CountDownLatch(1);
335          final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(2);
336 <        try (PoolCleaner cleaner = cleaner(p)) {
336 >        try (PoolCleaner cleaner = cleaner(p, done)) {
337              final CountDownLatch threadStarted = new CountDownLatch(1);
312 –            final CountDownLatch done = new CountDownLatch(1);
338              assertEquals(0, p.getActiveCount());
339              p.execute(new CheckedRunnable() {
340                  public void realRun() throws InterruptedException {
341                      threadStarted.countDown();
342                      assertEquals(1, p.getActiveCount());
343 <                    done.await();
343 >                    await(done);
344                  }});
345 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
345 >            await(threadStarted);
346              assertEquals(1, p.getActiveCount());
322 –            done.countDown();
347          }
348      }
349  
# Line 373 | Line 397 | public class ScheduledExecutorTest exten
397          final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(THREADS);
398          final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
399          final CountDownLatch done = new CountDownLatch(1);
400 <        try (PoolCleaner cleaner = cleaner(p)) {
400 >        try (PoolCleaner cleaner = cleaner(p, done)) {
401              assertEquals(0, p.getLargestPoolSize());
402              for (int i = 0; i < THREADS; i++)
403                  p.execute(new CheckedRunnable() {
404                      public void realRun() throws InterruptedException {
405                          threadsStarted.countDown();
406 <                        done.await();
406 >                        await(done);
407                          assertEquals(THREADS, p.getLargestPoolSize());
408                      }});
409 <            assertTrue(threadsStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
409 >            await(threadsStarted);
410              assertEquals(THREADS, p.getLargestPoolSize());
387 –            done.countDown();
411          }
412          assertEquals(THREADS, p.getLargestPoolSize());
413      }
# Line 397 | Line 420 | public class ScheduledExecutorTest exten
420          final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
421          final CountDownLatch threadStarted = new CountDownLatch(1);
422          final CountDownLatch done = new CountDownLatch(1);
423 <        try (PoolCleaner cleaner = cleaner(p)) {
423 >        try (PoolCleaner cleaner = cleaner(p, done)) {
424              assertEquals(0, p.getPoolSize());
425              p.execute(new CheckedRunnable() {
426                  public void realRun() throws InterruptedException {
427                      threadStarted.countDown();
428                      assertEquals(1, p.getPoolSize());
429 <                    done.await();
429 >                    await(done);
430                  }});
431 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
431 >            await(threadStarted);
432              assertEquals(1, p.getPoolSize());
410 –            done.countDown();
433          }
434      }
435  
# Line 416 | Line 438 | public class ScheduledExecutorTest exten
438       * submitted
439       */
440      public void testGetTaskCount() throws InterruptedException {
441 +        final int TASKS = 3;
442 +        final CountDownLatch done = new CountDownLatch(1);
443          final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
444 <        try (PoolCleaner cleaner = cleaner(p)) {
444 >        try (PoolCleaner cleaner = cleaner(p, done)) {
445              final CountDownLatch threadStarted = new CountDownLatch(1);
422 –            final CountDownLatch done = new CountDownLatch(1);
423 –            final int TASKS = 5;
446              assertEquals(0, p.getTaskCount());
447 <            for (int i = 0; i < TASKS; i++)
447 >            assertEquals(0, p.getCompletedTaskCount());
448 >            p.execute(new CheckedRunnable() {
449 >                public void realRun() throws InterruptedException {
450 >                    threadStarted.countDown();
451 >                    await(done);
452 >                }});
453 >            await(threadStarted);
454 >            assertEquals(1, p.getTaskCount());
455 >            assertEquals(0, p.getCompletedTaskCount());
456 >            for (int i = 0; i < TASKS; i++) {
457 >                assertEquals(1 + i, p.getTaskCount());
458                  p.execute(new CheckedRunnable() {
459                      public void realRun() throws InterruptedException {
460                          threadStarted.countDown();
461 <                        done.await();
461 >                        assertEquals(1 + TASKS, p.getTaskCount());
462 >                        await(done);
463                      }});
464 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
465 <            assertEquals(TASKS, p.getTaskCount());
466 <            done.countDown();
464 >            }
465 >            assertEquals(1 + TASKS, p.getTaskCount());
466 >            assertEquals(0, p.getCompletedTaskCount());
467          }
468 +        assertEquals(1 + TASKS, p.getTaskCount());
469 +        assertEquals(1 + TASKS, p.getCompletedTaskCount());
470      }
471  
472      /**
473       * getThreadFactory returns factory in constructor if not set
474       */
475      public void testGetThreadFactory() throws InterruptedException {
476 <        ThreadFactory threadFactory = new SimpleThreadFactory();
477 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1, threadFactory);
478 <        assertSame(threadFactory, p.getThreadFactory());
479 <        joinPool(p);
476 >        final ThreadFactory threadFactory = new SimpleThreadFactory();
477 >        final ScheduledThreadPoolExecutor p =
478 >            new ScheduledThreadPoolExecutor(1, threadFactory);
479 >        try (PoolCleaner cleaner = cleaner(p)) {
480 >            assertSame(threadFactory, p.getThreadFactory());
481 >        }
482      }
483  
484      /**
# Line 449 | Line 486 | public class ScheduledExecutorTest exten
486       */
487      public void testSetThreadFactory() throws InterruptedException {
488          ThreadFactory threadFactory = new SimpleThreadFactory();
489 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
489 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
490          try (PoolCleaner cleaner = cleaner(p)) {
491              p.setThreadFactory(threadFactory);
492              assertSame(threadFactory, p.getThreadFactory());
# Line 460 | Line 497 | public class ScheduledExecutorTest exten
497       * setThreadFactory(null) throws NPE
498       */
499      public void testSetThreadFactoryNull() throws InterruptedException {
500 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
500 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
501          try (PoolCleaner cleaner = cleaner(p)) {
502              try {
503                  p.setThreadFactory(null);
# Line 473 | Line 510 | public class ScheduledExecutorTest exten
510       * isShutdown is false before shutdown, true after
511       */
512      public void testIsShutdown() {
513 <
514 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
515 <        try {
516 <            assertFalse(p.isShutdown());
517 <        }
518 <        finally {
519 <            try { p.shutdown(); } catch (SecurityException ok) { return; }
513 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
514 >        assertFalse(p.isShutdown());
515 >        try (PoolCleaner cleaner = cleaner(p)) {
516 >            try {
517 >                p.shutdown();
518 >                assertTrue(p.isShutdown());
519 >            } catch (SecurityException ok) {}
520          }
484 –        assertTrue(p.isShutdown());
521      }
522  
523      /**
# Line 497 | Line 533 | public class ScheduledExecutorTest exten
533                  public void realRun() throws InterruptedException {
534                      assertFalse(p.isTerminated());
535                      threadStarted.countDown();
536 <                    done.await();
536 >                    await(done);
537                  }});
538 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
538 >            await(threadStarted);
539              assertFalse(p.isTerminating());
540              done.countDown();
541              try { p.shutdown(); } catch (SecurityException ok) { return; }
# Line 521 | Line 557 | public class ScheduledExecutorTest exten
557                  public void realRun() throws InterruptedException {
558                      assertFalse(p.isTerminating());
559                      threadStarted.countDown();
560 <                    done.await();
560 >                    await(done);
561                  }});
562 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
562 >            await(threadStarted);
563              assertFalse(p.isTerminating());
564              done.countDown();
565              try { p.shutdown(); } catch (SecurityException ok) { return; }
# Line 537 | Line 573 | public class ScheduledExecutorTest exten
573       * getQueue returns the work queue, which contains queued tasks
574       */
575      public void testGetQueue() throws InterruptedException {
576 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
577 <        try (PoolCleaner cleaner = cleaner(p)) {
576 >        final CountDownLatch done = new CountDownLatch(1);
577 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
578 >        try (PoolCleaner cleaner = cleaner(p, done)) {
579              final CountDownLatch threadStarted = new CountDownLatch(1);
543 –            final CountDownLatch done = new CountDownLatch(1);
580              ScheduledFuture[] tasks = new ScheduledFuture[5];
581              for (int i = 0; i < tasks.length; i++) {
582                  Runnable r = new CheckedRunnable() {
583                      public void realRun() throws InterruptedException {
584                          threadStarted.countDown();
585 <                        done.await();
585 >                        await(done);
586                      }};
587                  tasks[i] = p.schedule(r, 1, MILLISECONDS);
588              }
589 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
589 >            await(threadStarted);
590              BlockingQueue<Runnable> q = p.getQueue();
591              assertTrue(q.contains(tasks[tasks.length - 1]));
592              assertFalse(q.contains(tasks[0]));
557 –            done.countDown();
593          }
594      }
595  
# Line 562 | Line 597 | public class ScheduledExecutorTest exten
597       * remove(task) removes queued task, and fails to remove active task
598       */
599      public void testRemove() throws InterruptedException {
600 +        final CountDownLatch done = new CountDownLatch(1);
601          final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
602 <        try (PoolCleaner cleaner = cleaner(p)) {
602 >        try (PoolCleaner cleaner = cleaner(p, done)) {
603              ScheduledFuture[] tasks = new ScheduledFuture[5];
604              final CountDownLatch threadStarted = new CountDownLatch(1);
569 –            final CountDownLatch done = new CountDownLatch(1);
605              for (int i = 0; i < tasks.length; i++) {
606                  Runnable r = new CheckedRunnable() {
607                      public void realRun() throws InterruptedException {
608                          threadStarted.countDown();
609 <                        done.await();
609 >                        await(done);
610                      }};
611                  tasks[i] = p.schedule(r, 1, MILLISECONDS);
612              }
613 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
613 >            await(threadStarted);
614              BlockingQueue<Runnable> q = p.getQueue();
615              assertFalse(p.remove((Runnable)tasks[0]));
616              assertTrue(q.contains((Runnable)tasks[4]));
# Line 586 | Line 621 | public class ScheduledExecutorTest exten
621              assertTrue(q.contains((Runnable)tasks[3]));
622              assertTrue(p.remove((Runnable)tasks[3]));
623              assertFalse(q.contains((Runnable)tasks[3]));
589 –            done.countDown();
624          }
625      }
626  
# Line 594 | Line 628 | public class ScheduledExecutorTest exten
628       * purge eventually removes cancelled tasks from the queue
629       */
630      public void testPurge() throws InterruptedException {
631 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
632 <        ScheduledFuture[] tasks = new ScheduledFuture[5];
633 <        for (int i = 0; i < tasks.length; i++)
634 <            tasks[i] = p.schedule(new SmallPossiblyInterruptedRunnable(),
635 <                                  LONG_DELAY_MS, MILLISECONDS);
636 <        try {
631 >        final ScheduledFuture[] tasks = new ScheduledFuture[5];
632 >        final Runnable releaser = new Runnable() { public void run() {
633 >            for (ScheduledFuture task : tasks)
634 >                if (task != null) task.cancel(true); }};
635 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
636 >        try (PoolCleaner cleaner = cleaner(p, releaser)) {
637 >            for (int i = 0; i < tasks.length; i++)
638 >                tasks[i] = p.schedule(new SmallPossiblyInterruptedRunnable(),
639 >                                      LONG_DELAY_MS, MILLISECONDS);
640              int max = tasks.length;
641              if (tasks[4].cancel(true)) --max;
642              if (tasks[3].cancel(true)) --max;
# Line 611 | Line 648 | public class ScheduledExecutorTest exten
648                  long count = p.getTaskCount();
649                  if (count == max)
650                      return;
651 <            } while (millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
651 >            } while (millisElapsedSince(startTime) < LONG_DELAY_MS);
652              fail("Purge failed to remove cancelled tasks");
616 –        } finally {
617 –            for (ScheduledFuture task : tasks)
618 –                task.cancel(true);
619 –            joinPool(p);
653          }
654      }
655  
# Line 630 | Line 663 | public class ScheduledExecutorTest exten
663          final AtomicInteger ran = new AtomicInteger(0);
664          final ScheduledThreadPoolExecutor p =
665              new ScheduledThreadPoolExecutor(poolSize);
666 <        CountDownLatch threadsStarted = new CountDownLatch(poolSize);
666 >        final CountDownLatch threadsStarted = new CountDownLatch(poolSize);
667          Runnable waiter = new CheckedRunnable() { public void realRun() {
668              threadsStarted.countDown();
669              try {
# Line 640 | Line 673 | public class ScheduledExecutorTest exten
673          }};
674          for (int i = 0; i < count; i++)
675              p.execute(waiter);
676 <        assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
676 >        await(threadsStarted);
677          assertEquals(poolSize, p.getActiveCount());
678          assertEquals(0, p.getCompletedTaskCount());
679          final List<Runnable> queuedTasks;
# Line 663 | Line 696 | public class ScheduledExecutorTest exten
696       * and those tasks are drained from the queue
697       */
698      public void testShutdownNow_delayedTasks() throws InterruptedException {
699 <        ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
699 >        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
700          List<ScheduledFuture> tasks = new ArrayList<>();
701          for (int i = 0; i < 3; i++) {
702              Runnable r = new NoOpRunnable();
# Line 855 | Line 888 | public class ScheduledExecutorTest exten
888          CountDownLatch latch = new CountDownLatch(1);
889          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
890          try (PoolCleaner cleaner = cleaner(e)) {
891 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
891 >            List<Callable<String>> l = new ArrayList<>();
892              l.add(latchAwaitingStringTask(latch));
893              l.add(null);
894              try {
# Line 872 | Line 905 | public class ScheduledExecutorTest exten
905      public void testInvokeAny4() throws Exception {
906          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
907          try (PoolCleaner cleaner = cleaner(e)) {
908 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
908 >            List<Callable<String>> l = new ArrayList<>();
909              l.add(new NPETask());
910              try {
911                  e.invokeAny(l);
# Line 889 | Line 922 | public class ScheduledExecutorTest exten
922      public void testInvokeAny5() throws Exception {
923          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
924          try (PoolCleaner cleaner = cleaner(e)) {
925 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
925 >            List<Callable<String>> l = new ArrayList<>();
926              l.add(new StringTask());
927              l.add(new StringTask());
928              String result = e.invokeAny(l);
# Line 927 | Line 960 | public class ScheduledExecutorTest exten
960      public void testInvokeAll3() throws Exception {
961          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
962          try (PoolCleaner cleaner = cleaner(e)) {
963 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
963 >            List<Callable<String>> l = new ArrayList<>();
964              l.add(new StringTask());
965              l.add(null);
966              try {
# Line 943 | Line 976 | public class ScheduledExecutorTest exten
976      public void testInvokeAll4() throws Exception {
977          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
978          try (PoolCleaner cleaner = cleaner(e)) {
979 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
979 >            List<Callable<String>> l = new ArrayList<>();
980              l.add(new NPETask());
981              List<Future<String>> futures = e.invokeAll(l);
982              assertEquals(1, futures.size());
# Line 962 | Line 995 | public class ScheduledExecutorTest exten
995      public void testInvokeAll5() throws Exception {
996          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
997          try (PoolCleaner cleaner = cleaner(e)) {
998 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
998 >            List<Callable<String>> l = new ArrayList<>();
999              l.add(new StringTask());
1000              l.add(new StringTask());
1001              List<Future<String>> futures = e.invokeAll(l);
# Line 991 | Line 1024 | public class ScheduledExecutorTest exten
1024      public void testTimedInvokeAnyNullTimeUnit() throws Exception {
1025          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1026          try (PoolCleaner cleaner = cleaner(e)) {
1027 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1027 >            List<Callable<String>> l = new ArrayList<>();
1028              l.add(new StringTask());
1029              try {
1030                  e.invokeAny(l, MEDIUM_DELAY_MS, null);
# Line 1020 | Line 1053 | public class ScheduledExecutorTest exten
1053          CountDownLatch latch = new CountDownLatch(1);
1054          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1055          try (PoolCleaner cleaner = cleaner(e)) {
1056 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1056 >            List<Callable<String>> l = new ArrayList<>();
1057              l.add(latchAwaitingStringTask(latch));
1058              l.add(null);
1059              try {
# Line 1037 | Line 1070 | public class ScheduledExecutorTest exten
1070      public void testTimedInvokeAny4() throws Exception {
1071          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1072          try (PoolCleaner cleaner = cleaner(e)) {
1073 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1073 >            long startTime = System.nanoTime();
1074 >            List<Callable<String>> l = new ArrayList<>();
1075              l.add(new NPETask());
1076              try {
1077 <                e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1077 >                e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
1078                  shouldThrow();
1079              } catch (ExecutionException success) {
1080                  assertTrue(success.getCause() instanceof NullPointerException);
1081              }
1082 +            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1083          }
1084      }
1085  
# Line 1054 | Line 1089 | public class ScheduledExecutorTest exten
1089      public void testTimedInvokeAny5() throws Exception {
1090          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1091          try (PoolCleaner cleaner = cleaner(e)) {
1092 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1092 >            long startTime = System.nanoTime();
1093 >            List<Callable<String>> l = new ArrayList<>();
1094              l.add(new StringTask());
1095              l.add(new StringTask());
1096 <            String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1096 >            String result = e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
1097              assertSame(TEST_STRING, result);
1098 +            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1099          }
1100      }
1101  
# Line 1081 | Line 1118 | public class ScheduledExecutorTest exten
1118      public void testTimedInvokeAllNullTimeUnit() throws Exception {
1119          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1120          try (PoolCleaner cleaner = cleaner(e)) {
1121 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1121 >            List<Callable<String>> l = new ArrayList<>();
1122              l.add(new StringTask());
1123              try {
1124                  e.invokeAll(l, MEDIUM_DELAY_MS, null);
# Line 1108 | Line 1145 | public class ScheduledExecutorTest exten
1145      public void testTimedInvokeAll3() throws Exception {
1146          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1147          try (PoolCleaner cleaner = cleaner(e)) {
1148 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1148 >            List<Callable<String>> l = new ArrayList<>();
1149              l.add(new StringTask());
1150              l.add(null);
1151              try {
# Line 1124 | Line 1161 | public class ScheduledExecutorTest exten
1161      public void testTimedInvokeAll4() throws Exception {
1162          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1163          try (PoolCleaner cleaner = cleaner(e)) {
1164 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1164 >            List<Callable<String>> l = new ArrayList<>();
1165              l.add(new NPETask());
1166              List<Future<String>> futures =
1167 <                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1167 >                e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
1168              assertEquals(1, futures.size());
1169              try {
1170                  futures.get(0).get();
# Line 1144 | Line 1181 | public class ScheduledExecutorTest exten
1181      public void testTimedInvokeAll5() throws Exception {
1182          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1183          try (PoolCleaner cleaner = cleaner(e)) {
1184 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1184 >            List<Callable<String>> l = new ArrayList<>();
1185              l.add(new StringTask());
1186              l.add(new StringTask());
1187              List<Future<String>> futures =
# Line 1159 | Line 1196 | public class ScheduledExecutorTest exten
1196       * timed invokeAll(c) cancels tasks not completed by timeout
1197       */
1198      public void testTimedInvokeAll6() throws Exception {
1199 <        final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1200 <        try (PoolCleaner cleaner = cleaner(e)) {
1201 <            for (long timeout = timeoutMillis();;) {
1199 >        for (long timeout = timeoutMillis();;) {
1200 >            final CountDownLatch done = new CountDownLatch(1);
1201 >            final Callable<String> waiter = new CheckedCallable<String>() {
1202 >                public String realCall() {
1203 >                    try { done.await(LONG_DELAY_MS, MILLISECONDS); }
1204 >                    catch (InterruptedException ok) {}
1205 >                    return "1"; }};
1206 >            final ExecutorService p = new ScheduledThreadPoolExecutor(2);
1207 >            try (PoolCleaner cleaner = cleaner(p, done)) {
1208                  List<Callable<String>> tasks = new ArrayList<>();
1209                  tasks.add(new StringTask("0"));
1210 <                tasks.add(Executors.callable(new LongPossiblyInterruptedRunnable(), TEST_STRING));
1210 >                tasks.add(waiter);
1211                  tasks.add(new StringTask("2"));
1212                  long startTime = System.nanoTime();
1213                  List<Future<String>> futures =
1214 <                    e.invokeAll(tasks, timeout, MILLISECONDS);
1214 >                    p.invokeAll(tasks, timeout, MILLISECONDS);
1215                  assertEquals(tasks.size(), futures.size());
1216                  assertTrue(millisElapsedSince(startTime) >= timeout);
1217                  for (Future future : futures)
# Line 1187 | Line 1230 | public class ScheduledExecutorTest exten
1230          }
1231      }
1232  
1233 +    /**
1234 +     * A fixed delay task with overflowing period should not prevent a
1235 +     * one-shot task from executing.
1236 +     * https://bugs.openjdk.java.net/browse/JDK-8051859
1237 +     */
1238 +    public void testScheduleWithFixedDelay_overflow() throws Exception {
1239 +        final CountDownLatch delayedDone = new CountDownLatch(1);
1240 +        final CountDownLatch immediateDone = new CountDownLatch(1);
1241 +        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
1242 +        try (PoolCleaner cleaner = cleaner(p)) {
1243 +            final Runnable immediate = new Runnable() { public void run() {
1244 +                immediateDone.countDown();
1245 +            }};
1246 +            final Runnable delayed = new Runnable() { public void run() {
1247 +                delayedDone.countDown();
1248 +                p.submit(immediate);
1249 +            }};
1250 +            p.scheduleWithFixedDelay(delayed, 0L, Long.MAX_VALUE, SECONDS);
1251 +            await(delayedDone);
1252 +            await(immediateDone);
1253 +        }
1254 +    }
1255 +
1256   }

Diff Legend

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