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.116 by jsr166, Wed Mar 22 20:19:55 2017 UTC vs.
Revision 1.124 by jsr166, Mon Jul 17 22:27:31 2017 UTC

# Line 11 | Line 11 | import static java.util.concurrent.TimeU
11   import static java.util.concurrent.TimeUnit.SECONDS;
12  
13   import java.util.ArrayList;
14 + import java.util.Collection;
15 + import java.util.Collections;
16   import java.util.List;
17   import java.util.concurrent.ArrayBlockingQueue;
18   import java.util.concurrent.BlockingQueue;
# Line 26 | Line 28 | import java.util.concurrent.RejectedExec
28   import java.util.concurrent.RejectedExecutionHandler;
29   import java.util.concurrent.SynchronousQueue;
30   import java.util.concurrent.ThreadFactory;
31 + import java.util.concurrent.ThreadLocalRandom;
32   import java.util.concurrent.ThreadPoolExecutor;
33 + import java.util.concurrent.ThreadPoolExecutor.AbortPolicy;
34 + import java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy;
35 + import java.util.concurrent.ThreadPoolExecutor.DiscardPolicy;
36 + import java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy;
37   import java.util.concurrent.atomic.AtomicInteger;
38 + import java.util.concurrent.atomic.AtomicReference;
39  
40   import junit.framework.Test;
41   import junit.framework.TestSuite;
# Line 90 | Line 98 | public class ThreadPoolExecutorTest exte
98              final Runnable task = new CheckedRunnable() {
99                  public void realRun() { done.countDown(); }};
100              p.execute(task);
101 <            assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
101 >            await(done);
102          }
103      }
104  
# Line 184 | Line 192 | public class ThreadPoolExecutorTest exte
192                  public void realRun() throws InterruptedException {
193                      threadStarted.countDown();
194                      assertEquals(0, p.getCompletedTaskCount());
195 <                    threadProceed.await();
195 >                    await(threadProceed);
196                      threadDone.countDown();
197                  }});
198              await(threadStarted);
199              assertEquals(0, p.getCompletedTaskCount());
200              threadProceed.countDown();
201 <            threadDone.await();
201 >            await(threadDone);
202              long startTime = System.nanoTime();
203              while (p.getCompletedTaskCount() != 1) {
204                  if (millisElapsedSince(startTime) > LONG_DELAY_MS)
# Line 282 | Line 290 | public class ThreadPoolExecutorTest exte
290                                     LONG_DELAY_MS, MILLISECONDS,
291                                     new ArrayBlockingQueue<Runnable>(10));
292          try (PoolCleaner cleaner = cleaner(p)) {
293 <            assertTrue(p.getRejectedExecutionHandler()
286 <                       instanceof ThreadPoolExecutor.AbortPolicy);
293 >            assertTrue(p.getRejectedExecutionHandler() instanceof AbortPolicy);
294          }
295      }
296  
# Line 470 | Line 477 | public class ThreadPoolExecutorTest exte
477              assertFalse(p.awaitTermination(Long.MIN_VALUE, MILLISECONDS));
478              assertFalse(p.awaitTermination(-1L, NANOSECONDS));
479              assertFalse(p.awaitTermination(-1L, MILLISECONDS));
480 <            assertFalse(p.awaitTermination(0L, NANOSECONDS));
481 <            assertFalse(p.awaitTermination(0L, MILLISECONDS));
480 >            assertFalse(p.awaitTermination(randomExpiredTimeout(),
481 >                                           randomTimeUnit()));
482              long timeoutNanos = 999999L;
483              long startTime = System.nanoTime();
484              assertFalse(p.awaitTermination(timeoutNanos, NANOSECONDS));
# Line 1052 | Line 1059 | public class ThreadPoolExecutorTest exte
1059                      p.submit(task).get();
1060                  }});
1061  
1062 <            await(threadStarted);
1062 >            await(threadStarted); // ensure quiescence
1063              t.interrupt();
1064              awaitTermination(t);
1065          }
1066      }
1067  
1068      /**
1069 <     * execute throws RejectedExecutionException if saturated.
1069 >     * Submitted tasks are rejected when saturated or shutdown
1070       */
1071 <    public void testSaturatedExecute() {
1071 >    public void testSubmittedTasksRejectedWhenSaturatedOrShutdown() throws InterruptedException {
1072 >        final ThreadPoolExecutor p = new ThreadPoolExecutor(
1073 >            1, 1, 1, SECONDS, new ArrayBlockingQueue<Runnable>(1));
1074 >        final int saturatedSize = saturatedSize(p);
1075 >        final ThreadLocalRandom rnd = ThreadLocalRandom.current();
1076 >        final CountDownLatch threadsStarted = new CountDownLatch(p.getMaximumPoolSize());
1077          final CountDownLatch done = new CountDownLatch(1);
1078 <        final ThreadPoolExecutor p =
1079 <            new ThreadPoolExecutor(1, 1,
1080 <                                   LONG_DELAY_MS, MILLISECONDS,
1069 <                                   new ArrayBlockingQueue<Runnable>(1));
1070 <        try (PoolCleaner cleaner = cleaner(p, done)) {
1071 <            Runnable task = new CheckedRunnable() {
1072 <                public void realRun() throws InterruptedException {
1073 <                    await(done);
1074 <                }};
1075 <            for (int i = 0; i < 2; ++i)
1076 <                p.execute(task);
1077 <            for (int i = 0; i < 2; ++i) {
1078 >        final Runnable r = () -> {
1079 >            threadsStarted.countDown();
1080 >            for (;;) {
1081                  try {
1082 <                    p.execute(task);
1083 <                    shouldThrow();
1084 <                } catch (RejectedExecutionException success) {}
1085 <                assertTrue(p.getTaskCount() <= 2);
1086 <            }
1087 <        }
1088 <    }
1086 <
1087 <    /**
1088 <     * submit(runnable) throws RejectedExecutionException if saturated.
1089 <     */
1090 <    public void testSaturatedSubmitRunnable() {
1091 <        final CountDownLatch done = new CountDownLatch(1);
1092 <        final ThreadPoolExecutor p =
1093 <            new ThreadPoolExecutor(1, 1,
1094 <                                   LONG_DELAY_MS, MILLISECONDS,
1095 <                                   new ArrayBlockingQueue<Runnable>(1));
1096 <        try (PoolCleaner cleaner = cleaner(p, done)) {
1097 <            Runnable task = new CheckedRunnable() {
1098 <                public void realRun() throws InterruptedException {
1099 <                    await(done);
1100 <                }};
1101 <            for (int i = 0; i < 2; ++i)
1102 <                p.submit(task);
1103 <            for (int i = 0; i < 2; ++i) {
1082 >                    done.await();
1083 >                    return;
1084 >                } catch (InterruptedException shutdownNowDeliberatelyIgnored) {}
1085 >            }};
1086 >        final Callable<Boolean> c = () -> {
1087 >            threadsStarted.countDown();
1088 >            for (;;) {
1089                  try {
1090 <                    p.execute(task);
1091 <                    shouldThrow();
1092 <                } catch (RejectedExecutionException success) {}
1093 <                assertTrue(p.getTaskCount() <= 2);
1094 <            }
1110 <        }
1111 <    }
1090 >                    done.await();
1091 >                    return Boolean.TRUE;
1092 >                } catch (InterruptedException shutdownNowDeliberatelyIgnored) {}
1093 >            }};
1094 >        final boolean shutdownNow = rnd.nextBoolean();
1095  
1113 –    /**
1114 –     * submit(callable) throws RejectedExecutionException if saturated.
1115 –     */
1116 –    public void testSaturatedSubmitCallable() {
1117 –        final CountDownLatch done = new CountDownLatch(1);
1118 –        final ThreadPoolExecutor p =
1119 –            new ThreadPoolExecutor(1, 1,
1120 –                                   LONG_DELAY_MS, MILLISECONDS,
1121 –                                   new ArrayBlockingQueue<Runnable>(1));
1096          try (PoolCleaner cleaner = cleaner(p, done)) {
1097 <            Runnable task = new CheckedRunnable() {
1098 <                public void realRun() throws InterruptedException {
1099 <                    await(done);
1100 <                }};
1101 <            for (int i = 0; i < 2; ++i)
1102 <                p.execute(task);
1103 <            for (int i = 0; i < 2; ++i) {
1104 <                try {
1131 <                    p.execute(task);
1132 <                    shouldThrow();
1133 <                } catch (RejectedExecutionException success) {}
1134 <                assertTrue(p.getTaskCount() <= 2);
1097 >            // saturate
1098 >            for (int i = saturatedSize; i--> 0; ) {
1099 >                switch (rnd.nextInt(4)) {
1100 >                case 0: p.execute(r); break;
1101 >                case 1: assertFalse(p.submit(r).isDone()); break;
1102 >                case 2: assertFalse(p.submit(r, Boolean.TRUE).isDone()); break;
1103 >                case 3: assertFalse(p.submit(c).isDone()); break;
1104 >                }
1105              }
1136 –        }
1137 –    }
1106  
1107 <    /**
1108 <     * executor using CallerRunsPolicy runs task if saturated.
1141 <     */
1142 <    public void testSaturatedExecute2() {
1143 <        final ThreadPoolExecutor p =
1144 <            new ThreadPoolExecutor(1, 1,
1145 <                                   LONG_DELAY_MS,
1146 <                                   MILLISECONDS,
1147 <                                   new ArrayBlockingQueue<Runnable>(1),
1148 <                                   new ThreadPoolExecutor.CallerRunsPolicy());
1149 <        try (PoolCleaner cleaner = cleaner(p)) {
1150 <            final CountDownLatch done = new CountDownLatch(1);
1151 <            Runnable blocker = new CheckedRunnable() {
1152 <                public void realRun() throws InterruptedException {
1153 <                    await(done);
1154 <                }};
1155 <            p.execute(blocker);
1156 <            TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
1157 <            for (int i = 0; i < tasks.length; i++)
1158 <                tasks[i] = new TrackedNoOpRunnable();
1159 <            for (int i = 0; i < tasks.length; i++)
1160 <                p.execute(tasks[i]);
1161 <            for (int i = 1; i < tasks.length; i++)
1162 <                assertTrue(tasks[i].done);
1163 <            assertFalse(tasks[0].done); // waiting in queue
1164 <            done.countDown();
1165 <        }
1166 <    }
1107 >            await(threadsStarted);
1108 >            assertTaskSubmissionsAreRejected(p);
1109  
1110 <    /**
1111 <     * executor using DiscardPolicy drops task if saturated.
1112 <     */
1113 <    public void testSaturatedExecute3() {
1114 <        final CountDownLatch done = new CountDownLatch(1);
1115 <        final TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
1116 <        for (int i = 0; i < tasks.length; ++i)
1117 <            tasks[i] = new TrackedNoOpRunnable();
1118 <        final ThreadPoolExecutor p =
1119 <            new ThreadPoolExecutor(1, 1,
1178 <                          LONG_DELAY_MS, MILLISECONDS,
1179 <                          new ArrayBlockingQueue<Runnable>(1),
1180 <                          new ThreadPoolExecutor.DiscardPolicy());
1181 <        try (PoolCleaner cleaner = cleaner(p, done)) {
1182 <            p.execute(awaiter(done));
1110 >            if (shutdownNow)
1111 >                p.shutdownNow();
1112 >            else
1113 >                p.shutdown();
1114 >            // Pool is shutdown, but not yet terminated
1115 >            assertTaskSubmissionsAreRejected(p);
1116 >            assertFalse(p.isTerminated());
1117 >
1118 >            done.countDown();   // release blocking tasks
1119 >            assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
1120  
1121 <            for (TrackedNoOpRunnable task : tasks)
1122 <                p.execute(task);
1123 <            for (int i = 1; i < tasks.length; i++)
1124 <                assertFalse(tasks[i].done);
1125 <        }
1189 <        for (int i = 1; i < tasks.length; i++)
1190 <            assertFalse(tasks[i].done);
1191 <        assertTrue(tasks[0].done); // was waiting in queue
1121 >            assertTaskSubmissionsAreRejected(p);
1122 >        }
1123 >        assertEquals(saturatedSize(p)
1124 >                     - (shutdownNow ? p.getQueue().remainingCapacity() : 0),
1125 >                     p.getCompletedTaskCount());
1126      }
1127  
1128      /**
1129       * executor using DiscardOldestPolicy drops oldest task if saturated.
1130       */
1131 <    public void testSaturatedExecute4() {
1131 >    public void testSaturatedExecute_DiscardOldestPolicy() {
1132          final CountDownLatch done = new CountDownLatch(1);
1133          LatchAwaiter r1 = awaiter(done);
1134          LatchAwaiter r2 = awaiter(done);
# Line 1203 | Line 1137 | public class ThreadPoolExecutorTest exte
1137              new ThreadPoolExecutor(1, 1,
1138                                     LONG_DELAY_MS, MILLISECONDS,
1139                                     new ArrayBlockingQueue<Runnable>(1),
1140 <                                   new ThreadPoolExecutor.DiscardOldestPolicy());
1140 >                                   new DiscardOldestPolicy());
1141          try (PoolCleaner cleaner = cleaner(p, done)) {
1142              assertEquals(LatchAwaiter.NEW, r1.state);
1143              assertEquals(LatchAwaiter.NEW, r2.state);
# Line 1221 | Line 1155 | public class ThreadPoolExecutorTest exte
1155      }
1156  
1157      /**
1224 –     * execute throws RejectedExecutionException if shutdown
1225 –     */
1226 –    public void testRejectedExecutionExceptionOnShutdown() {
1227 –        final ThreadPoolExecutor p =
1228 –            new ThreadPoolExecutor(1, 1,
1229 –                                   LONG_DELAY_MS, MILLISECONDS,
1230 –                                   new ArrayBlockingQueue<Runnable>(1));
1231 –        try { p.shutdown(); } catch (SecurityException ok) { return; }
1232 –        try (PoolCleaner cleaner = cleaner(p)) {
1233 –            try {
1234 –                p.execute(new NoOpRunnable());
1235 –                shouldThrow();
1236 –            } catch (RejectedExecutionException success) {}
1237 –        }
1238 –    }
1239 –
1240 –    /**
1241 –     * execute using CallerRunsPolicy drops task on shutdown
1242 –     */
1243 –    public void testCallerRunsOnShutdown() {
1244 –        RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy();
1245 –        final ThreadPoolExecutor p =
1246 –            new ThreadPoolExecutor(1, 1,
1247 –                                   LONG_DELAY_MS, MILLISECONDS,
1248 –                                   new ArrayBlockingQueue<Runnable>(1), h);
1249 –
1250 –        try { p.shutdown(); } catch (SecurityException ok) { return; }
1251 –        try (PoolCleaner cleaner = cleaner(p)) {
1252 –            TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1253 –            p.execute(r);
1254 –            assertFalse(r.done);
1255 –        }
1256 –    }
1257 –
1258 –    /**
1259 –     * execute using DiscardPolicy drops task on shutdown
1260 –     */
1261 –    public void testDiscardOnShutdown() {
1262 –        final ThreadPoolExecutor p =
1263 –            new ThreadPoolExecutor(1, 1,
1264 –                                   LONG_DELAY_MS, MILLISECONDS,
1265 –                                   new ArrayBlockingQueue<Runnable>(1),
1266 –                                   new ThreadPoolExecutor.DiscardPolicy());
1267 –
1268 –        try { p.shutdown(); } catch (SecurityException ok) { return; }
1269 –        try (PoolCleaner cleaner = cleaner(p)) {
1270 –            TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1271 –            p.execute(r);
1272 –            assertFalse(r.done);
1273 –        }
1274 –    }
1275 –
1276 –    /**
1158       * execute using DiscardOldestPolicy drops task on shutdown
1159       */
1160      public void testDiscardOldestOnShutdown() {
# Line 1281 | Line 1162 | public class ThreadPoolExecutorTest exte
1162              new ThreadPoolExecutor(1, 1,
1163                                     LONG_DELAY_MS, MILLISECONDS,
1164                                     new ArrayBlockingQueue<Runnable>(1),
1165 <                                   new ThreadPoolExecutor.DiscardOldestPolicy());
1165 >                                   new DiscardOldestPolicy());
1166  
1167          try { p.shutdown(); } catch (SecurityException ok) { return; }
1168          try (PoolCleaner cleaner = cleaner(p)) {
# Line 1292 | Line 1173 | public class ThreadPoolExecutorTest exte
1173      }
1174  
1175      /**
1176 <     * execute(null) throws NPE
1176 >     * Submitting null tasks throws NullPointerException
1177       */
1178 <    public void testExecuteNull() {
1178 >    public void testNullTaskSubmission() {
1179          final ThreadPoolExecutor p =
1180              new ThreadPoolExecutor(1, 2,
1181                                     1L, SECONDS,
1182                                     new ArrayBlockingQueue<Runnable>(10));
1183          try (PoolCleaner cleaner = cleaner(p)) {
1184 <            try {
1304 <                p.execute(null);
1305 <                shouldThrow();
1306 <            } catch (NullPointerException success) {}
1184 >            assertNullTaskSubmissionThrowsNullPointerException(p);
1185          }
1186      }
1187  
# Line 1495 | Line 1373 | public class ThreadPoolExecutorTest exte
1373      }
1374  
1375      /**
1376 <     * invokeAny(empty collection) throws IAE
1376 >     * invokeAny(empty collection) throws IllegalArgumentException
1377       */
1378      public void testInvokeAny2() throws Exception {
1379          final ExecutorService e =
# Line 1585 | Line 1463 | public class ThreadPoolExecutorTest exte
1463      }
1464  
1465      /**
1466 <     * invokeAll(empty collection) returns empty collection
1466 >     * invokeAll(empty collection) returns empty list
1467       */
1468      public void testInvokeAll2() throws InterruptedException {
1469          final ExecutorService e =
1470              new ThreadPoolExecutor(2, 2,
1471                                     LONG_DELAY_MS, MILLISECONDS,
1472                                     new ArrayBlockingQueue<Runnable>(10));
1473 +        final Collection<Callable<String>> emptyCollection
1474 +            = Collections.emptyList();
1475          try (PoolCleaner cleaner = cleaner(e)) {
1476 <            List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
1476 >            List<Future<String>> r = e.invokeAll(emptyCollection);
1477              assertTrue(r.isEmpty());
1478          }
1479      }
# Line 1668 | Line 1548 | public class ThreadPoolExecutorTest exte
1548                                     new ArrayBlockingQueue<Runnable>(10));
1549          try (PoolCleaner cleaner = cleaner(e)) {
1550              try {
1551 <                e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
1551 >                e.invokeAny(null, randomTimeout(), randomTimeUnit());
1552                  shouldThrow();
1553              } catch (NullPointerException success) {}
1554          }
# Line 1686 | Line 1566 | public class ThreadPoolExecutorTest exte
1566              List<Callable<String>> l = new ArrayList<>();
1567              l.add(new StringTask());
1568              try {
1569 <                e.invokeAny(l, MEDIUM_DELAY_MS, null);
1569 >                e.invokeAny(l, randomTimeout(), null);
1570                  shouldThrow();
1571              } catch (NullPointerException success) {}
1572          }
1573      }
1574  
1575      /**
1576 <     * timed invokeAny(empty collection) throws IAE
1576 >     * timed invokeAny(empty collection) throws IllegalArgumentException
1577       */
1578      public void testTimedInvokeAny2() throws Exception {
1579          final ExecutorService e =
# Line 1703 | Line 1583 | public class ThreadPoolExecutorTest exte
1583          try (PoolCleaner cleaner = cleaner(e)) {
1584              try {
1585                  e.invokeAny(new ArrayList<Callable<String>>(),
1586 <                            MEDIUM_DELAY_MS, MILLISECONDS);
1586 >                            randomTimeout(), randomTimeUnit());
1587                  shouldThrow();
1588              } catch (IllegalArgumentException success) {}
1589          }
1590      }
1591  
1592      /**
1593 <     * timed invokeAny(c) throws NPE if c has null elements
1593 >     * timed invokeAny(c) throws NullPointerException if c has null elements
1594       */
1595      public void testTimedInvokeAny3() throws Exception {
1596          final CountDownLatch latch = new CountDownLatch(1);
# Line 1723 | Line 1603 | public class ThreadPoolExecutorTest exte
1603              l.add(latchAwaitingStringTask(latch));
1604              l.add(null);
1605              try {
1606 <                e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1606 >                e.invokeAny(l, randomTimeout(), randomTimeUnit());
1607                  shouldThrow();
1608              } catch (NullPointerException success) {}
1609              latch.countDown();
# Line 1781 | Line 1661 | public class ThreadPoolExecutorTest exte
1661                                     new ArrayBlockingQueue<Runnable>(10));
1662          try (PoolCleaner cleaner = cleaner(e)) {
1663              try {
1664 <                e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
1664 >                e.invokeAll(null, randomTimeout(), randomTimeUnit());
1665                  shouldThrow();
1666              } catch (NullPointerException success) {}
1667          }
# Line 1799 | Line 1679 | public class ThreadPoolExecutorTest exte
1679              List<Callable<String>> l = new ArrayList<>();
1680              l.add(new StringTask());
1681              try {
1682 <                e.invokeAll(l, MEDIUM_DELAY_MS, null);
1682 >                e.invokeAll(l, randomTimeout(), null);
1683                  shouldThrow();
1684              } catch (NullPointerException success) {}
1685          }
1686      }
1687  
1688      /**
1689 <     * timed invokeAll(empty collection) returns empty collection
1689 >     * timed invokeAll(empty collection) returns empty list
1690       */
1691      public void testTimedInvokeAll2() throws InterruptedException {
1692          final ExecutorService e =
1693              new ThreadPoolExecutor(2, 2,
1694                                     LONG_DELAY_MS, MILLISECONDS,
1695                                     new ArrayBlockingQueue<Runnable>(10));
1696 +        final Collection<Callable<String>> emptyCollection
1697 +            = Collections.emptyList();
1698          try (PoolCleaner cleaner = cleaner(e)) {
1699 <            List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(),
1700 <                                                 MEDIUM_DELAY_MS, MILLISECONDS);
1699 >            List<Future<String>> r =
1700 >                e.invokeAll(emptyCollection, randomTimeout(), randomTimeUnit());
1701              assertTrue(r.isEmpty());
1702          }
1703      }
# Line 1833 | Line 1715 | public class ThreadPoolExecutorTest exte
1715              l.add(new StringTask());
1716              l.add(null);
1717              try {
1718 <                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1718 >                e.invokeAll(l, randomTimeout(), randomTimeUnit());
1719                  shouldThrow();
1720              } catch (NullPointerException success) {}
1721          }
# Line 1941 | Line 1823 | public class ThreadPoolExecutorTest exte
1823                      public void realRun() {
1824                          done.countDown();
1825                      }});
1826 <            assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
1826 >            await(done);
1827          }
1828      }
1829  
# Line 2034 | Line 1916 | public class ThreadPoolExecutorTest exte
1916                  }
1917              }
1918              // enough time to run all tasks
1919 <            assertTrue(done.await(nTasks * SHORT_DELAY_MS, MILLISECONDS));
1919 >            await(done, nTasks * SHORT_DELAY_MS);
1920          }
1921      }
1922  
# Line 2075 | Line 1957 | public class ThreadPoolExecutorTest exte
1957          }
1958      }
1959  
1960 +    /** Directly test simple ThreadPoolExecutor RejectedExecutionHandlers. */
1961 +    public void testStandardRejectedExecutionHandlers() {
1962 +        final ThreadPoolExecutor p =
1963 +            new ThreadPoolExecutor(1, 1, 1, SECONDS,
1964 +                                   new ArrayBlockingQueue<Runnable>(1));
1965 +        final AtomicReference<Thread> thread = new AtomicReference<>();
1966 +        final Runnable r = new Runnable() { public void run() {
1967 +            thread.set(Thread.currentThread()); }};
1968 +
1969 +        try {
1970 +            new AbortPolicy().rejectedExecution(r, p);
1971 +            shouldThrow();
1972 +        } catch (RejectedExecutionException success) {}
1973 +        assertNull(thread.get());
1974 +
1975 +        new DiscardPolicy().rejectedExecution(r, p);
1976 +        assertNull(thread.get());
1977 +
1978 +        new CallerRunsPolicy().rejectedExecution(r, p);
1979 +        assertSame(Thread.currentThread(), thread.get());
1980 +
1981 +        // check that pool was not perturbed by handlers
1982 +        assertTrue(p.getRejectedExecutionHandler() instanceof AbortPolicy);
1983 +        assertEquals(0, p.getTaskCount());
1984 +        assertTrue(p.getQueue().isEmpty());
1985 +    }
1986 +
1987   }

Diff Legend

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