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

Comparing jsr166/src/test/tck/ThreadPoolExecutorTest.java (file contents):
Revision 1.91 by jsr166, Sun Oct 4 03:27:46 2015 UTC vs.
Revision 1.95 by jsr166, Sun Oct 4 03:58:22 2015 UTC

# Line 1184 | Line 1184 | public class ThreadPoolExecutorTest exte
1184       * executor using DiscardOldestPolicy drops oldest task if saturated.
1185       */
1186      public void testSaturatedExecute4() {
1187 <        RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardOldestPolicy();
1187 >        final CountDownLatch done = new CountDownLatch(1);
1188 >        LatchAwaiter r1 = awaiter(done);
1189 >        LatchAwaiter r2 = awaiter(done);
1190 >        LatchAwaiter r3 = awaiter(done);
1191          final ThreadPoolExecutor p =
1192              new ThreadPoolExecutor(1, 1,
1193                                     LONG_DELAY_MS, MILLISECONDS,
1194                                     new ArrayBlockingQueue<Runnable>(1),
1195 <                                   h);
1196 <        try {
1197 <            p.execute(new TrackedLongRunnable());
1198 <            TrackedLongRunnable r2 = new TrackedLongRunnable();
1195 >                                   new ThreadPoolExecutor.DiscardOldestPolicy());
1196 >        try (PoolCleaner cleaner = cleaner(p)) {
1197 >            assertEquals(LatchAwaiter.NEW, r1.state);
1198 >            assertEquals(LatchAwaiter.NEW, r2.state);
1199 >            assertEquals(LatchAwaiter.NEW, r3.state);
1200 >            p.execute(r1);
1201              p.execute(r2);
1202              assertTrue(p.getQueue().contains(r2));
1198 –            TrackedNoOpRunnable r3 = new TrackedNoOpRunnable();
1203              p.execute(r3);
1204              assertFalse(p.getQueue().contains(r2));
1205              assertTrue(p.getQueue().contains(r3));
1206 <            try { p.shutdownNow(); } catch (SecurityException ok) { return; }
1203 <        } finally {
1204 <            joinPool(p);
1206 >            done.countDown();
1207          }
1208 +        assertEquals(LatchAwaiter.DONE, r1.state);
1209 +        assertEquals(LatchAwaiter.NEW, r2.state);
1210 +        assertEquals(LatchAwaiter.DONE, r3.state);
1211      }
1212  
1213      /**
# Line 1214 | Line 1219 | public class ThreadPoolExecutorTest exte
1219                                     LONG_DELAY_MS, MILLISECONDS,
1220                                     new ArrayBlockingQueue<Runnable>(1));
1221          try { p.shutdown(); } catch (SecurityException ok) { return; }
1222 <        try {
1223 <            p.execute(new NoOpRunnable());
1224 <            shouldThrow();
1225 <        } catch (RejectedExecutionException success) {}
1226 <
1227 <        joinPool(p);
1222 >        try (PoolCleaner cleaner = cleaner(p)) {
1223 >            try {
1224 >                p.execute(new NoOpRunnable());
1225 >                shouldThrow();
1226 >            } catch (RejectedExecutionException success) {}
1227 >        }
1228      }
1229  
1230      /**
# Line 1233 | Line 1238 | public class ThreadPoolExecutorTest exte
1238                                     new ArrayBlockingQueue<Runnable>(1), h);
1239  
1240          try { p.shutdown(); } catch (SecurityException ok) { return; }
1241 <        try {
1241 >        try (PoolCleaner cleaner = cleaner(p)) {
1242              TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1243              p.execute(r);
1244              assertFalse(r.done);
1240 –        } finally {
1241 –            joinPool(p);
1245          }
1246      }
1247  
# Line 1246 | Line 1249 | public class ThreadPoolExecutorTest exte
1249       * execute using DiscardPolicy drops task on shutdown
1250       */
1251      public void testDiscardOnShutdown() {
1252 <        RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardPolicy();
1250 <        ThreadPoolExecutor p =
1252 >        final ThreadPoolExecutor p =
1253              new ThreadPoolExecutor(1, 1,
1254                                     LONG_DELAY_MS, MILLISECONDS,
1255                                     new ArrayBlockingQueue<Runnable>(1),
1256 <                                   h);
1256 >                                   new ThreadPoolExecutor.DiscardPolicy());
1257  
1258          try { p.shutdown(); } catch (SecurityException ok) { return; }
1259 <        try {
1259 >        try (PoolCleaner cleaner = cleaner(p)) {
1260              TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1261              p.execute(r);
1262              assertFalse(r.done);
1261 –        } finally {
1262 –            joinPool(p);
1263          }
1264      }
1265  
# Line 1267 | Line 1267 | public class ThreadPoolExecutorTest exte
1267       * execute using DiscardOldestPolicy drops task on shutdown
1268       */
1269      public void testDiscardOldestOnShutdown() {
1270 <        RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardOldestPolicy();
1271 <        ThreadPoolExecutor p =
1270 >        final ThreadPoolExecutor p =
1271              new ThreadPoolExecutor(1, 1,
1272                                     LONG_DELAY_MS, MILLISECONDS,
1273                                     new ArrayBlockingQueue<Runnable>(1),
1274 <                                   h);
1274 >                                   new ThreadPoolExecutor.DiscardOldestPolicy());
1275  
1276          try { p.shutdown(); } catch (SecurityException ok) { return; }
1277 <        try {
1277 >        try (PoolCleaner cleaner = cleaner(p)) {
1278              TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1279              p.execute(r);
1280              assertFalse(r.done);
1282 –        } finally {
1283 –            joinPool(p);
1281          }
1282      }
1283  
# Line 1288 | Line 1285 | public class ThreadPoolExecutorTest exte
1285       * execute(null) throws NPE
1286       */
1287      public void testExecuteNull() {
1288 <        ThreadPoolExecutor p =
1289 <            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
1288 >        final ThreadPoolExecutor p =
1289 >            new ThreadPoolExecutor(1, 2,
1290 >                                   1L, SECONDS,
1291                                     new ArrayBlockingQueue<Runnable>(10));
1292 <        try {
1293 <            p.execute(null);
1294 <            shouldThrow();
1295 <        } catch (NullPointerException success) {}
1296 <
1297 <        joinPool(p);
1292 >        try (PoolCleaner cleaner = cleaner(p)) {
1293 >            try {
1294 >                p.execute(null);
1295 >                shouldThrow();
1296 >            } catch (NullPointerException success) {}
1297 >        }
1298      }
1299  
1300      /**

Diff Legend

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