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.82 by jsr166, Thu Sep 15 17:31:16 2016 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());
834                  assertTrue(periodic.isDone());
835              }
836          }
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
# Line 888 | Line 918 | public class ScheduledExecutorTest exten
918          CountDownLatch latch = new CountDownLatch(1);
919          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
920          try (PoolCleaner cleaner = cleaner(e)) {
921 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
921 >            List<Callable<String>> l = new ArrayList<>();
922              l.add(latchAwaitingStringTask(latch));
923              l.add(null);
924              try {
# Line 905 | Line 935 | public class ScheduledExecutorTest exten
935      public void testInvokeAny4() throws Exception {
936          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
937          try (PoolCleaner cleaner = cleaner(e)) {
938 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
938 >            List<Callable<String>> l = new ArrayList<>();
939              l.add(new NPETask());
940              try {
941                  e.invokeAny(l);
# Line 922 | Line 952 | public class ScheduledExecutorTest exten
952      public void testInvokeAny5() throws Exception {
953          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
954          try (PoolCleaner cleaner = cleaner(e)) {
955 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
955 >            List<Callable<String>> l = new ArrayList<>();
956              l.add(new StringTask());
957              l.add(new StringTask());
958              String result = e.invokeAny(l);
# Line 960 | Line 990 | public class ScheduledExecutorTest exten
990      public void testInvokeAll3() throws Exception {
991          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
992          try (PoolCleaner cleaner = cleaner(e)) {
993 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
993 >            List<Callable<String>> l = new ArrayList<>();
994              l.add(new StringTask());
995              l.add(null);
996              try {
# Line 976 | Line 1006 | public class ScheduledExecutorTest exten
1006      public void testInvokeAll4() throws Exception {
1007          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1008          try (PoolCleaner cleaner = cleaner(e)) {
1009 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1009 >            List<Callable<String>> l = new ArrayList<>();
1010              l.add(new NPETask());
1011              List<Future<String>> futures = e.invokeAll(l);
1012              assertEquals(1, futures.size());
# Line 995 | Line 1025 | public class ScheduledExecutorTest exten
1025      public void testInvokeAll5() throws Exception {
1026          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1027          try (PoolCleaner cleaner = cleaner(e)) {
1028 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1028 >            List<Callable<String>> l = new ArrayList<>();
1029              l.add(new StringTask());
1030              l.add(new StringTask());
1031              List<Future<String>> futures = e.invokeAll(l);
# Line 1024 | Line 1054 | public class ScheduledExecutorTest exten
1054      public void testTimedInvokeAnyNullTimeUnit() throws Exception {
1055          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1056          try (PoolCleaner cleaner = cleaner(e)) {
1057 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1057 >            List<Callable<String>> l = new ArrayList<>();
1058              l.add(new StringTask());
1059              try {
1060                  e.invokeAny(l, MEDIUM_DELAY_MS, null);
# Line 1053 | Line 1083 | public class ScheduledExecutorTest exten
1083          CountDownLatch latch = new CountDownLatch(1);
1084          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1085          try (PoolCleaner cleaner = cleaner(e)) {
1086 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1086 >            List<Callable<String>> l = new ArrayList<>();
1087              l.add(latchAwaitingStringTask(latch));
1088              l.add(null);
1089              try {
# Line 1071 | Line 1101 | public class ScheduledExecutorTest exten
1101          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1102          try (PoolCleaner cleaner = cleaner(e)) {
1103              long startTime = System.nanoTime();
1104 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1104 >            List<Callable<String>> l = new ArrayList<>();
1105              l.add(new NPETask());
1106              try {
1107                  e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
# Line 1090 | Line 1120 | public class ScheduledExecutorTest exten
1120          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1121          try (PoolCleaner cleaner = cleaner(e)) {
1122              long startTime = System.nanoTime();
1123 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1123 >            List<Callable<String>> l = new ArrayList<>();
1124              l.add(new StringTask());
1125              l.add(new StringTask());
1126              String result = e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
# Line 1118 | Line 1148 | public class ScheduledExecutorTest exten
1148      public void testTimedInvokeAllNullTimeUnit() throws Exception {
1149          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1150          try (PoolCleaner cleaner = cleaner(e)) {
1151 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1151 >            List<Callable<String>> l = new ArrayList<>();
1152              l.add(new StringTask());
1153              try {
1154                  e.invokeAll(l, MEDIUM_DELAY_MS, null);
# Line 1145 | Line 1175 | public class ScheduledExecutorTest exten
1175      public void testTimedInvokeAll3() throws Exception {
1176          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1177          try (PoolCleaner cleaner = cleaner(e)) {
1178 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1178 >            List<Callable<String>> l = new ArrayList<>();
1179              l.add(new StringTask());
1180              l.add(null);
1181              try {
# Line 1161 | Line 1191 | public class ScheduledExecutorTest exten
1191      public void testTimedInvokeAll4() throws Exception {
1192          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1193          try (PoolCleaner cleaner = cleaner(e)) {
1194 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1194 >            List<Callable<String>> l = new ArrayList<>();
1195              l.add(new NPETask());
1196              List<Future<String>> futures =
1197                  e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
# Line 1181 | Line 1211 | public class ScheduledExecutorTest exten
1211      public void testTimedInvokeAll5() throws Exception {
1212          final ExecutorService e = new ScheduledThreadPoolExecutor(2);
1213          try (PoolCleaner cleaner = cleaner(e)) {
1214 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1214 >            List<Callable<String>> l = new ArrayList<>();
1215              l.add(new StringTask());
1216              l.add(new StringTask());
1217              List<Future<String>> futures =

Diff Legend

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