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.48 by jsr166, Mon May 20 16:51:56 2013 UTC vs.
Revision 1.84 by jsr166, Sun Oct 4 02:31:15 2015 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 import junit.framework.*;
10 import java.util.concurrent.*;
9   import static java.util.concurrent.TimeUnit.MILLISECONDS;
10   import static java.util.concurrent.TimeUnit.NANOSECONDS;
11 < import java.util.*;
11 > import static java.util.concurrent.TimeUnit.SECONDS;
12 >
13 > import java.util.ArrayList;
14 > import java.util.List;
15 > import java.util.concurrent.ArrayBlockingQueue;
16 > import java.util.concurrent.BlockingQueue;
17 > import java.util.concurrent.Callable;
18 > import java.util.concurrent.CancellationException;
19 > import java.util.concurrent.CountDownLatch;
20 > import java.util.concurrent.ExecutionException;
21 > import java.util.concurrent.Executors;
22 > import java.util.concurrent.ExecutorService;
23 > import java.util.concurrent.Future;
24 > import java.util.concurrent.FutureTask;
25 > import java.util.concurrent.LinkedBlockingQueue;
26 > import java.util.concurrent.RejectedExecutionException;
27 > import java.util.concurrent.RejectedExecutionHandler;
28 > import java.util.concurrent.SynchronousQueue;
29 > import java.util.concurrent.ThreadFactory;
30 > import java.util.concurrent.ThreadPoolExecutor;
31 > import java.util.concurrent.TimeUnit;
32 > import java.util.concurrent.atomic.AtomicInteger;
33 >
34 > import junit.framework.Test;
35 > import junit.framework.TestSuite;
36  
37   public class ThreadPoolExecutorTest extends JSR166TestCase {
38      public static void main(String[] args) {
39 <        junit.textui.TestRunner.run(suite());
39 >        main(suite(), args);
40      }
41      public static Test suite() {
42          return new TestSuite(ThreadPoolExecutorTest.class);
# Line 65 | Line 87 | public class ThreadPoolExecutorTest exte
87              new ThreadPoolExecutor(1, 1,
88                                     LONG_DELAY_MS, MILLISECONDS,
89                                     new ArrayBlockingQueue<Runnable>(10));
90 <        final CountDownLatch done = new CountDownLatch(1);
91 <        final Runnable task = new CheckedRunnable() {
92 <            public void realRun() {
93 <                done.countDown();
72 <            }};
73 <        try {
90 >        try (PoolCleaner cleaner = cleaner(p)) {
91 >            final CountDownLatch done = new CountDownLatch(1);
92 >            final Runnable task = new CheckedRunnable() {
93 >                public void realRun() { done.countDown(); }};
94              p.execute(task);
95 <            assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS));
76 <        } finally {
77 <            joinPool(p);
95 >            assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
96          }
97      }
98  
# Line 87 | Line 105 | public class ThreadPoolExecutorTest exte
105              new ThreadPoolExecutor(2, 2,
106                                     LONG_DELAY_MS, MILLISECONDS,
107                                     new ArrayBlockingQueue<Runnable>(10));
108 <        final CountDownLatch threadStarted = new CountDownLatch(1);
109 <        final CountDownLatch done = new CountDownLatch(1);
110 <        try {
108 >        try (PoolCleaner cleaner = cleaner(p)) {
109 >            final CountDownLatch threadStarted = new CountDownLatch(1);
110 >            final CountDownLatch done = new CountDownLatch(1);
111              assertEquals(0, p.getActiveCount());
112              p.execute(new CheckedRunnable() {
113                  public void realRun() throws InterruptedException {
# Line 97 | Line 115 | public class ThreadPoolExecutorTest exte
115                      assertEquals(1, p.getActiveCount());
116                      done.await();
117                  }});
118 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
118 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
119              assertEquals(1, p.getActiveCount());
102        } finally {
120              done.countDown();
104            joinPool(p);
121          }
122      }
123  
# Line 110 | Line 126 | public class ThreadPoolExecutorTest exte
126       */
127      public void testPrestartCoreThread() {
128          final ThreadPoolExecutor p =
129 <            new ThreadPoolExecutor(2, 2,
129 >            new ThreadPoolExecutor(2, 6,
130                                     LONG_DELAY_MS, MILLISECONDS,
131                                     new ArrayBlockingQueue<Runnable>(10));
132 <        assertEquals(0, p.getPoolSize());
133 <        assertTrue(p.prestartCoreThread());
134 <        assertEquals(1, p.getPoolSize());
135 <        assertTrue(p.prestartCoreThread());
136 <        assertEquals(2, p.getPoolSize());
137 <        assertFalse(p.prestartCoreThread());
138 <        assertEquals(2, p.getPoolSize());
139 <        joinPool(p);
132 >        try (PoolCleaner cleaner = cleaner(p)) {
133 >            assertEquals(0, p.getPoolSize());
134 >            assertTrue(p.prestartCoreThread());
135 >            assertEquals(1, p.getPoolSize());
136 >            assertTrue(p.prestartCoreThread());
137 >            assertEquals(2, p.getPoolSize());
138 >            assertFalse(p.prestartCoreThread());
139 >            assertEquals(2, p.getPoolSize());
140 >            p.setCorePoolSize(4);
141 >            assertTrue(p.prestartCoreThread());
142 >            assertEquals(3, p.getPoolSize());
143 >            assertTrue(p.prestartCoreThread());
144 >            assertEquals(4, p.getPoolSize());
145 >            assertFalse(p.prestartCoreThread());
146 >            assertEquals(4, p.getPoolSize());
147 >        }
148      }
149  
150      /**
# Line 128 | Line 152 | public class ThreadPoolExecutorTest exte
152       */
153      public void testPrestartAllCoreThreads() {
154          final ThreadPoolExecutor p =
155 <            new ThreadPoolExecutor(2, 2,
155 >            new ThreadPoolExecutor(2, 6,
156                                     LONG_DELAY_MS, MILLISECONDS,
157                                     new ArrayBlockingQueue<Runnable>(10));
158 <        assertEquals(0, p.getPoolSize());
159 <        p.prestartAllCoreThreads();
160 <        assertEquals(2, p.getPoolSize());
161 <        p.prestartAllCoreThreads();
162 <        assertEquals(2, p.getPoolSize());
163 <        joinPool(p);
158 >        try (PoolCleaner cleaner = cleaner(p)) {
159 >            assertEquals(0, p.getPoolSize());
160 >            p.prestartAllCoreThreads();
161 >            assertEquals(2, p.getPoolSize());
162 >            p.prestartAllCoreThreads();
163 >            assertEquals(2, p.getPoolSize());
164 >            p.setCorePoolSize(4);
165 >            p.prestartAllCoreThreads();
166 >            assertEquals(4, p.getPoolSize());
167 >            p.prestartAllCoreThreads();
168 >            assertEquals(4, p.getPoolSize());
169 >        }
170      }
171  
172      /**
# Line 148 | Line 178 | public class ThreadPoolExecutorTest exte
178              new ThreadPoolExecutor(2, 2,
179                                     LONG_DELAY_MS, MILLISECONDS,
180                                     new ArrayBlockingQueue<Runnable>(10));
181 <        final CountDownLatch threadStarted = new CountDownLatch(1);
182 <        final CountDownLatch threadProceed = new CountDownLatch(1);
183 <        final CountDownLatch threadDone = new CountDownLatch(1);
184 <        try {
181 >        try (PoolCleaner cleaner = cleaner(p)) {
182 >            final CountDownLatch threadStarted = new CountDownLatch(1);
183 >            final CountDownLatch threadProceed = new CountDownLatch(1);
184 >            final CountDownLatch threadDone = new CountDownLatch(1);
185              assertEquals(0, p.getCompletedTaskCount());
186              p.execute(new CheckedRunnable() {
187                  public void realRun() throws InterruptedException {
# Line 170 | Line 200 | public class ThreadPoolExecutorTest exte
200                      fail("timed out");
201                  Thread.yield();
202              }
173        } finally {
174            joinPool(p);
203          }
204      }
205  
# Line 183 | Line 211 | public class ThreadPoolExecutorTest exte
211              new ThreadPoolExecutor(1, 1,
212                                     LONG_DELAY_MS, MILLISECONDS,
213                                     new ArrayBlockingQueue<Runnable>(10));
214 <        assertEquals(1, p.getCorePoolSize());
215 <        joinPool(p);
214 >        try (PoolCleaner cleaner = cleaner(p)) {
215 >            assertEquals(1, p.getCorePoolSize());
216 >        }
217      }
218  
219      /**
# Line 195 | Line 224 | public class ThreadPoolExecutorTest exte
224              new ThreadPoolExecutor(2, 2,
225                                     1000, MILLISECONDS,
226                                     new ArrayBlockingQueue<Runnable>(10));
227 <        assertEquals(1, p.getKeepAliveTime(TimeUnit.SECONDS));
228 <        joinPool(p);
227 >        try (PoolCleaner cleaner = cleaner(p)) {
228 >            assertEquals(1, p.getKeepAliveTime(SECONDS));
229 >        }
230      }
231  
232      /**
233       * getThreadFactory returns factory in constructor if not set
234       */
235      public void testGetThreadFactory() {
236 <        ThreadFactory tf = new SimpleThreadFactory();
236 >        ThreadFactory threadFactory = new SimpleThreadFactory();
237          final ThreadPoolExecutor p =
238              new ThreadPoolExecutor(1, 2,
239                                     LONG_DELAY_MS, MILLISECONDS,
240                                     new ArrayBlockingQueue<Runnable>(10),
241 <                                   tf,
241 >                                   threadFactory,
242                                     new NoOpREHandler());
243 <        assertSame(tf, p.getThreadFactory());
244 <        joinPool(p);
243 >        try (PoolCleaner cleaner = cleaner(p)) {
244 >            assertSame(threadFactory, p.getThreadFactory());
245 >        }
246      }
247  
248      /**
# Line 222 | Line 253 | public class ThreadPoolExecutorTest exte
253              new ThreadPoolExecutor(1, 2,
254                                     LONG_DELAY_MS, MILLISECONDS,
255                                     new ArrayBlockingQueue<Runnable>(10));
256 <        ThreadFactory tf = new SimpleThreadFactory();
257 <        p.setThreadFactory(tf);
258 <        assertSame(tf, p.getThreadFactory());
259 <        joinPool(p);
256 >        try (PoolCleaner cleaner = cleaner(p)) {
257 >            ThreadFactory threadFactory = new SimpleThreadFactory();
258 >            p.setThreadFactory(threadFactory);
259 >            assertSame(threadFactory, p.getThreadFactory());
260 >        }
261      }
262  
263      /**
# Line 236 | Line 268 | public class ThreadPoolExecutorTest exte
268              new ThreadPoolExecutor(1, 2,
269                                     LONG_DELAY_MS, MILLISECONDS,
270                                     new ArrayBlockingQueue<Runnable>(10));
271 <        try {
272 <            p.setThreadFactory(null);
273 <            shouldThrow();
274 <        } catch (NullPointerException success) {
275 <        } finally {
244 <            joinPool(p);
271 >        try (PoolCleaner cleaner = cleaner(p)) {
272 >            try {
273 >                p.setThreadFactory(null);
274 >                shouldThrow();
275 >            } catch (NullPointerException success) {}
276          }
277      }
278  
# Line 249 | Line 280 | public class ThreadPoolExecutorTest exte
280       * getRejectedExecutionHandler returns handler in constructor if not set
281       */
282      public void testGetRejectedExecutionHandler() {
283 <        final RejectedExecutionHandler h = new NoOpREHandler();
283 >        final RejectedExecutionHandler handler = new NoOpREHandler();
284          final ThreadPoolExecutor p =
285              new ThreadPoolExecutor(1, 2,
286                                     LONG_DELAY_MS, MILLISECONDS,
287                                     new ArrayBlockingQueue<Runnable>(10),
288 <                                   h);
289 <        assertSame(h, p.getRejectedExecutionHandler());
290 <        joinPool(p);
288 >                                   handler);
289 >        try (PoolCleaner cleaner = cleaner(p)) {
290 >            assertSame(handler, p.getRejectedExecutionHandler());
291 >        }
292      }
293  
294      /**
# Line 268 | Line 300 | public class ThreadPoolExecutorTest exte
300              new ThreadPoolExecutor(1, 2,
301                                     LONG_DELAY_MS, MILLISECONDS,
302                                     new ArrayBlockingQueue<Runnable>(10));
303 <        RejectedExecutionHandler h = new NoOpREHandler();
304 <        p.setRejectedExecutionHandler(h);
305 <        assertSame(h, p.getRejectedExecutionHandler());
306 <        joinPool(p);
303 >        try (PoolCleaner cleaner = cleaner(p)) {
304 >            RejectedExecutionHandler handler = new NoOpREHandler();
305 >            p.setRejectedExecutionHandler(handler);
306 >            assertSame(handler, p.getRejectedExecutionHandler());
307 >        }
308      }
309  
310      /**
# Line 282 | Line 315 | public class ThreadPoolExecutorTest exte
315              new ThreadPoolExecutor(1, 2,
316                                     LONG_DELAY_MS, MILLISECONDS,
317                                     new ArrayBlockingQueue<Runnable>(10));
318 <        try {
319 <            p.setRejectedExecutionHandler(null);
320 <            shouldThrow();
321 <        } catch (NullPointerException success) {
322 <        } finally {
290 <            joinPool(p);
318 >        try (PoolCleaner cleaner = cleaner(p)) {
319 >            try {
320 >                p.setRejectedExecutionHandler(null);
321 >                shouldThrow();
322 >            } catch (NullPointerException success) {}
323          }
324      }
325  
# Line 301 | Line 333 | public class ThreadPoolExecutorTest exte
333              new ThreadPoolExecutor(THREADS, THREADS,
334                                     LONG_DELAY_MS, MILLISECONDS,
335                                     new ArrayBlockingQueue<Runnable>(10));
336 <        final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
337 <        final CountDownLatch done = new CountDownLatch(1);
338 <        try {
336 >        try (PoolCleaner cleaner = cleaner(p)) {
337 >            final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
338 >            final CountDownLatch done = new CountDownLatch(1);
339              assertEquals(0, p.getLargestPoolSize());
340              for (int i = 0; i < THREADS; i++)
341                  p.execute(new CheckedRunnable() {
# Line 312 | Line 344 | public class ThreadPoolExecutorTest exte
344                          done.await();
345                          assertEquals(THREADS, p.getLargestPoolSize());
346                      }});
347 <            assertTrue(threadsStarted.await(SMALL_DELAY_MS, MILLISECONDS));
316 <            assertEquals(THREADS, p.getLargestPoolSize());
317 <        } finally {
318 <            done.countDown();
319 <            joinPool(p);
347 >            assertTrue(threadsStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
348              assertEquals(THREADS, p.getLargestPoolSize());
349 +            done.countDown();   // release pool
350          }
351 +        assertEquals(THREADS, p.getLargestPoolSize());
352      }
353  
354      /**
# Line 330 | Line 360 | public class ThreadPoolExecutorTest exte
360              new ThreadPoolExecutor(2, 3,
361                                     LONG_DELAY_MS, MILLISECONDS,
362                                     new ArrayBlockingQueue<Runnable>(10));
363 <        assertEquals(3, p.getMaximumPoolSize());
364 <        joinPool(p);
363 >        try (PoolCleaner cleaner = cleaner(p)) {
364 >            assertEquals(3, p.getMaximumPoolSize());
365 >            p.setMaximumPoolSize(5);
366 >            assertEquals(5, p.getMaximumPoolSize());
367 >            p.setMaximumPoolSize(4);
368 >            assertEquals(4, p.getMaximumPoolSize());
369 >        }
370      }
371  
372      /**
# Line 343 | Line 378 | public class ThreadPoolExecutorTest exte
378              new ThreadPoolExecutor(1, 1,
379                                     LONG_DELAY_MS, MILLISECONDS,
380                                     new ArrayBlockingQueue<Runnable>(10));
381 <        final CountDownLatch threadStarted = new CountDownLatch(1);
382 <        final CountDownLatch done = new CountDownLatch(1);
383 <        try {
381 >        try (PoolCleaner cleaner = cleaner(p)) {
382 >            final CountDownLatch threadStarted = new CountDownLatch(1);
383 >            final CountDownLatch done = new CountDownLatch(1);
384              assertEquals(0, p.getPoolSize());
385              p.execute(new CheckedRunnable() {
386                  public void realRun() throws InterruptedException {
# Line 353 | Line 388 | public class ThreadPoolExecutorTest exte
388                      assertEquals(1, p.getPoolSize());
389                      done.await();
390                  }});
391 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
391 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
392              assertEquals(1, p.getPoolSize());
393 <        } finally {
359 <            done.countDown();
360 <            joinPool(p);
393 >            done.countDown();   // release pool
394          }
395      }
396  
# Line 369 | Line 402 | public class ThreadPoolExecutorTest exte
402              new ThreadPoolExecutor(1, 1,
403                                     LONG_DELAY_MS, MILLISECONDS,
404                                     new ArrayBlockingQueue<Runnable>(10));
405 <        final CountDownLatch threadStarted = new CountDownLatch(1);
406 <        final CountDownLatch done = new CountDownLatch(1);
407 <        try {
405 >        try (PoolCleaner cleaner = cleaner(p)) {
406 >            final CountDownLatch threadStarted = new CountDownLatch(1);
407 >            final CountDownLatch done = new CountDownLatch(1);
408              assertEquals(0, p.getTaskCount());
409              p.execute(new CheckedRunnable() {
410                  public void realRun() throws InterruptedException {
# Line 379 | Line 412 | public class ThreadPoolExecutorTest exte
412                      assertEquals(1, p.getTaskCount());
413                      done.await();
414                  }});
415 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
415 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
416              assertEquals(1, p.getTaskCount());
384        } finally {
417              done.countDown();
386            joinPool(p);
418          }
419      }
420  
# Line 395 | Line 426 | public class ThreadPoolExecutorTest exte
426              new ThreadPoolExecutor(1, 1,
427                                     LONG_DELAY_MS, MILLISECONDS,
428                                     new ArrayBlockingQueue<Runnable>(10));
429 <        assertFalse(p.isShutdown());
430 <        try { p.shutdown(); } catch (SecurityException ok) { return; }
431 <        assertTrue(p.isShutdown());
432 <        joinPool(p);
429 >        try (PoolCleaner cleaner = cleaner(p)) {
430 >            assertFalse(p.isShutdown());
431 >            try { p.shutdown(); } catch (SecurityException ok) { return; }
432 >            assertTrue(p.isShutdown());
433 >        }
434      }
435  
436      /**
# Line 409 | Line 441 | public class ThreadPoolExecutorTest exte
441              new ThreadPoolExecutor(1, 1,
442                                     LONG_DELAY_MS, MILLISECONDS,
443                                     new ArrayBlockingQueue<Runnable>(10));
444 <        assertFalse(p.isTerminated());
445 <        assertFalse(p.awaitTermination(Long.MIN_VALUE, NANOSECONDS));
446 <        assertFalse(p.awaitTermination(Long.MIN_VALUE, MILLISECONDS));
447 <        assertFalse(p.awaitTermination(-1L, NANOSECONDS));
448 <        assertFalse(p.awaitTermination(-1L, MILLISECONDS));
449 <        assertFalse(p.awaitTermination(0L, NANOSECONDS));
450 <        assertFalse(p.awaitTermination(0L, MILLISECONDS));
451 <        long timeoutNanos = 999999L;
452 <        long startTime = System.nanoTime();
453 <        assertFalse(p.awaitTermination(timeoutNanos, NANOSECONDS));
454 <        assertTrue(System.nanoTime() - startTime >= timeoutNanos);
455 <        assertFalse(p.isTerminated());
456 <        startTime = System.nanoTime();
457 <        long timeoutMillis = timeoutMillis();
458 <        assertFalse(p.awaitTermination(timeoutMillis, MILLISECONDS));
459 <        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
460 <        assertFalse(p.isTerminated());
461 <        p.shutdown();
462 <        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
463 <        assertTrue(p.isTerminated());
444 >        try (PoolCleaner cleaner = cleaner(p)) {
445 >            assertFalse(p.isTerminated());
446 >            assertFalse(p.awaitTermination(Long.MIN_VALUE, NANOSECONDS));
447 >            assertFalse(p.awaitTermination(Long.MIN_VALUE, MILLISECONDS));
448 >            assertFalse(p.awaitTermination(-1L, NANOSECONDS));
449 >            assertFalse(p.awaitTermination(-1L, MILLISECONDS));
450 >            assertFalse(p.awaitTermination(0L, NANOSECONDS));
451 >            assertFalse(p.awaitTermination(0L, MILLISECONDS));
452 >            long timeoutNanos = 999999L;
453 >            long startTime = System.nanoTime();
454 >            assertFalse(p.awaitTermination(timeoutNanos, NANOSECONDS));
455 >            assertTrue(System.nanoTime() - startTime >= timeoutNanos);
456 >            assertFalse(p.isTerminated());
457 >            startTime = System.nanoTime();
458 >            long timeoutMillis = timeoutMillis();
459 >            assertFalse(p.awaitTermination(timeoutMillis, MILLISECONDS));
460 >            assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
461 >            assertFalse(p.isTerminated());
462 >            try { p.shutdown(); } catch (SecurityException ok) { return; }
463 >            assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
464 >            assertTrue(p.isTerminated());
465 >        }
466      }
467  
468      /**
# Line 439 | Line 473 | public class ThreadPoolExecutorTest exte
473              new ThreadPoolExecutor(1, 1,
474                                     LONG_DELAY_MS, MILLISECONDS,
475                                     new ArrayBlockingQueue<Runnable>(10));
476 <        final CountDownLatch threadStarted = new CountDownLatch(1);
477 <        final CountDownLatch done = new CountDownLatch(1);
478 <        assertFalse(p.isTerminated());
479 <        try {
476 >        try (PoolCleaner cleaner = cleaner(p)) {
477 >            final CountDownLatch threadStarted = new CountDownLatch(1);
478 >            final CountDownLatch done = new CountDownLatch(1);
479 >            assertFalse(p.isTerminating());
480              p.execute(new CheckedRunnable() {
481                  public void realRun() throws InterruptedException {
482 <                    assertFalse(p.isTerminated());
482 >                    assertFalse(p.isTerminating());
483                      threadStarted.countDown();
484                      done.await();
485                  }});
486 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
486 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
487              assertFalse(p.isTerminating());
488              done.countDown();
455        } finally {
489              try { p.shutdown(); } catch (SecurityException ok) { return; }
490 +            assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
491 +            assertTrue(p.isTerminated());
492 +            assertFalse(p.isTerminating());
493          }
458        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
459        assertTrue(p.isTerminated());
494      }
495  
496      /**
# Line 477 | Line 511 | public class ThreadPoolExecutorTest exte
511                      threadStarted.countDown();
512                      done.await();
513                  }});
514 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
514 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
515              assertFalse(p.isTerminating());
516              done.countDown();
517          } finally {
# Line 512 | Line 546 | public class ThreadPoolExecutorTest exte
546                  tasks[i] = new FutureTask(task);
547                  p.execute(tasks[i]);
548              }
549 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
549 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
550              assertSame(q, p.getQueue());
551              assertFalse(q.contains(tasks[0]));
552              assertTrue(q.contains(tasks[tasks.length - 1]));
# Line 544 | Line 578 | public class ThreadPoolExecutorTest exte
578                      }};
579                  p.execute(tasks[i]);
580              }
581 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
581 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
582              assertFalse(p.remove(tasks[0]));
583              assertTrue(q.contains(tasks[4]));
584              assertTrue(q.contains(tasks[3]));
# Line 583 | Line 617 | public class ThreadPoolExecutorTest exte
617                  tasks[i] = new FutureTask(task);
618                  p.execute(tasks[i]);
619              }
620 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
620 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
621              assertEquals(tasks.length, p.getTaskCount());
622              assertEquals(tasks.length - 1, q.size());
623              assertEquals(1L, p.getActiveCount());
# Line 603 | Line 637 | public class ThreadPoolExecutorTest exte
637      }
638  
639      /**
640 <     * shutdownNow returns a list containing tasks that were not run
640 >     * shutdownNow returns a list containing tasks that were not run,
641 >     * and those tasks are drained from the queue
642       */
643 <    public void testShutdownNow() {
643 >    public void testShutdownNow() throws InterruptedException {
644 >        final int poolSize = 2;
645 >        final int count = 5;
646 >        final AtomicInteger ran = new AtomicInteger(0);
647          final ThreadPoolExecutor p =
648 <            new ThreadPoolExecutor(1, 1,
648 >            new ThreadPoolExecutor(poolSize, poolSize,
649                                     LONG_DELAY_MS, MILLISECONDS,
650                                     new ArrayBlockingQueue<Runnable>(10));
651 <        List l;
652 <        try {
653 <            for (int i = 0; i < 5; i++)
616 <                p.execute(new MediumPossiblyInterruptedRunnable());
617 <        }
618 <        finally {
651 >        CountDownLatch threadsStarted = new CountDownLatch(poolSize);
652 >        Runnable waiter = new CheckedRunnable() { public void realRun() {
653 >            threadsStarted.countDown();
654              try {
655 <                l = p.shutdownNow();
656 <            } catch (SecurityException ok) { return; }
655 >                MILLISECONDS.sleep(2 * LONG_DELAY_MS);
656 >            } catch (InterruptedException success) {}
657 >            ran.getAndIncrement();
658 >        }};
659 >        for (int i = 0; i < count; i++)
660 >            p.execute(waiter);
661 >        assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
662 >        assertEquals(poolSize, p.getActiveCount());
663 >        assertEquals(0, p.getCompletedTaskCount());
664 >        final List<Runnable> queuedTasks;
665 >        try {
666 >            queuedTasks = p.shutdownNow();
667 >        } catch (SecurityException ok) {
668 >            return; // Allowed in case test doesn't have privs
669          }
670          assertTrue(p.isShutdown());
671 <        assertTrue(l.size() <= 4);
671 >        assertTrue(p.getQueue().isEmpty());
672 >        assertEquals(count - poolSize, queuedTasks.size());
673 >        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
674 >        assertTrue(p.isTerminated());
675 >        assertEquals(poolSize, ran.get());
676 >        assertEquals(poolSize, p.getCompletedTaskCount());
677      }
678  
679      // Exception Tests
# Line 631 | Line 683 | public class ThreadPoolExecutorTest exte
683       */
684      public void testConstructor1() {
685          try {
686 <            new ThreadPoolExecutor(-1, 1,
635 <                                   LONG_DELAY_MS, MILLISECONDS,
686 >            new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
687                                     new ArrayBlockingQueue<Runnable>(10));
688              shouldThrow();
689          } catch (IllegalArgumentException success) {}
# Line 643 | Line 694 | public class ThreadPoolExecutorTest exte
694       */
695      public void testConstructor2() {
696          try {
697 <            new ThreadPoolExecutor(1, -1,
647 <                                   LONG_DELAY_MS, MILLISECONDS,
697 >            new ThreadPoolExecutor(1, -1, 1L, SECONDS,
698                                     new ArrayBlockingQueue<Runnable>(10));
699              shouldThrow();
700          } catch (IllegalArgumentException success) {}
# Line 655 | Line 705 | public class ThreadPoolExecutorTest exte
705       */
706      public void testConstructor3() {
707          try {
708 <            new ThreadPoolExecutor(1, 0,
659 <                                   LONG_DELAY_MS, MILLISECONDS,
708 >            new ThreadPoolExecutor(1, 0, 1L, SECONDS,
709                                     new ArrayBlockingQueue<Runnable>(10));
710              shouldThrow();
711          } catch (IllegalArgumentException success) {}
# Line 667 | Line 716 | public class ThreadPoolExecutorTest exte
716       */
717      public void testConstructor4() {
718          try {
719 <            new ThreadPoolExecutor(1, 2,
671 <                                   -1L, MILLISECONDS,
719 >            new ThreadPoolExecutor(1, 2, -1L, SECONDS,
720                                     new ArrayBlockingQueue<Runnable>(10));
721              shouldThrow();
722          } catch (IllegalArgumentException success) {}
# Line 679 | Line 727 | public class ThreadPoolExecutorTest exte
727       */
728      public void testConstructor5() {
729          try {
730 <            new ThreadPoolExecutor(2, 1,
683 <                                   LONG_DELAY_MS, MILLISECONDS,
730 >            new ThreadPoolExecutor(2, 1, 1L, SECONDS,
731                                     new ArrayBlockingQueue<Runnable>(10));
732              shouldThrow();
733          } catch (IllegalArgumentException success) {}
# Line 691 | Line 738 | public class ThreadPoolExecutorTest exte
738       */
739      public void testConstructorNullPointerException() {
740          try {
741 <            new ThreadPoolExecutor(1, 2,
695 <                                   LONG_DELAY_MS, MILLISECONDS,
741 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
742                                     (BlockingQueue) null);
743              shouldThrow();
744          } catch (NullPointerException success) {}
# Line 703 | Line 749 | public class ThreadPoolExecutorTest exte
749       */
750      public void testConstructor6() {
751          try {
752 <            new ThreadPoolExecutor(-1, 1,
707 <                                   LONG_DELAY_MS, MILLISECONDS,
752 >            new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
753                                     new ArrayBlockingQueue<Runnable>(10),
754                                     new SimpleThreadFactory());
755              shouldThrow();
# Line 716 | Line 761 | public class ThreadPoolExecutorTest exte
761       */
762      public void testConstructor7() {
763          try {
764 <            new ThreadPoolExecutor(1, -1,
720 <                                   LONG_DELAY_MS, MILLISECONDS,
764 >            new ThreadPoolExecutor(1, -1, 1L, SECONDS,
765                                     new ArrayBlockingQueue<Runnable>(10),
766                                     new SimpleThreadFactory());
767              shouldThrow();
# Line 729 | Line 773 | public class ThreadPoolExecutorTest exte
773       */
774      public void testConstructor8() {
775          try {
776 <            new ThreadPoolExecutor(1, 0,
733 <                                   LONG_DELAY_MS, MILLISECONDS,
776 >            new ThreadPoolExecutor(1, 0, 1L, SECONDS,
777                                     new ArrayBlockingQueue<Runnable>(10),
778                                     new SimpleThreadFactory());
779              shouldThrow();
# Line 742 | Line 785 | public class ThreadPoolExecutorTest exte
785       */
786      public void testConstructor9() {
787          try {
788 <            new ThreadPoolExecutor(1, 2,
746 <                                   -1L, MILLISECONDS,
788 >            new ThreadPoolExecutor(1, 2, -1L, SECONDS,
789                                     new ArrayBlockingQueue<Runnable>(10),
790                                     new SimpleThreadFactory());
791              shouldThrow();
# Line 755 | Line 797 | public class ThreadPoolExecutorTest exte
797       */
798      public void testConstructor10() {
799          try {
800 <            new ThreadPoolExecutor(2, 1,
759 <                                   LONG_DELAY_MS, MILLISECONDS,
800 >            new ThreadPoolExecutor(2, 1, 1L, SECONDS,
801                                     new ArrayBlockingQueue<Runnable>(10),
802                                     new SimpleThreadFactory());
803              shouldThrow();
# Line 768 | Line 809 | public class ThreadPoolExecutorTest exte
809       */
810      public void testConstructorNullPointerException2() {
811          try {
812 <            new ThreadPoolExecutor(1, 2,
772 <                                   LONG_DELAY_MS, MILLISECONDS,
812 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
813                                     (BlockingQueue) null,
814                                     new SimpleThreadFactory());
815              shouldThrow();
# Line 781 | Line 821 | public class ThreadPoolExecutorTest exte
821       */
822      public void testConstructorNullPointerException3() {
823          try {
824 <            new ThreadPoolExecutor(1, 2,
785 <                                   LONG_DELAY_MS, MILLISECONDS,
824 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
825                                     new ArrayBlockingQueue<Runnable>(10),
826                                     (ThreadFactory) null);
827              shouldThrow();
# Line 794 | Line 833 | public class ThreadPoolExecutorTest exte
833       */
834      public void testConstructor11() {
835          try {
836 <            new ThreadPoolExecutor(-1, 1,
798 <                                   LONG_DELAY_MS, MILLISECONDS,
836 >            new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
837                                     new ArrayBlockingQueue<Runnable>(10),
838                                     new NoOpREHandler());
839              shouldThrow();
# Line 807 | Line 845 | public class ThreadPoolExecutorTest exte
845       */
846      public void testConstructor12() {
847          try {
848 <            new ThreadPoolExecutor(1, -1,
811 <                                   LONG_DELAY_MS, MILLISECONDS,
848 >            new ThreadPoolExecutor(1, -1, 1L, SECONDS,
849                                     new ArrayBlockingQueue<Runnable>(10),
850                                     new NoOpREHandler());
851              shouldThrow();
# Line 820 | Line 857 | public class ThreadPoolExecutorTest exte
857       */
858      public void testConstructor13() {
859          try {
860 <            new ThreadPoolExecutor(1, 0,
824 <                                   LONG_DELAY_MS, MILLISECONDS,
860 >            new ThreadPoolExecutor(1, 0, 1L, SECONDS,
861                                     new ArrayBlockingQueue<Runnable>(10),
862                                     new NoOpREHandler());
863              shouldThrow();
# Line 833 | Line 869 | public class ThreadPoolExecutorTest exte
869       */
870      public void testConstructor14() {
871          try {
872 <            new ThreadPoolExecutor(1, 2,
837 <                                   -1L, MILLISECONDS,
872 >            new ThreadPoolExecutor(1, 2, -1L, SECONDS,
873                                     new ArrayBlockingQueue<Runnable>(10),
874                                     new NoOpREHandler());
875              shouldThrow();
# Line 846 | Line 881 | public class ThreadPoolExecutorTest exte
881       */
882      public void testConstructor15() {
883          try {
884 <            new ThreadPoolExecutor(2, 1,
850 <                                   LONG_DELAY_MS, MILLISECONDS,
884 >            new ThreadPoolExecutor(2, 1, 1L, SECONDS,
885                                     new ArrayBlockingQueue<Runnable>(10),
886                                     new NoOpREHandler());
887              shouldThrow();
# Line 859 | Line 893 | public class ThreadPoolExecutorTest exte
893       */
894      public void testConstructorNullPointerException4() {
895          try {
896 <            new ThreadPoolExecutor(1, 2,
863 <                                   LONG_DELAY_MS, MILLISECONDS,
896 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
897                                     (BlockingQueue) null,
898                                     new NoOpREHandler());
899              shouldThrow();
# Line 872 | Line 905 | public class ThreadPoolExecutorTest exte
905       */
906      public void testConstructorNullPointerException5() {
907          try {
908 <            new ThreadPoolExecutor(1, 2,
876 <                                   LONG_DELAY_MS, MILLISECONDS,
908 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
909                                     new ArrayBlockingQueue<Runnable>(10),
910                                     (RejectedExecutionHandler) null);
911              shouldThrow();
# Line 885 | Line 917 | public class ThreadPoolExecutorTest exte
917       */
918      public void testConstructor16() {
919          try {
920 <            new ThreadPoolExecutor(-1, 1,
889 <                                   LONG_DELAY_MS, MILLISECONDS,
920 >            new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
921                                     new ArrayBlockingQueue<Runnable>(10),
922                                     new SimpleThreadFactory(),
923                                     new NoOpREHandler());
# Line 899 | Line 930 | public class ThreadPoolExecutorTest exte
930       */
931      public void testConstructor17() {
932          try {
933 <            new ThreadPoolExecutor(1, -1,
903 <                                   LONG_DELAY_MS, MILLISECONDS,
933 >            new ThreadPoolExecutor(1, -1, 1L, SECONDS,
934                                     new ArrayBlockingQueue<Runnable>(10),
935                                     new SimpleThreadFactory(),
936                                     new NoOpREHandler());
# Line 913 | Line 943 | public class ThreadPoolExecutorTest exte
943       */
944      public void testConstructor18() {
945          try {
946 <            new ThreadPoolExecutor(1, 0,
917 <                                   LONG_DELAY_MS, MILLISECONDS,
946 >            new ThreadPoolExecutor(1, 0, 1L, SECONDS,
947                                     new ArrayBlockingQueue<Runnable>(10),
948                                     new SimpleThreadFactory(),
949                                     new NoOpREHandler());
# Line 927 | Line 956 | public class ThreadPoolExecutorTest exte
956       */
957      public void testConstructor19() {
958          try {
959 <            new ThreadPoolExecutor(1, 2,
931 <                                   -1L, MILLISECONDS,
959 >            new ThreadPoolExecutor(1, 2, -1L, SECONDS,
960                                     new ArrayBlockingQueue<Runnable>(10),
961                                     new SimpleThreadFactory(),
962                                     new NoOpREHandler());
# Line 941 | Line 969 | public class ThreadPoolExecutorTest exte
969       */
970      public void testConstructor20() {
971          try {
972 <            new ThreadPoolExecutor(2, 1,
945 <                                   LONG_DELAY_MS, MILLISECONDS,
972 >            new ThreadPoolExecutor(2, 1, 1L, SECONDS,
973                                     new ArrayBlockingQueue<Runnable>(10),
974                                     new SimpleThreadFactory(),
975                                     new NoOpREHandler());
# Line 955 | Line 982 | public class ThreadPoolExecutorTest exte
982       */
983      public void testConstructorNullPointerException6() {
984          try {
985 <            new ThreadPoolExecutor(1, 2,
959 <                                   LONG_DELAY_MS, MILLISECONDS,
985 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
986                                     (BlockingQueue) null,
987                                     new SimpleThreadFactory(),
988                                     new NoOpREHandler());
# Line 969 | Line 995 | public class ThreadPoolExecutorTest exte
995       */
996      public void testConstructorNullPointerException7() {
997          try {
998 <            new ThreadPoolExecutor(1, 2,
973 <                                   LONG_DELAY_MS, MILLISECONDS,
998 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
999                                     new ArrayBlockingQueue<Runnable>(10),
1000                                     new SimpleThreadFactory(),
1001                                     (RejectedExecutionHandler) null);
# Line 983 | Line 1008 | public class ThreadPoolExecutorTest exte
1008       */
1009      public void testConstructorNullPointerException8() {
1010          try {
1011 <            new ThreadPoolExecutor(1, 2,
987 <                                   LONG_DELAY_MS, MILLISECONDS,
1011 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
1012                                     new ArrayBlockingQueue<Runnable>(10),
1013                                     (ThreadFactory) null,
1014                                     new NoOpREHandler());
# Line 998 | Line 1022 | public class ThreadPoolExecutorTest exte
1022      public void testInterruptedSubmit() throws InterruptedException {
1023          final ThreadPoolExecutor p =
1024              new ThreadPoolExecutor(1, 1,
1025 <                                   60, TimeUnit.SECONDS,
1025 >                                   60, SECONDS,
1026                                     new ArrayBlockingQueue<Runnable>(10));
1027  
1028          final CountDownLatch threadStarted = new CountDownLatch(1);
# Line 1015 | Line 1039 | public class ThreadPoolExecutorTest exte
1039                      p.submit(task).get();
1040                  }});
1041  
1042 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
1042 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
1043              t.interrupt();
1044              awaitTermination(t, MEDIUM_DELAY_MS);
1045          } finally {
# Line 1272 | Line 1296 | public class ThreadPoolExecutorTest exte
1296       */
1297      public void testExecuteNull() {
1298          ThreadPoolExecutor p =
1299 <            new ThreadPoolExecutor(1, 2,
1276 <                                   LONG_DELAY_MS, MILLISECONDS,
1299 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
1300                                     new ArrayBlockingQueue<Runnable>(10));
1301          try {
1302              p.execute(null);
# Line 1340 | Line 1363 | public class ThreadPoolExecutorTest exte
1363      }
1364  
1365      /**
1366 +     * Configuration changes that allow core pool size greater than
1367 +     * max pool size result in IllegalArgumentException.
1368 +     */
1369 +    public void testPoolSizeInvariants() {
1370 +        ThreadPoolExecutor p =
1371 +            new ThreadPoolExecutor(1, 1,
1372 +                                   LONG_DELAY_MS, MILLISECONDS,
1373 +                                   new ArrayBlockingQueue<Runnable>(10));
1374 +        for (int s = 1; s < 5; s++) {
1375 +            p.setMaximumPoolSize(s);
1376 +            p.setCorePoolSize(s);
1377 +            try {
1378 +                p.setMaximumPoolSize(s - 1);
1379 +                shouldThrow();
1380 +            } catch (IllegalArgumentException success) {}
1381 +            assertEquals(s, p.getCorePoolSize());
1382 +            assertEquals(s, p.getMaximumPoolSize());
1383 +            try {
1384 +                p.setCorePoolSize(s + 1);
1385 +                shouldThrow();
1386 +            } catch (IllegalArgumentException success) {}
1387 +            assertEquals(s, p.getCorePoolSize());
1388 +            assertEquals(s, p.getMaximumPoolSize());
1389 +        }
1390 +        joinPool(p);
1391 +    }
1392 +
1393 +    /**
1394       * setKeepAliveTime throws IllegalArgumentException
1395       * when given a negative value
1396       */
# Line 1375 | Line 1426 | public class ThreadPoolExecutorTest exte
1426          ExtendedTPE p = new ExtendedTPE();
1427          try {
1428              final CountDownLatch done = new CountDownLatch(1);
1429 <            final CheckedRunnable task = new CheckedRunnable() {
1429 >            p.execute(new CheckedRunnable() {
1430                  public void realRun() {
1431                      done.countDown();
1432 <                }};
1382 <            p.execute(task);
1432 >                }});
1433              await(p.afterCalled);
1434              assertEquals(0, done.getCount());
1435              assertTrue(p.afterCalled());
# Line 1856 | Line 1906 | public class ThreadPoolExecutorTest exte
1906              l.add(new StringTask());
1907              l.add(new StringTask());
1908              List<Future<String>> futures =
1909 <                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1909 >                e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
1910              assertEquals(2, futures.size());
1911              for (Future<String> future : futures)
1912                  assertSame(TEST_STRING, future.get());
# Line 1874 | Line 1924 | public class ThreadPoolExecutorTest exte
1924                                     LONG_DELAY_MS, MILLISECONDS,
1925                                     new ArrayBlockingQueue<Runnable>(10));
1926          try {
1927 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1928 <            l.add(new StringTask());
1929 <            l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
1930 <            l.add(new StringTask());
1931 <            List<Future<String>> futures =
1932 <                e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
1933 <            assertEquals(l.size(), futures.size());
1934 <            for (Future future : futures)
1935 <                assertTrue(future.isDone());
1936 <            assertFalse(futures.get(0).isCancelled());
1937 <            assertTrue(futures.get(1).isCancelled());
1927 >            for (long timeout = timeoutMillis();;) {
1928 >                List<Callable<String>> tasks = new ArrayList<>();
1929 >                tasks.add(new StringTask("0"));
1930 >                tasks.add(Executors.callable(new LongPossiblyInterruptedRunnable(), TEST_STRING));
1931 >                tasks.add(new StringTask("2"));
1932 >                long startTime = System.nanoTime();
1933 >                List<Future<String>> futures =
1934 >                    e.invokeAll(tasks, timeout, MILLISECONDS);
1935 >                assertEquals(tasks.size(), futures.size());
1936 >                assertTrue(millisElapsedSince(startTime) >= timeout);
1937 >                for (Future future : futures)
1938 >                    assertTrue(future.isDone());
1939 >                assertTrue(futures.get(1).isCancelled());
1940 >                try {
1941 >                    assertEquals("0", futures.get(0).get());
1942 >                    assertEquals("2", futures.get(2).get());
1943 >                    break;
1944 >                } catch (CancellationException retryWithLongerTimeout) {
1945 >                    timeout *= 2;
1946 >                    if (timeout >= LONG_DELAY_MS / 2)
1947 >                        fail("expected exactly one task to be cancelled");
1948 >                }
1949 >            }
1950          } finally {
1951              joinPool(e);
1952          }
# Line 1930 | Line 1992 | public class ThreadPoolExecutorTest exte
1992       * allowCoreThreadTimeOut(true) causes idle threads to time out
1993       */
1994      public void testAllowCoreThreadTimeOut_true() throws Exception {
1995 <        long coreThreadTimeOut = SHORT_DELAY_MS;
1995 >        long keepAliveTime = timeoutMillis();
1996          final ThreadPoolExecutor p =
1997              new ThreadPoolExecutor(2, 10,
1998 <                                   coreThreadTimeOut, MILLISECONDS,
1998 >                                   keepAliveTime, MILLISECONDS,
1999                                     new ArrayBlockingQueue<Runnable>(10));
2000          final CountDownLatch threadStarted = new CountDownLatch(1);
2001          try {
# Line 1944 | Line 2006 | public class ThreadPoolExecutorTest exte
2006                      assertEquals(1, p.getPoolSize());
2007                  }});
2008              await(threadStarted);
2009 <            delay(coreThreadTimeOut);
2009 >            delay(keepAliveTime);
2010              long startTime = System.nanoTime();
2011              while (p.getPoolSize() > 0
2012                     && millisElapsedSince(startTime) < LONG_DELAY_MS)
# Line 1960 | Line 2022 | public class ThreadPoolExecutorTest exte
2022       * allowCoreThreadTimeOut(false) causes idle threads not to time out
2023       */
2024      public void testAllowCoreThreadTimeOut_false() throws Exception {
2025 <        long coreThreadTimeOut = SHORT_DELAY_MS;
2025 >        long keepAliveTime = timeoutMillis();
2026          final ThreadPoolExecutor p =
2027              new ThreadPoolExecutor(2, 10,
2028 <                                   coreThreadTimeOut, MILLISECONDS,
2028 >                                   keepAliveTime, MILLISECONDS,
2029                                     new ArrayBlockingQueue<Runnable>(10));
2030          final CountDownLatch threadStarted = new CountDownLatch(1);
2031          try {
# Line 1973 | Line 2035 | public class ThreadPoolExecutorTest exte
2035                      threadStarted.countDown();
2036                      assertTrue(p.getPoolSize() >= 1);
2037                  }});
2038 <            delay(2 * coreThreadTimeOut);
2038 >            delay(2 * keepAliveTime);
2039              assertTrue(p.getPoolSize() >= 1);
2040          } finally {
2041              joinPool(p);
# Line 1992 | Line 2054 | public class ThreadPoolExecutorTest exte
2054                  done.countDown();
2055              }};
2056          final ThreadPoolExecutor p =
2057 <            new ThreadPoolExecutor(1, 30, 60, TimeUnit.SECONDS,
2057 >            new ThreadPoolExecutor(1, 30,
2058 >                                   60, SECONDS,
2059                                     new ArrayBlockingQueue(30));
2060          try {
2061              for (int i = 0; i < nTasks; ++i) {
# Line 2011 | Line 2074 | public class ThreadPoolExecutorTest exte
2074          }
2075      }
2076  
2077 +    /**
2078 +     * get(cancelled task) throws CancellationException
2079 +     */
2080 +    public void testGet_cancelled() throws Exception {
2081 +        final ExecutorService e =
2082 +            new ThreadPoolExecutor(1, 1,
2083 +                                   LONG_DELAY_MS, MILLISECONDS,
2084 +                                   new LinkedBlockingQueue<Runnable>());
2085 +        try {
2086 +            final CountDownLatch blockerStarted = new CountDownLatch(1);
2087 +            final CountDownLatch done = new CountDownLatch(1);
2088 +            final List<Future<?>> futures = new ArrayList<>();
2089 +            for (int i = 0; i < 2; i++) {
2090 +                Runnable r = new CheckedRunnable() { public void realRun()
2091 +                                                         throws Throwable {
2092 +                    blockerStarted.countDown();
2093 +                    assertTrue(done.await(2 * LONG_DELAY_MS, MILLISECONDS));
2094 +                }};
2095 +                futures.add(e.submit(r));
2096 +            }
2097 +            assertTrue(blockerStarted.await(LONG_DELAY_MS, MILLISECONDS));
2098 +            for (Future<?> future : futures) future.cancel(false);
2099 +            for (Future<?> future : futures) {
2100 +                try {
2101 +                    future.get();
2102 +                    shouldThrow();
2103 +                } catch (CancellationException success) {}
2104 +                try {
2105 +                    future.get(LONG_DELAY_MS, MILLISECONDS);
2106 +                    shouldThrow();
2107 +                } catch (CancellationException success) {}
2108 +                assertTrue(future.isCancelled());
2109 +                assertTrue(future.isDone());
2110 +            }
2111 +            done.countDown();
2112 +        } finally {
2113 +            joinPool(e);
2114 +        }
2115 +    }
2116 +
2117   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines