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.88 by jsr166, Sun Oct 4 02:46:13 2015 UTC vs.
Revision 1.94 by jsr166, Sun Oct 4 03:52:33 2015 UTC

# Line 1043 | Line 1043 | public class ThreadPoolExecutorTest exte
1043       * execute throws RejectedExecutionException if saturated.
1044       */
1045      public void testSaturatedExecute() {
1046 <        ThreadPoolExecutor p =
1046 >        final ThreadPoolExecutor p =
1047              new ThreadPoolExecutor(1, 1,
1048                                     LONG_DELAY_MS, MILLISECONDS,
1049                                     new ArrayBlockingQueue<Runnable>(1));
1050 <        final CountDownLatch done = new CountDownLatch(1);
1051 <        try {
1050 >        try (PoolCleaner cleaner = cleaner(p)) {
1051 >            final CountDownLatch done = new CountDownLatch(1);
1052              Runnable task = new CheckedRunnable() {
1053                  public void realRun() throws InterruptedException {
1054                      done.await();
# Line 1062 | Line 1062 | public class ThreadPoolExecutorTest exte
1062                  } catch (RejectedExecutionException success) {}
1063                  assertTrue(p.getTaskCount() <= 2);
1064              }
1065 –        } finally {
1065              done.countDown();
1067 –            joinPool(p);
1066          }
1067      }
1068  
# Line 1130 | Line 1128 | public class ThreadPoolExecutorTest exte
1128       * executor using CallerRunsPolicy runs task if saturated.
1129       */
1130      public void testSaturatedExecute2() {
1133 –        RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy();
1131          final ThreadPoolExecutor p =
1132              new ThreadPoolExecutor(1, 1,
1133                                     LONG_DELAY_MS,
1134                                     MILLISECONDS,
1135                                     new ArrayBlockingQueue<Runnable>(1),
1136 <                                   h);
1137 <        try {
1136 >                                   new ThreadPoolExecutor.CallerRunsPolicy());
1137 >        try (PoolCleaner cleaner = cleaner(p)) {
1138 >            final CountDownLatch done = new CountDownLatch(1);
1139 >            Runnable blocker = new CheckedRunnable() {
1140 >                public void realRun() throws InterruptedException {
1141 >                    done.await();
1142 >                }};
1143 >            p.execute(blocker);
1144              TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
1145 <            for (int i = 0; i < tasks.length; ++i)
1145 >            for (int i = 0; i < tasks.length; i++)
1146                  tasks[i] = new TrackedNoOpRunnable();
1147 <            TrackedLongRunnable mr = new TrackedLongRunnable();
1145 <            p.execute(mr);
1146 <            for (int i = 0; i < tasks.length; ++i)
1147 >            for (int i = 0; i < tasks.length; i++)
1148                  p.execute(tasks[i]);
1149 <            for (int i = 1; i < tasks.length; ++i)
1149 >            for (int i = 1; i < tasks.length; i++)
1150                  assertTrue(tasks[i].done);
1151 <            try { p.shutdownNow(); } catch (SecurityException ok) { return; }
1152 <        } finally {
1152 <            joinPool(p);
1151 >            assertFalse(tasks[0].done); // waiting in queue
1152 >            done.countDown();
1153          }
1154      }
1155  
# Line 1157 | Line 1157 | public class ThreadPoolExecutorTest exte
1157       * executor using DiscardPolicy drops task if saturated.
1158       */
1159      public void testSaturatedExecute3() {
1160 <        RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardPolicy();
1160 >        final TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
1161 >        for (int i = 0; i < tasks.length; ++i)
1162 >            tasks[i] = new TrackedNoOpRunnable();
1163          final ThreadPoolExecutor p =
1164              new ThreadPoolExecutor(1, 1,
1165 <                                   LONG_DELAY_MS, MILLISECONDS,
1166 <                                   new ArrayBlockingQueue<Runnable>(1),
1167 <                                   h);
1168 <        try {
1169 <            TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
1170 <            for (int i = 0; i < tasks.length; ++i)
1171 <                tasks[i] = new TrackedNoOpRunnable();
1170 <            p.execute(new TrackedLongRunnable());
1165 >                          LONG_DELAY_MS, MILLISECONDS,
1166 >                          new ArrayBlockingQueue<Runnable>(1),
1167 >                          new ThreadPoolExecutor.DiscardPolicy());
1168 >        try (PoolCleaner cleaner = cleaner(p)) {
1169 >            final CountDownLatch done = new CountDownLatch(1);
1170 >            p.execute(awaiter(done));
1171 >
1172              for (TrackedNoOpRunnable task : tasks)
1173                  p.execute(task);
1174 <            for (TrackedNoOpRunnable task : tasks)
1175 <                assertFalse(task.done);
1176 <            try { p.shutdownNow(); } catch (SecurityException ok) { return; }
1176 <        } finally {
1177 <            joinPool(p);
1174 >            for (int i = 1; i < tasks.length; i++)
1175 >                assertFalse(tasks[i].done);
1176 >            done.countDown();
1177          }
1178 +        for (int i = 1; i < tasks.length; i++)
1179 +            assertFalse(tasks[i].done);
1180 +        assertTrue(tasks[0].done); // was waiting in queue
1181      }
1182  
1183      /**
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));
1196 –            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; }
1201 <        } finally {
1202 <            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 1212 | 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 1231 | 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);
1238 –        } finally {
1239 –            joinPool(p);
1245          }
1246      }
1247  

Diff Legend

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