--- jsr166/src/test/tck/ScheduledExecutorTest.java	2017/03/20 00:34:27	1.84
+++ jsr166/src/test/tck/ScheduledExecutorTest.java	2017/03/26 02:00:39	1.88
@@ -24,6 +24,7 @@ import java.util.concurrent.RejectedExec
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.ScheduledThreadPoolExecutor;
 import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -50,7 +51,7 @@ public class ScheduledExecutorTest exten
             final Runnable task = new CheckedRunnable() {
                 public void realRun() { done.countDown(); }};
             p.execute(task);
-            assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
+            await(done);
         }
     }
 
@@ -362,13 +363,13 @@ public class ScheduledExecutorTest exten
                 public void realRun() throws InterruptedException {
                     threadStarted.countDown();
                     assertEquals(0, p.getCompletedTaskCount());
-                    threadProceed.await();
+                    await(threadProceed);
                     threadDone.countDown();
                 }});
             await(threadStarted);
             assertEquals(0, p.getCompletedTaskCount());
             threadProceed.countDown();
-            threadDone.await();
+            await(threadDone);
             long startTime = System.nanoTime();
             while (p.getCompletedTaskCount() != 1) {
                 if (millisElapsedSince(startTime) > LONG_DELAY_MS)
@@ -507,6 +508,17 @@ public class ScheduledExecutorTest exten
     }
 
     /**
+     * The default rejected execution handler is AbortPolicy.
+     */
+    public void testDefaultRejectedExecutionHandler() {
+        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
+        try (PoolCleaner cleaner = cleaner(p)) {
+            assertTrue(p.getRejectedExecutionHandler()
+                       instanceof ThreadPoolExecutor.AbortPolicy);
+        }
+    }
+
+    /**
      * isShutdown is false before shutdown, true after
      */
     public void testIsShutdown() {
@@ -733,26 +745,38 @@ public class ScheduledExecutorTest exten
      * - setContinueExistingPeriodicTasksAfterShutdownPolicy
      */
     public void testShutdown_cancellation() throws Exception {
-        Boolean[] allBooleans = { null, Boolean.FALSE, Boolean.TRUE };
-        for (Boolean policy : allBooleans)
-    {
         final int poolSize = 2;
         final ScheduledThreadPoolExecutor p
             = new ScheduledThreadPoolExecutor(poolSize);
-        final boolean effectiveDelayedPolicy = (policy != Boolean.FALSE);
-        final boolean effectivePeriodicPolicy = (policy == Boolean.TRUE);
-        final boolean effectiveRemovePolicy = (policy == Boolean.TRUE);
-        if (policy != null) {
-            p.setExecuteExistingDelayedTasksAfterShutdownPolicy(policy);
-            p.setContinueExistingPeriodicTasksAfterShutdownPolicy(policy);
-            p.setRemoveOnCancelPolicy(policy);
-        }
+        final ThreadLocalRandom rnd = ThreadLocalRandom.current();
+        final boolean effectiveDelayedPolicy;
+        final boolean effectivePeriodicPolicy;
+        final boolean effectiveRemovePolicy;
+
+        if (rnd.nextBoolean())
+            p.setExecuteExistingDelayedTasksAfterShutdownPolicy(
+                effectiveDelayedPolicy = rnd.nextBoolean());
+        else
+            effectiveDelayedPolicy = true;
         assertEquals(effectiveDelayedPolicy,
                      p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
+
+        if (rnd.nextBoolean())
+            p.setContinueExistingPeriodicTasksAfterShutdownPolicy(
+                effectivePeriodicPolicy = rnd.nextBoolean());
+        else
+            effectivePeriodicPolicy = false;
         assertEquals(effectivePeriodicPolicy,
                      p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
+
+        if (rnd.nextBoolean())
+            p.setRemoveOnCancelPolicy(
+                effectiveRemovePolicy = rnd.nextBoolean());
+        else
+            effectiveRemovePolicy = false;
         assertEquals(effectiveRemovePolicy,
                      p.getRemoveOnCancelPolicy());
+
         // Strategy: Wedge the pool with poolSize "blocker" threads
         final AtomicInteger ran = new AtomicInteger(0);
         final CountDownLatch poolBlocked = new CountDownLatch(poolSize);
@@ -762,7 +786,7 @@ public class ScheduledExecutorTest exten
         Runnable task = new CheckedRunnable() { public void realRun()
                                                     throws InterruptedException {
             poolBlocked.countDown();
-            assertTrue(unblock.await(LONG_DELAY_MS, MILLISECONDS));
+            await(unblock);
             ran.getAndIncrement();
         }};
         List<Future<?>> blockers = new ArrayList<>();
@@ -770,12 +794,12 @@ public class ScheduledExecutorTest exten
         List<Future<?>> delayeds = new ArrayList<>();
         for (int i = 0; i < poolSize; i++)
             blockers.add(p.submit(task));
-        assertTrue(poolBlocked.await(LONG_DELAY_MS, MILLISECONDS));
+        await(poolBlocked);
 
-        periodics.add(p.scheduleAtFixedRate(countDowner(periodicLatch1),
-                                            1, 1, MILLISECONDS));
-        periodics.add(p.scheduleWithFixedDelay(countDowner(periodicLatch2),
-                                               1, 1, MILLISECONDS));
+        periodics.add(p.scheduleAtFixedRate(
+                          countDowner(periodicLatch1), 1, 1, MILLISECONDS));
+        periodics.add(p.scheduleWithFixedDelay(
+                          countDowner(periodicLatch2), 1, 1, MILLISECONDS));
         delayeds.add(p.schedule(task, 1, MILLISECONDS));
 
         assertTrue(p.getQueue().containsAll(periodics));
@@ -797,17 +821,13 @@ public class ScheduledExecutorTest exten
             assertEquals(effectiveDelayedPolicy,
                          p.getQueue().containsAll(delayeds));
         }
-        // Release all pool threads
-        unblock.countDown();
+        unblock.countDown();    // Release all pool threads
 
-        for (Future<?> delayed : delayeds) {
-            if (effectiveDelayedPolicy) {
-                assertNull(delayed.get());
-            }
-        }
+        if (effectiveDelayedPolicy)
+            for (Future<?> delayed : delayeds) assertNull(delayed.get());
         if (effectivePeriodicPolicy) {
-            assertTrue(periodicLatch1.await(LONG_DELAY_MS, MILLISECONDS));
-            assertTrue(periodicLatch2.await(LONG_DELAY_MS, MILLISECONDS));
+            await(periodicLatch1);
+            await(periodicLatch2);
             for (Future<?> periodic : periodics) {
                 assertTrue(periodic.cancel(false));
                 assertTrue(periodic.isCancelled());
@@ -817,8 +837,17 @@ public class ScheduledExecutorTest exten
         for (Future<?> blocker : blockers) assertNull(blocker.get());
         assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
         assertTrue(p.isTerminated());
+
+        for (Future<?> future : delayeds) {
+            assertTrue(effectiveDelayedPolicy ^ future.isCancelled());
+            assertTrue(future.isDone());
+        }
+        for (Future<?> future : periodics)
+            assertTrue(future.isCancelled());
+        for (Future<?> future : blockers)
+            assertNull(future.get());
         assertEquals(2 + (effectiveDelayedPolicy ? 1 : 0), ran.get());
-    }}
+    }
 
     /**
      * completed submit of callable returns result