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.84 by jsr166, Mon Mar 20 00:34:27 2017 UTC vs.
Revision 1.88 by jsr166, Sun Mar 26 02:00:39 2017 UTC

# Line 24 | Line 24 | import java.util.concurrent.RejectedExec
24   import java.util.concurrent.ScheduledFuture;
25   import java.util.concurrent.ScheduledThreadPoolExecutor;
26   import java.util.concurrent.ThreadFactory;
27 + import java.util.concurrent.ThreadLocalRandom;
28   import java.util.concurrent.ThreadPoolExecutor;
29   import java.util.concurrent.atomic.AtomicBoolean;
30   import java.util.concurrent.atomic.AtomicInteger;
# Line 50 | Line 51 | public class ScheduledExecutorTest exten
51              final Runnable task = new CheckedRunnable() {
52                  public void realRun() { done.countDown(); }};
53              p.execute(task);
54 <            assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
54 >            await(done);
55          }
56      }
57  
# Line 362 | Line 363 | public class ScheduledExecutorTest exten
363                  public void realRun() throws InterruptedException {
364                      threadStarted.countDown();
365                      assertEquals(0, p.getCompletedTaskCount());
366 <                    threadProceed.await();
366 >                    await(threadProceed);
367                      threadDone.countDown();
368                  }});
369              await(threadStarted);
370              assertEquals(0, p.getCompletedTaskCount());
371              threadProceed.countDown();
372 <            threadDone.await();
372 >            await(threadDone);
373              long startTime = System.nanoTime();
374              while (p.getCompletedTaskCount() != 1) {
375                  if (millisElapsedSince(startTime) > LONG_DELAY_MS)
# Line 507 | Line 508 | public class ScheduledExecutorTest exten
508      }
509  
510      /**
511 +     * The default rejected execution handler is AbortPolicy.
512 +     */
513 +    public void testDefaultRejectedExecutionHandler() {
514 +        final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
515 +        try (PoolCleaner cleaner = cleaner(p)) {
516 +            assertTrue(p.getRejectedExecutionHandler()
517 +                       instanceof ThreadPoolExecutor.AbortPolicy);
518 +        }
519 +    }
520 +
521 +    /**
522       * isShutdown is false before shutdown, true after
523       */
524      public void testIsShutdown() {
# Line 733 | Line 745 | public class ScheduledExecutorTest exten
745       * - setContinueExistingPeriodicTasksAfterShutdownPolicy
746       */
747      public void testShutdown_cancellation() throws Exception {
736 –        Boolean[] allBooleans = { null, Boolean.FALSE, Boolean.TRUE };
737 –        for (Boolean policy : allBooleans)
738 –    {
748          final int poolSize = 2;
749          final ScheduledThreadPoolExecutor p
750              = new ScheduledThreadPoolExecutor(poolSize);
751 <        final boolean effectiveDelayedPolicy = (policy != Boolean.FALSE);
752 <        final boolean effectivePeriodicPolicy = (policy == Boolean.TRUE);
753 <        final boolean effectiveRemovePolicy = (policy == Boolean.TRUE);
754 <        if (policy != null) {
755 <            p.setExecuteExistingDelayedTasksAfterShutdownPolicy(policy);
756 <            p.setContinueExistingPeriodicTasksAfterShutdownPolicy(policy);
757 <            p.setRemoveOnCancelPolicy(policy);
758 <        }
751 >        final ThreadLocalRandom rnd = ThreadLocalRandom.current();
752 >        final boolean effectiveDelayedPolicy;
753 >        final boolean effectivePeriodicPolicy;
754 >        final boolean effectiveRemovePolicy;
755 >
756 >        if (rnd.nextBoolean())
757 >            p.setExecuteExistingDelayedTasksAfterShutdownPolicy(
758 >                effectiveDelayedPolicy = rnd.nextBoolean());
759 >        else
760 >            effectiveDelayedPolicy = true;
761          assertEquals(effectiveDelayedPolicy,
762                       p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
763 +
764 +        if (rnd.nextBoolean())
765 +            p.setContinueExistingPeriodicTasksAfterShutdownPolicy(
766 +                effectivePeriodicPolicy = rnd.nextBoolean());
767 +        else
768 +            effectivePeriodicPolicy = false;
769          assertEquals(effectivePeriodicPolicy,
770                       p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
771 +
772 +        if (rnd.nextBoolean())
773 +            p.setRemoveOnCancelPolicy(
774 +                effectiveRemovePolicy = rnd.nextBoolean());
775 +        else
776 +            effectiveRemovePolicy = false;
777          assertEquals(effectiveRemovePolicy,
778                       p.getRemoveOnCancelPolicy());
779 +
780          // Strategy: Wedge the pool with poolSize "blocker" threads
781          final AtomicInteger ran = new AtomicInteger(0);
782          final CountDownLatch poolBlocked = new CountDownLatch(poolSize);
# Line 762 | Line 786 | public class ScheduledExecutorTest exten
786          Runnable task = new CheckedRunnable() { public void realRun()
787                                                      throws InterruptedException {
788              poolBlocked.countDown();
789 <            assertTrue(unblock.await(LONG_DELAY_MS, MILLISECONDS));
789 >            await(unblock);
790              ran.getAndIncrement();
791          }};
792          List<Future<?>> blockers = new ArrayList<>();
# Line 770 | Line 794 | public class ScheduledExecutorTest exten
794          List<Future<?>> delayeds = new ArrayList<>();
795          for (int i = 0; i < poolSize; i++)
796              blockers.add(p.submit(task));
797 <        assertTrue(poolBlocked.await(LONG_DELAY_MS, MILLISECONDS));
797 >        await(poolBlocked);
798  
799 <        periodics.add(p.scheduleAtFixedRate(countDowner(periodicLatch1),
800 <                                            1, 1, MILLISECONDS));
801 <        periodics.add(p.scheduleWithFixedDelay(countDowner(periodicLatch2),
802 <                                               1, 1, MILLISECONDS));
799 >        periodics.add(p.scheduleAtFixedRate(
800 >                          countDowner(periodicLatch1), 1, 1, MILLISECONDS));
801 >        periodics.add(p.scheduleWithFixedDelay(
802 >                          countDowner(periodicLatch2), 1, 1, MILLISECONDS));
803          delayeds.add(p.schedule(task, 1, MILLISECONDS));
804  
805          assertTrue(p.getQueue().containsAll(periodics));
# Line 797 | Line 821 | public class ScheduledExecutorTest exten
821              assertEquals(effectiveDelayedPolicy,
822                           p.getQueue().containsAll(delayeds));
823          }
824 <        // Release all pool threads
801 <        unblock.countDown();
824 >        unblock.countDown();    // Release all pool threads
825  
826 <        for (Future<?> delayed : delayeds) {
827 <            if (effectiveDelayedPolicy) {
805 <                assertNull(delayed.get());
806 <            }
807 <        }
826 >        if (effectiveDelayedPolicy)
827 >            for (Future<?> delayed : delayeds) assertNull(delayed.get());
828          if (effectivePeriodicPolicy) {
829 <            assertTrue(periodicLatch1.await(LONG_DELAY_MS, MILLISECONDS));
830 <            assertTrue(periodicLatch2.await(LONG_DELAY_MS, MILLISECONDS));
829 >            await(periodicLatch1);
830 >            await(periodicLatch2);
831              for (Future<?> periodic : periodics) {
832                  assertTrue(periodic.cancel(false));
833                  assertTrue(periodic.isCancelled());
# Line 817 | Line 837 | public class ScheduledExecutorTest exten
837          for (Future<?> blocker : blockers) assertNull(blocker.get());
838          assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
839          assertTrue(p.isTerminated());
840 +
841 +        for (Future<?> future : delayeds) {
842 +            assertTrue(effectiveDelayedPolicy ^ future.isCancelled());
843 +            assertTrue(future.isDone());
844 +        }
845 +        for (Future<?> future : periodics)
846 +            assertTrue(future.isCancelled());
847 +        for (Future<?> future : blockers)
848 +            assertNull(future.get());
849          assertEquals(2 + (effectiveDelayedPolicy ? 1 : 0), ran.get());
850 <    }}
850 >    }
851  
852      /**
853       * completed submit of callable returns result

Diff Legend

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