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.68 by jsr166, Sun Oct 4 02:26:47 2015 UTC vs.
Revision 1.77 by jsr166, Sun Oct 4 03:51:35 2015 UTC

# Line 588 | 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 601 | Line 601 | public class ThreadPoolExecutorSubclassT
601              assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
602              assertFalse(p.isTerminating());
603              done.countDown();
604 –        } 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          }
607 –        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
608 –        assertTrue(p.isTerminated());
609 –        assertFalse(p.isTerminating());
609      }
610  
611      /**
# Line 617 | 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 630 | Line 629 | public class ThreadPoolExecutorSubclassT
629              assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
630              assertFalse(p.isTerminating());
631              done.countDown();
633 –        } 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          }
636 –        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
637 –        assertTrue(p.isTerminated());
638 –        assertFalse(p.isTerminating());
637      }
638  
639      /**
# Line 647 | 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 667 | Line 665 | public class ThreadPoolExecutorSubclassT
665              assertFalse(q.contains(tasks[0]));
666              assertTrue(q.contains(tasks[tasks.length - 1]));
667              assertEquals(tasks.length - 1, q.size());
670 –        } finally {
668              done.countDown();
672 –            joinPool(p);
669          }
670      }
671  
# Line 682 | 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(MEDIUM_DELAY_MS, MILLISECONDS));
# Line 704 | Line 700 | public class ThreadPoolExecutorSubclassT
700              assertTrue(q.contains(tasks[3]));
701              assertTrue(p.remove(tasks[3]));
702              assertFalse(q.contains(tasks[3]));
707 –        } finally {
703              done.countDown();
709 –            joinPool(p);
704          }
705      }
706  
# Line 721 | 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 746 | 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());
749 –        } finally {
743              done.countDown();
751 –            joinPool(p);
744          }
745      }
746  
# Line 1132 | 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 1151 | Line 1143 | public class ThreadPoolExecutorSubclassT
1143                  } catch (RejectedExecutionException success) {}
1144                  assertTrue(p.getTaskCount() <= 2);
1145              }
1154 –        } finally {
1146              done.countDown();
1156 –            joinPool(p);
1147          }
1148      }
1149  
# Line 1161 | 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();
1174 <            p.execute(mr);
1175 <            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 {
1181 <            joinPool(p);
1173 >            assertFalse(tasks[0].done); // waiting in queue
1174 >            done.countDown();
1175          }
1176      }
1177  
# Line 1186 | 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();
1199 <            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; }
1205 <        } finally {
1206 <            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      /**
1206       * executor using DiscardOldestPolicy drops oldest task if saturated.
1207       */
1208      public void testSaturatedExecute4() {
1209 <        RejectedExecutionHandler h = new CustomTPE.DiscardOldestPolicy();
1210 <        ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
1211 <        try {
1212 <            p.execute(new TrackedLongRunnable());
1213 <            TrackedLongRunnable r2 = new TrackedLongRunnable();
1209 >        final CountDownLatch done = new CountDownLatch(1);
1210 >        LatchAwaiter r1 = awaiter(done);
1211 >        LatchAwaiter r2 = awaiter(done);
1212 >        LatchAwaiter r3 = awaiter(done);
1213 >        final ThreadPoolExecutor p =
1214 >            new CustomTPE(1, 1,
1215 >                          LONG_DELAY_MS, MILLISECONDS,
1216 >                          new ArrayBlockingQueue<Runnable>(1),
1217 >                          new CustomTPE.DiscardOldestPolicy());
1218 >        try (PoolCleaner cleaner = cleaner(p)) {
1219 >            assertEquals(LatchAwaiter.NEW, r1.state);
1220 >            assertEquals(LatchAwaiter.NEW, r2.state);
1221 >            assertEquals(LatchAwaiter.NEW, r3.state);
1222 >            p.execute(r1);
1223              p.execute(r2);
1224              assertTrue(p.getQueue().contains(r2));
1221 –            TrackedNoOpRunnable r3 = new TrackedNoOpRunnable();
1225              p.execute(r3);
1226              assertFalse(p.getQueue().contains(r2));
1227              assertTrue(p.getQueue().contains(r3));
1228 <            try { p.shutdownNow(); } catch (SecurityException ok) { return; }
1226 <        } finally {
1227 <            joinPool(p);
1228 >            done.countDown();
1229          }
1230 +        assertEquals(LatchAwaiter.DONE, r1.state);
1231 +        assertEquals(LatchAwaiter.NEW, r2.state);
1232 +        assertEquals(LatchAwaiter.DONE, r3.state);
1233      }
1234  
1235      /**
1236       * execute throws RejectedExecutionException if shutdown
1237       */
1238      public void testRejectedExecutionExceptionOnShutdown() {
1239 <        ThreadPoolExecutor p =
1240 <            new CustomTPE(1,1,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(1));
1239 >        final ThreadPoolExecutor p =
1240 >            new CustomTPE(1, 1,
1241 >                          LONG_DELAY_MS, MILLISECONDS,
1242 >                          new ArrayBlockingQueue<Runnable>(1));
1243          try { p.shutdown(); } catch (SecurityException ok) { return; }
1244 <        try {
1245 <            p.execute(new NoOpRunnable());
1246 <            shouldThrow();
1247 <        } catch (RejectedExecutionException success) {}
1248 <
1249 <        joinPool(p);
1244 >        try (PoolCleaner cleaner = cleaner(p)) {
1245 >            try {
1246 >                p.execute(new NoOpRunnable());
1247 >                shouldThrow();
1248 >            } catch (RejectedExecutionException success) {}
1249 >        }
1250      }
1251  
1252      /**

Diff Legend

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