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

Comparing jsr166/src/test/tck/ThreadPoolExecutorSubclassTest.java (file contents):
Revision 1.64 by jsr166, Sun Oct 4 02:09:57 2015 UTC vs.
Revision 1.75 by jsr166, Sun Oct 4 03:27:46 2015 UTC

# Line 252 | Line 252 | public class ThreadPoolExecutorSubclassT
252              new CustomTPE(2, 2,
253                            LONG_DELAY_MS, MILLISECONDS,
254                            new ArrayBlockingQueue<Runnable>(10));
255 –        final CountDownLatch threadStarted = new CountDownLatch(1);
256 –        final CountDownLatch done = new CountDownLatch(1);
255          try (PoolCleaner cleaner = cleaner(p)) {
256 +            final CountDownLatch threadStarted = new CountDownLatch(1);
257 +            final CountDownLatch done = new CountDownLatch(1);
258              assertEquals(0, p.getActiveCount());
259              p.execute(new CheckedRunnable() {
260                  public void realRun() throws InterruptedException {
# Line 262 | Line 262 | public class ThreadPoolExecutorSubclassT
262                      assertEquals(1, p.getActiveCount());
263                      done.await();
264                  }});
265 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
265 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
266              assertEquals(1, p.getActiveCount());
267              done.countDown();
268          }
# Line 549 | Line 549 | public class ThreadPoolExecutorSubclassT
549              new CustomTPE(1, 1,
550                            LONG_DELAY_MS, MILLISECONDS,
551                            new ArrayBlockingQueue<Runnable>(10));
552 <        final CountDownLatch threadStarted = new CountDownLatch(1);
553 <        final CountDownLatch done = new CountDownLatch(1);
554 <        try {
552 >        try (PoolCleaner cleaner = cleaner(p)) {
553 >            final CountDownLatch threadStarted = new CountDownLatch(1);
554 >            final CountDownLatch done = new CountDownLatch(1);
555              assertEquals(0, p.getTaskCount());
556              p.execute(new CheckedRunnable() {
557                  public void realRun() throws InterruptedException {
# Line 559 | Line 559 | public class ThreadPoolExecutorSubclassT
559                      assertEquals(1, p.getTaskCount());
560                      done.await();
561                  }});
562 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
562 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
563              assertEquals(1, p.getTaskCount());
564 –        } finally {
564              done.countDown();
566 –            joinPool(p);
565          }
566      }
567  
# Line 571 | Line 569 | public class ThreadPoolExecutorSubclassT
569       * isShutdown is false before shutdown, true after
570       */
571      public void testIsShutdown() {
572 <
573 <        ThreadPoolExecutor p = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
574 <        assertFalse(p.isShutdown());
575 <        try { p.shutdown(); } catch (SecurityException ok) { return; }
576 <        assertTrue(p.isShutdown());
577 <        joinPool(p);
572 >        final ThreadPoolExecutor p =
573 >            new CustomTPE(1, 1,
574 >                          LONG_DELAY_MS, MILLISECONDS,
575 >                          new ArrayBlockingQueue<Runnable>(10));
576 >        try (PoolCleaner cleaner = cleaner(p)) {
577 >            assertFalse(p.isShutdown());
578 >            try { p.shutdown(); } catch (SecurityException ok) { return; }
579 >            assertTrue(p.isShutdown());
580 >        }
581      }
582  
583      /**
# Line 587 | Line 588 | public class ThreadPoolExecutorSubclassT
588              new CustomTPE(1, 1,
589                            LONG_DELAY_MS, MILLISECONDS,
590                            new ArrayBlockingQueue<Runnable>(10));
591 <        final CountDownLatch threadStarted = new CountDownLatch(1);
592 <        final CountDownLatch done = new CountDownLatch(1);
593 <        try {
591 >        try (PoolCleaner cleaner = cleaner(p)) {
592 >            final CountDownLatch threadStarted = new CountDownLatch(1);
593 >            final CountDownLatch done = new CountDownLatch(1);
594              assertFalse(p.isTerminating());
595              p.execute(new CheckedRunnable() {
596                  public void realRun() throws InterruptedException {
# Line 597 | Line 598 | public class ThreadPoolExecutorSubclassT
598                      threadStarted.countDown();
599                      done.await();
600                  }});
601 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
601 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
602              assertFalse(p.isTerminating());
603              done.countDown();
603 –        } finally {
604              try { p.shutdown(); } catch (SecurityException ok) { return; }
605 +            assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
606 +            assertTrue(p.isTerminated());
607 +            assertFalse(p.isTerminating());
608          }
606 –        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
607 –        assertTrue(p.isTerminated());
608 –        assertFalse(p.isTerminating());
609      }
610  
611      /**
# Line 616 | Line 616 | public class ThreadPoolExecutorSubclassT
616              new CustomTPE(1, 1,
617                            LONG_DELAY_MS, MILLISECONDS,
618                            new ArrayBlockingQueue<Runnable>(10));
619 <        final CountDownLatch threadStarted = new CountDownLatch(1);
620 <        final CountDownLatch done = new CountDownLatch(1);
621 <        try {
619 >        try (PoolCleaner cleaner = cleaner(p)) {
620 >            final CountDownLatch threadStarted = new CountDownLatch(1);
621 >            final CountDownLatch done = new CountDownLatch(1);
622              assertFalse(p.isTerminating());
623              p.execute(new CheckedRunnable() {
624                  public void realRun() throws InterruptedException {
# Line 626 | Line 626 | public class ThreadPoolExecutorSubclassT
626                      threadStarted.countDown();
627                      done.await();
628                  }});
629 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
629 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
630              assertFalse(p.isTerminating());
631              done.countDown();
632 –        } finally {
632              try { p.shutdown(); } catch (SecurityException ok) { return; }
633 +            assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
634 +            assertTrue(p.isTerminated());
635 +            assertFalse(p.isTerminating());
636          }
635 –        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
636 –        assertTrue(p.isTerminated());
637 –        assertFalse(p.isTerminating());
637      }
638  
639      /**
# Line 646 | Line 645 | public class ThreadPoolExecutorSubclassT
645              new CustomTPE(1, 1,
646                            LONG_DELAY_MS, MILLISECONDS,
647                            q);
648 <        final CountDownLatch threadStarted = new CountDownLatch(1);
649 <        final CountDownLatch done = new CountDownLatch(1);
650 <        try {
648 >        try (PoolCleaner cleaner = cleaner(p)) {
649 >            final CountDownLatch threadStarted = new CountDownLatch(1);
650 >            final CountDownLatch done = new CountDownLatch(1);
651              FutureTask[] tasks = new FutureTask[5];
652              for (int i = 0; i < tasks.length; i++) {
653                  Callable task = new CheckedCallable<Boolean>() {
# Line 661 | Line 660 | public class ThreadPoolExecutorSubclassT
660                  tasks[i] = new FutureTask(task);
661                  p.execute(tasks[i]);
662              }
663 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
663 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
664              assertSame(q, p.getQueue());
665              assertFalse(q.contains(tasks[0]));
666              assertTrue(q.contains(tasks[tasks.length - 1]));
667              assertEquals(tasks.length - 1, q.size());
669 –        } finally {
668              done.countDown();
671 –            joinPool(p);
669          }
670      }
671  
# Line 681 | Line 678 | public class ThreadPoolExecutorSubclassT
678              new CustomTPE(1, 1,
679                            LONG_DELAY_MS, MILLISECONDS,
680                            q);
681 <        Runnable[] tasks = new Runnable[6];
682 <        final CountDownLatch threadStarted = new CountDownLatch(1);
683 <        final CountDownLatch done = new CountDownLatch(1);
684 <        try {
681 >        try (PoolCleaner cleaner = cleaner(p)) {
682 >            Runnable[] tasks = new Runnable[6];
683 >            final CountDownLatch threadStarted = new CountDownLatch(1);
684 >            final CountDownLatch done = new CountDownLatch(1);
685              for (int i = 0; i < tasks.length; i++) {
686                  tasks[i] = new CheckedRunnable() {
687 <                        public void realRun() throws InterruptedException {
688 <                            threadStarted.countDown();
689 <                            done.await();
690 <                        }};
687 >                    public void realRun() throws InterruptedException {
688 >                        threadStarted.countDown();
689 >                        done.await();
690 >                    }};
691                  p.execute(tasks[i]);
692              }
693 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
693 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
694              assertFalse(p.remove(tasks[0]));
695              assertTrue(q.contains(tasks[4]));
696              assertTrue(q.contains(tasks[3]));
# Line 703 | Line 700 | public class ThreadPoolExecutorSubclassT
700              assertTrue(q.contains(tasks[3]));
701              assertTrue(p.remove(tasks[3]));
702              assertFalse(q.contains(tasks[3]));
706 –        } finally {
703              done.countDown();
708 –            joinPool(p);
704          }
705      }
706  
# Line 720 | Line 715 | public class ThreadPoolExecutorSubclassT
715              new CustomTPE(1, 1,
716                            LONG_DELAY_MS, MILLISECONDS,
717                            q);
718 <        FutureTask[] tasks = new FutureTask[5];
719 <        try {
718 >        try (PoolCleaner cleaner = cleaner(p)) {
719 >            FutureTask[] tasks = new FutureTask[5];
720              for (int i = 0; i < tasks.length; i++) {
721                  Callable task = new CheckedCallable<Boolean>() {
722                      public Boolean realCall() throws InterruptedException {
# Line 732 | Line 727 | public class ThreadPoolExecutorSubclassT
727                  tasks[i] = new FutureTask(task);
728                  p.execute(tasks[i]);
729              }
730 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
730 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
731              assertEquals(tasks.length, p.getTaskCount());
732              assertEquals(tasks.length - 1, q.size());
733              assertEquals(1L, p.getActiveCount());
# Line 745 | Line 740 | public class ThreadPoolExecutorSubclassT
740              p.purge();         // Nothing to do
741              assertEquals(tasks.length - 3, q.size());
742              assertEquals(tasks.length - 2, p.getTaskCount());
748 –        } finally {
743              done.countDown();
750 –            joinPool(p);
744          }
745      }
746  
# Line 1131 | Line 1124 | public class ThreadPoolExecutorSubclassT
1124       * execute throws RejectedExecutionException if saturated.
1125       */
1126      public void testSaturatedExecute() {
1127 <        ThreadPoolExecutor p =
1127 >        final ThreadPoolExecutor p =
1128              new CustomTPE(1, 1,
1129                            LONG_DELAY_MS, MILLISECONDS,
1130                            new ArrayBlockingQueue<Runnable>(1));
1131 <        final CountDownLatch done = new CountDownLatch(1);
1132 <        try {
1131 >        try (PoolCleaner cleaner = cleaner(p)) {
1132 >            final CountDownLatch done = new CountDownLatch(1);
1133              Runnable task = new CheckedRunnable() {
1134                  public void realRun() throws InterruptedException {
1135                      done.await();
# Line 1150 | Line 1143 | public class ThreadPoolExecutorSubclassT
1143                  } catch (RejectedExecutionException success) {}
1144                  assertTrue(p.getTaskCount() <= 2);
1145              }
1153 –        } finally {
1146              done.countDown();
1155 –            joinPool(p);
1147          }
1148      }
1149  
# Line 1160 | Line 1151 | public class ThreadPoolExecutorSubclassT
1151       * executor using CallerRunsPolicy runs task if saturated.
1152       */
1153      public void testSaturatedExecute2() {
1154 <        RejectedExecutionHandler h = new CustomTPE.CallerRunsPolicy();
1155 <        ThreadPoolExecutor p = new CustomTPE(1, 1,
1156 <                                             LONG_DELAY_MS, MILLISECONDS,
1157 <                                             new ArrayBlockingQueue<Runnable>(1),
1158 <                                             h);
1159 <        try {
1154 >        final ThreadPoolExecutor p =
1155 >            new CustomTPE(1, 1,
1156 >                          LONG_DELAY_MS, MILLISECONDS,
1157 >                          new ArrayBlockingQueue<Runnable>(1),
1158 >                          new CustomTPE.CallerRunsPolicy());
1159 >        try (PoolCleaner cleaner = cleaner(p)) {
1160 >            final CountDownLatch done = new CountDownLatch(1);
1161 >            Runnable blocker = new CheckedRunnable() {
1162 >                public void realRun() throws InterruptedException {
1163 >                    done.await();
1164 >                }};
1165 >            p.execute(blocker);
1166              TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
1167 <            for (int i = 0; i < tasks.length; ++i)
1167 >            for (int i = 0; i < tasks.length; i++)
1168                  tasks[i] = new TrackedNoOpRunnable();
1169 <            TrackedLongRunnable mr = new TrackedLongRunnable();
1173 <            p.execute(mr);
1174 <            for (int i = 0; i < tasks.length; ++i)
1169 >            for (int i = 0; i < tasks.length; i++)
1170                  p.execute(tasks[i]);
1171 <            for (int i = 1; i < tasks.length; ++i)
1171 >            for (int i = 1; i < tasks.length; i++)
1172                  assertTrue(tasks[i].done);
1173 <            try { p.shutdownNow(); } catch (SecurityException ok) { return; }
1174 <        } finally {
1180 <            joinPool(p);
1173 >            assertFalse(tasks[0].done); // waiting in queue
1174 >            done.countDown();
1175          }
1176      }
1177  
# Line 1185 | Line 1179 | public class ThreadPoolExecutorSubclassT
1179       * executor using DiscardPolicy drops task if saturated.
1180       */
1181      public void testSaturatedExecute3() {
1182 <        RejectedExecutionHandler h = new CustomTPE.DiscardPolicy();
1183 <        ThreadPoolExecutor p =
1182 >        final TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
1183 >        for (int i = 0; i < tasks.length; ++i)
1184 >            tasks[i] = new TrackedNoOpRunnable();
1185 >        final ThreadPoolExecutor p =
1186              new CustomTPE(1, 1,
1187                            LONG_DELAY_MS, MILLISECONDS,
1188                            new ArrayBlockingQueue<Runnable>(1),
1189 <                          h);
1190 <        try {
1191 <            TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
1192 <            for (int i = 0; i < tasks.length; ++i)
1193 <                tasks[i] = new TrackedNoOpRunnable();
1198 <            p.execute(new TrackedLongRunnable());
1189 >                          new CustomTPE.DiscardPolicy());
1190 >        try (PoolCleaner cleaner = cleaner(p)) {
1191 >            final CountDownLatch done = new CountDownLatch(1);
1192 >            p.execute(awaiter(done));
1193 >
1194              for (TrackedNoOpRunnable task : tasks)
1195                  p.execute(task);
1196 <            for (TrackedNoOpRunnable task : tasks)
1197 <                assertFalse(task.done);
1198 <            try { p.shutdownNow(); } catch (SecurityException ok) { return; }
1204 <        } finally {
1205 <            joinPool(p);
1196 >            for (int i = 1; i < tasks.length; i++)
1197 >                assertFalse(tasks[i].done);
1198 >            done.countDown();
1199          }
1200 +        for (int i = 1; i < tasks.length; i++)
1201 +            assertFalse(tasks[i].done);
1202 +        assertTrue(tasks[0].done); // was waiting in queue
1203      }
1204  
1205      /**

Diff Legend

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