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.74 by jsr166, Sun Oct 4 03:07:31 2015 UTC vs.
Revision 1.79 by jsr166, Sun Oct 4 03:58:22 2015 UTC

# Line 1170 | Line 1170 | public class ThreadPoolExecutorSubclassT
1170                  p.execute(tasks[i]);
1171              for (int i = 1; i < tasks.length; i++)
1172                  assertTrue(tasks[i].done);
1173 <            // tasks[0] is waiting in queue
1174 <            assertFalse(tasks[0].done);
1173 >            assertFalse(tasks[0].done); // waiting in queue
1174              done.countDown();
1175          }
1176      }
# Line 1180 | 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();
1193 <            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; }
1199 <        } finally {
1200 <            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));
1215 –            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; }
1220 <        } finally {
1221 <            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      /**
1253       * execute using CallerRunsPolicy drops task on shutdown
1254       */
1255      public void testCallerRunsOnShutdown() {
1256 <        RejectedExecutionHandler h = new CustomTPE.CallerRunsPolicy();
1257 <        ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
1258 <
1256 >        final ThreadPoolExecutor p =
1257 >            new CustomTPE(1, 1,
1258 >                          LONG_DELAY_MS, MILLISECONDS,
1259 >                          new ArrayBlockingQueue<Runnable>(1),
1260 >                          new CustomTPE.CallerRunsPolicy());
1261          try { p.shutdown(); } catch (SecurityException ok) { return; }
1262 <        try {
1262 >        try (PoolCleaner cleaner = cleaner(p)) {
1263              TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1264              p.execute(r);
1265              assertFalse(r.done);
1252 –        } finally {
1253 –            joinPool(p);
1266          }
1267      }
1268  
# Line 1258 | Line 1270 | public class ThreadPoolExecutorSubclassT
1270       * execute using DiscardPolicy drops task on shutdown
1271       */
1272      public void testDiscardOnShutdown() {
1273 <        RejectedExecutionHandler h = new CustomTPE.DiscardPolicy();
1274 <        ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
1275 <
1273 >        final ThreadPoolExecutor p =
1274 >            new CustomTPE(1, 1,
1275 >                          LONG_DELAY_MS, MILLISECONDS,
1276 >                          new ArrayBlockingQueue<Runnable>(1),
1277 >                          new CustomTPE.DiscardPolicy());
1278          try { p.shutdown(); } catch (SecurityException ok) { return; }
1279 <        try {
1279 >        try (PoolCleaner cleaner = cleaner(p)) {
1280              TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1281              p.execute(r);
1282              assertFalse(r.done);
1269 –        } finally {
1270 –            joinPool(p);
1283          }
1284      }
1285  
# Line 1275 | Line 1287 | public class ThreadPoolExecutorSubclassT
1287       * execute using DiscardOldestPolicy drops task on shutdown
1288       */
1289      public void testDiscardOldestOnShutdown() {
1290 <        RejectedExecutionHandler h = new CustomTPE.DiscardOldestPolicy();
1291 <        ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
1290 >        final ThreadPoolExecutor p =
1291 >            new CustomTPE(1, 1,
1292 >                          LONG_DELAY_MS, MILLISECONDS,
1293 >                          new ArrayBlockingQueue<Runnable>(1),
1294 >                          new CustomTPE.DiscardOldestPolicy());
1295  
1296          try { p.shutdown(); } catch (SecurityException ok) { return; }
1297 <        try {
1297 >        try (PoolCleaner cleaner = cleaner(p)) {
1298              TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1299              p.execute(r);
1300              assertFalse(r.done);
1286 –        } finally {
1287 –            joinPool(p);
1301          }
1302      }
1303  
# Line 1292 | Line 1305 | public class ThreadPoolExecutorSubclassT
1305       * execute(null) throws NPE
1306       */
1307      public void testExecuteNull() {
1308 <        ThreadPoolExecutor p =
1309 <            new CustomTPE(1, 2, 1L, SECONDS,
1308 >        final ThreadPoolExecutor p =
1309 >            new CustomTPE(1, 2,
1310 >                          1L, SECONDS,
1311                            new ArrayBlockingQueue<Runnable>(10));
1312 <        try {
1313 <            p.execute(null);
1314 <            shouldThrow();
1315 <        } catch (NullPointerException success) {}
1316 <
1317 <        joinPool(p);
1312 >        try (PoolCleaner cleaner = cleaner(p)) {
1313 >            try {
1314 >                p.execute(null);
1315 >                shouldThrow();
1316 >            } catch (NullPointerException success) {}
1317 >        }
1318      }
1319  
1320      /**

Diff Legend

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