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.120 by jsr166, Sat Jul 15 18:17:40 2017 UTC vs.
Revision 1.122 by jsr166, Sat Jul 15 18:42:01 2017 UTC

# Line 29 | Line 29 | import java.util.concurrent.RejectedExec
29   import java.util.concurrent.SynchronousQueue;
30   import java.util.concurrent.ThreadFactory;
31   import java.util.concurrent.ThreadPoolExecutor;
32 + import java.util.concurrent.ThreadPoolExecutor.AbortPolicy;
33 + import java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy;
34 + import java.util.concurrent.ThreadPoolExecutor.DiscardPolicy;
35 + import java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy;
36   import java.util.concurrent.atomic.AtomicInteger;
37 + import java.util.concurrent.atomic.AtomicReference;
38  
39   import junit.framework.Test;
40   import junit.framework.TestSuite;
# Line 284 | Line 289 | public class ThreadPoolExecutorTest exte
289                                     LONG_DELAY_MS, MILLISECONDS,
290                                     new ArrayBlockingQueue<Runnable>(10));
291          try (PoolCleaner cleaner = cleaner(p)) {
292 <            assertTrue(p.getRejectedExecutionHandler()
288 <                       instanceof ThreadPoolExecutor.AbortPolicy);
292 >            assertTrue(p.getRejectedExecutionHandler() instanceof AbortPolicy);
293          }
294      }
295  
# Line 1147 | Line 1151 | public class ThreadPoolExecutorTest exte
1151                                     LONG_DELAY_MS,
1152                                     MILLISECONDS,
1153                                     new ArrayBlockingQueue<Runnable>(1),
1154 <                                   new ThreadPoolExecutor.CallerRunsPolicy());
1154 >                                   new CallerRunsPolicy());
1155          try (PoolCleaner cleaner = cleaner(p)) {
1156              final CountDownLatch done = new CountDownLatch(1);
1157              Runnable blocker = new CheckedRunnable() {
# Line 1179 | Line 1183 | public class ThreadPoolExecutorTest exte
1183              new ThreadPoolExecutor(1, 1,
1184                            LONG_DELAY_MS, MILLISECONDS,
1185                            new ArrayBlockingQueue<Runnable>(1),
1186 <                          new ThreadPoolExecutor.DiscardPolicy());
1186 >                          new DiscardPolicy());
1187          try (PoolCleaner cleaner = cleaner(p, done)) {
1188              p.execute(awaiter(done));
1189  
# Line 1205 | Line 1209 | public class ThreadPoolExecutorTest exte
1209              new ThreadPoolExecutor(1, 1,
1210                                     LONG_DELAY_MS, MILLISECONDS,
1211                                     new ArrayBlockingQueue<Runnable>(1),
1212 <                                   new ThreadPoolExecutor.DiscardOldestPolicy());
1212 >                                   new DiscardOldestPolicy());
1213          try (PoolCleaner cleaner = cleaner(p, done)) {
1214              assertEquals(LatchAwaiter.NEW, r1.state);
1215              assertEquals(LatchAwaiter.NEW, r2.state);
# Line 1243 | Line 1247 | public class ThreadPoolExecutorTest exte
1247       * execute using CallerRunsPolicy drops task on shutdown
1248       */
1249      public void testCallerRunsOnShutdown() {
1250 <        RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy();
1250 >        RejectedExecutionHandler h = new CallerRunsPolicy();
1251          final ThreadPoolExecutor p =
1252              new ThreadPoolExecutor(1, 1,
1253                                     LONG_DELAY_MS, MILLISECONDS,
# Line 1265 | Line 1269 | public class ThreadPoolExecutorTest exte
1269              new ThreadPoolExecutor(1, 1,
1270                                     LONG_DELAY_MS, MILLISECONDS,
1271                                     new ArrayBlockingQueue<Runnable>(1),
1272 <                                   new ThreadPoolExecutor.DiscardPolicy());
1272 >                                   new DiscardPolicy());
1273  
1274          try { p.shutdown(); } catch (SecurityException ok) { return; }
1275          try (PoolCleaner cleaner = cleaner(p)) {
# Line 1283 | Line 1287 | public class ThreadPoolExecutorTest exte
1287              new ThreadPoolExecutor(1, 1,
1288                                     LONG_DELAY_MS, MILLISECONDS,
1289                                     new ArrayBlockingQueue<Runnable>(1),
1290 <                                   new ThreadPoolExecutor.DiscardOldestPolicy());
1290 >                                   new DiscardOldestPolicy());
1291  
1292          try { p.shutdown(); } catch (SecurityException ok) { return; }
1293          try (PoolCleaner cleaner = cleaner(p)) {
# Line 2081 | Line 2085 | public class ThreadPoolExecutorTest exte
2085          }
2086      }
2087  
2088 <    public void testAbortPolicy() {
2089 <        final RejectedExecutionHandler handler =
2086 <            new ThreadPoolExecutor.AbortPolicy();
2088 >    /** Directly test simple ThreadPoolExecutor RejectedExecutionHandlers. */
2089 >    public void testStandardRejectedExecutionHandlers() {
2090          final ThreadPoolExecutor p =
2091 <            new ThreadPoolExecutor(1, 1,
2092 <                                   LONG_DELAY_MS, MILLISECONDS,
2093 <                                   new ArrayBlockingQueue<Runnable>(10));
2094 <        final TrackedNoOpRunnable r = new TrackedNoOpRunnable();
2091 >            new ThreadPoolExecutor(1, 1, 1, SECONDS,
2092 >                                   new ArrayBlockingQueue<Runnable>(1));
2093 >        final AtomicReference<Thread> thread = new AtomicReference<>();
2094 >        final Runnable r = new Runnable() { public void run() {
2095 >            thread.set(Thread.currentThread()); }};
2096 >
2097          try {
2098 <            handler.rejectedExecution(r, p);
2098 >            new AbortPolicy().rejectedExecution(r, p);
2099              shouldThrow();
2100          } catch (RejectedExecutionException success) {}
2101 <        assertFalse(r.done);
2101 >        assertNull(thread.get());
2102 >
2103 >        new DiscardPolicy().rejectedExecution(r, p);
2104 >        assertNull(thread.get());
2105 >
2106 >        new CallerRunsPolicy().rejectedExecution(r, p);
2107 >        assertSame(Thread.currentThread(), thread.get());
2108 >
2109 >        // check that pool was not perturbed by handlers
2110 >        assertTrue(p.getRejectedExecutionHandler() instanceof AbortPolicy);
2111          assertEquals(0, p.getTaskCount());
2112          assertTrue(p.getQueue().isEmpty());
2113      }

Diff Legend

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