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.45 by jsr166, Sun May 29 07:01:17 2011 UTC vs.
Revision 1.88 by jsr166, Sun Oct 4 02:46:13 2015 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 – import java.util.concurrent.*;
9   import static java.util.concurrent.TimeUnit.MILLISECONDS;
10 < import java.util.concurrent.atomic.*;
11 < import junit.framework.*;
12 < import java.util.*;
10 > import static java.util.concurrent.TimeUnit.NANOSECONDS;
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 >    /**
437 >     * awaitTermination on a non-shutdown pool times out
438 >     */
439 >    public void testAwaitTermination_timesOut() throws InterruptedException {
440 >        final ThreadPoolExecutor p =
441 >            new ThreadPoolExecutor(1, 1,
442 >                                   LONG_DELAY_MS, MILLISECONDS,
443 >                                   new ArrayBlockingQueue<Runnable>(10));
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 409 | 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();
425 –        } 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          }
428 –        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
429 –        assertTrue(p.isTerminated());
494      }
495  
496      /**
# Line 437 | Line 501 | public class ThreadPoolExecutorTest exte
501              new ThreadPoolExecutor(1, 1,
502                                     LONG_DELAY_MS, MILLISECONDS,
503                                     new ArrayBlockingQueue<Runnable>(10));
504 <        final CountDownLatch threadStarted = new CountDownLatch(1);
505 <        final CountDownLatch done = new CountDownLatch(1);
506 <        try {
504 >        try (PoolCleaner cleaner = cleaner(p)) {
505 >            final CountDownLatch threadStarted = new CountDownLatch(1);
506 >            final CountDownLatch done = new CountDownLatch(1);
507              assertFalse(p.isTerminating());
508              p.execute(new CheckedRunnable() {
509                  public void realRun() throws InterruptedException {
# Line 447 | 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();
453 –        } finally {
517              try { p.shutdown(); } catch (SecurityException ok) { return; }
518 +            assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
519 +            assertTrue(p.isTerminated());
520 +            assertFalse(p.isTerminating());
521          }
456 –        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
457 –        assertTrue(p.isTerminated());
458 –        assertFalse(p.isTerminating());
522      }
523  
524      /**
# Line 467 | Line 530 | public class ThreadPoolExecutorTest exte
530              new ThreadPoolExecutor(1, 1,
531                                     LONG_DELAY_MS, MILLISECONDS,
532                                     q);
533 <        final CountDownLatch threadStarted = new CountDownLatch(1);
534 <        final CountDownLatch done = new CountDownLatch(1);
535 <        try {
533 >        try (PoolCleaner cleaner = cleaner(p)) {
534 >            final CountDownLatch threadStarted = new CountDownLatch(1);
535 >            final CountDownLatch done = new CountDownLatch(1);
536              FutureTask[] tasks = new FutureTask[5];
537              for (int i = 0; i < tasks.length; i++) {
538                  Callable task = new CheckedCallable<Boolean>() {
# Line 482 | Line 545 | public class ThreadPoolExecutorTest exte
545                  tasks[i] = new FutureTask(task);
546                  p.execute(tasks[i]);
547              }
548 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
548 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
549              assertSame(q, p.getQueue());
550              assertFalse(q.contains(tasks[0]));
551              assertTrue(q.contains(tasks[tasks.length - 1]));
552              assertEquals(tasks.length - 1, q.size());
490 –        } finally {
553              done.countDown();
492 –            joinPool(p);
554          }
555      }
556  
# Line 502 | Line 563 | public class ThreadPoolExecutorTest exte
563              new ThreadPoolExecutor(1, 1,
564                                     LONG_DELAY_MS, MILLISECONDS,
565                                     q);
566 <        Runnable[] tasks = new Runnable[5];
567 <        final CountDownLatch threadStarted = new CountDownLatch(1);
568 <        final CountDownLatch done = new CountDownLatch(1);
569 <        try {
566 >        try (PoolCleaner cleaner = cleaner(p)) {
567 >            Runnable[] tasks = new Runnable[6];
568 >            final CountDownLatch threadStarted = new CountDownLatch(1);
569 >            final CountDownLatch done = new CountDownLatch(1);
570              for (int i = 0; i < tasks.length; i++) {
571                  tasks[i] = new CheckedRunnable() {
572                      public void realRun() throws InterruptedException {
# Line 514 | Line 575 | public class ThreadPoolExecutorTest exte
575                      }};
576                  p.execute(tasks[i]);
577              }
578 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
578 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
579              assertFalse(p.remove(tasks[0]));
580              assertTrue(q.contains(tasks[4]));
581              assertTrue(q.contains(tasks[3]));
# Line 524 | Line 585 | public class ThreadPoolExecutorTest exte
585              assertTrue(q.contains(tasks[3]));
586              assertTrue(p.remove(tasks[3]));
587              assertFalse(q.contains(tasks[3]));
527 –        } finally {
588              done.countDown();
529 –            joinPool(p);
589          }
590      }
591  
# Line 541 | Line 600 | public class ThreadPoolExecutorTest exte
600              new ThreadPoolExecutor(1, 1,
601                                     LONG_DELAY_MS, MILLISECONDS,
602                                     q);
603 <        FutureTask[] tasks = new FutureTask[5];
604 <        try {
603 >        try (PoolCleaner cleaner = cleaner(p)) {
604 >            FutureTask[] tasks = new FutureTask[5];
605              for (int i = 0; i < tasks.length; i++) {
606                  Callable task = new CheckedCallable<Boolean>() {
607                      public Boolean realCall() throws InterruptedException {
# Line 553 | Line 612 | public class ThreadPoolExecutorTest exte
612                  tasks[i] = new FutureTask(task);
613                  p.execute(tasks[i]);
614              }
615 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
615 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
616              assertEquals(tasks.length, p.getTaskCount());
617              assertEquals(tasks.length - 1, q.size());
618              assertEquals(1L, p.getActiveCount());
# Line 566 | Line 625 | public class ThreadPoolExecutorTest exte
625              p.purge();         // Nothing to do
626              assertEquals(tasks.length - 3, q.size());
627              assertEquals(tasks.length - 2, p.getTaskCount());
569 –        } finally {
628              done.countDown();
571 –            joinPool(p);
629          }
630      }
631  
632      /**
633 <     * shutdownNow returns a list containing tasks that were not run
633 >     * shutdownNow returns a list containing tasks that were not run,
634 >     * and those tasks are drained from the queue
635       */
636 <    public void testShutdownNow() {
636 >    public void testShutdownNow() throws InterruptedException {
637 >        final int poolSize = 2;
638 >        final int count = 5;
639 >        final AtomicInteger ran = new AtomicInteger(0);
640          final ThreadPoolExecutor p =
641 <            new ThreadPoolExecutor(1, 1,
641 >            new ThreadPoolExecutor(poolSize, poolSize,
642                                     LONG_DELAY_MS, MILLISECONDS,
643                                     new ArrayBlockingQueue<Runnable>(10));
644 <        List l;
645 <        try {
646 <            for (int i = 0; i < 5; i++)
586 <                p.execute(new MediumPossiblyInterruptedRunnable());
587 <        }
588 <        finally {
644 >        CountDownLatch threadsStarted = new CountDownLatch(poolSize);
645 >        Runnable waiter = new CheckedRunnable() { public void realRun() {
646 >            threadsStarted.countDown();
647              try {
648 <                l = p.shutdownNow();
649 <            } catch (SecurityException ok) { return; }
648 >                MILLISECONDS.sleep(2 * LONG_DELAY_MS);
649 >            } catch (InterruptedException success) {}
650 >            ran.getAndIncrement();
651 >        }};
652 >        for (int i = 0; i < count; i++)
653 >            p.execute(waiter);
654 >        assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
655 >        assertEquals(poolSize, p.getActiveCount());
656 >        assertEquals(0, p.getCompletedTaskCount());
657 >        final List<Runnable> queuedTasks;
658 >        try {
659 >            queuedTasks = p.shutdownNow();
660 >        } catch (SecurityException ok) {
661 >            return; // Allowed in case test doesn't have privs
662          }
663          assertTrue(p.isShutdown());
664 <        assertTrue(l.size() <= 4);
664 >        assertTrue(p.getQueue().isEmpty());
665 >        assertEquals(count - poolSize, queuedTasks.size());
666 >        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
667 >        assertTrue(p.isTerminated());
668 >        assertEquals(poolSize, ran.get());
669 >        assertEquals(poolSize, p.getCompletedTaskCount());
670      }
671  
672      // Exception Tests
# Line 601 | Line 676 | public class ThreadPoolExecutorTest exte
676       */
677      public void testConstructor1() {
678          try {
679 <            new ThreadPoolExecutor(-1, 1,
605 <                                   LONG_DELAY_MS, MILLISECONDS,
679 >            new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
680                                     new ArrayBlockingQueue<Runnable>(10));
681              shouldThrow();
682          } catch (IllegalArgumentException success) {}
# Line 613 | Line 687 | public class ThreadPoolExecutorTest exte
687       */
688      public void testConstructor2() {
689          try {
690 <            new ThreadPoolExecutor(1, -1,
617 <                                   LONG_DELAY_MS, MILLISECONDS,
690 >            new ThreadPoolExecutor(1, -1, 1L, SECONDS,
691                                     new ArrayBlockingQueue<Runnable>(10));
692              shouldThrow();
693          } catch (IllegalArgumentException success) {}
# Line 625 | Line 698 | public class ThreadPoolExecutorTest exte
698       */
699      public void testConstructor3() {
700          try {
701 <            new ThreadPoolExecutor(1, 0,
629 <                                   LONG_DELAY_MS, MILLISECONDS,
701 >            new ThreadPoolExecutor(1, 0, 1L, SECONDS,
702                                     new ArrayBlockingQueue<Runnable>(10));
703              shouldThrow();
704          } catch (IllegalArgumentException success) {}
# Line 637 | Line 709 | public class ThreadPoolExecutorTest exte
709       */
710      public void testConstructor4() {
711          try {
712 <            new ThreadPoolExecutor(1, 2,
641 <                                   -1L, MILLISECONDS,
712 >            new ThreadPoolExecutor(1, 2, -1L, SECONDS,
713                                     new ArrayBlockingQueue<Runnable>(10));
714              shouldThrow();
715          } catch (IllegalArgumentException success) {}
# Line 649 | Line 720 | public class ThreadPoolExecutorTest exte
720       */
721      public void testConstructor5() {
722          try {
723 <            new ThreadPoolExecutor(2, 1,
653 <                                   LONG_DELAY_MS, MILLISECONDS,
723 >            new ThreadPoolExecutor(2, 1, 1L, SECONDS,
724                                     new ArrayBlockingQueue<Runnable>(10));
725              shouldThrow();
726          } catch (IllegalArgumentException success) {}
# Line 661 | Line 731 | public class ThreadPoolExecutorTest exte
731       */
732      public void testConstructorNullPointerException() {
733          try {
734 <            new ThreadPoolExecutor(1, 2,
665 <                                   LONG_DELAY_MS, MILLISECONDS,
734 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
735                                     (BlockingQueue) null);
736              shouldThrow();
737          } catch (NullPointerException success) {}
# Line 673 | Line 742 | public class ThreadPoolExecutorTest exte
742       */
743      public void testConstructor6() {
744          try {
745 <            new ThreadPoolExecutor(-1, 1,
677 <                                   LONG_DELAY_MS, MILLISECONDS,
745 >            new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
746                                     new ArrayBlockingQueue<Runnable>(10),
747                                     new SimpleThreadFactory());
748              shouldThrow();
# Line 686 | Line 754 | public class ThreadPoolExecutorTest exte
754       */
755      public void testConstructor7() {
756          try {
757 <            new ThreadPoolExecutor(1, -1,
690 <                                   LONG_DELAY_MS, MILLISECONDS,
757 >            new ThreadPoolExecutor(1, -1, 1L, SECONDS,
758                                     new ArrayBlockingQueue<Runnable>(10),
759                                     new SimpleThreadFactory());
760              shouldThrow();
# Line 699 | Line 766 | public class ThreadPoolExecutorTest exte
766       */
767      public void testConstructor8() {
768          try {
769 <            new ThreadPoolExecutor(1, 0,
703 <                                   LONG_DELAY_MS, MILLISECONDS,
769 >            new ThreadPoolExecutor(1, 0, 1L, SECONDS,
770                                     new ArrayBlockingQueue<Runnable>(10),
771                                     new SimpleThreadFactory());
772              shouldThrow();
# Line 712 | Line 778 | public class ThreadPoolExecutorTest exte
778       */
779      public void testConstructor9() {
780          try {
781 <            new ThreadPoolExecutor(1, 2,
716 <                                   -1L, MILLISECONDS,
781 >            new ThreadPoolExecutor(1, 2, -1L, SECONDS,
782                                     new ArrayBlockingQueue<Runnable>(10),
783                                     new SimpleThreadFactory());
784              shouldThrow();
# Line 725 | Line 790 | public class ThreadPoolExecutorTest exte
790       */
791      public void testConstructor10() {
792          try {
793 <            new ThreadPoolExecutor(2, 1,
729 <                                   LONG_DELAY_MS, MILLISECONDS,
793 >            new ThreadPoolExecutor(2, 1, 1L, SECONDS,
794                                     new ArrayBlockingQueue<Runnable>(10),
795                                     new SimpleThreadFactory());
796              shouldThrow();
# Line 738 | Line 802 | public class ThreadPoolExecutorTest exte
802       */
803      public void testConstructorNullPointerException2() {
804          try {
805 <            new ThreadPoolExecutor(1, 2,
742 <                                   LONG_DELAY_MS, MILLISECONDS,
805 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
806                                     (BlockingQueue) null,
807                                     new SimpleThreadFactory());
808              shouldThrow();
# Line 751 | Line 814 | public class ThreadPoolExecutorTest exte
814       */
815      public void testConstructorNullPointerException3() {
816          try {
817 <            new ThreadPoolExecutor(1, 2,
755 <                                   LONG_DELAY_MS, MILLISECONDS,
817 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
818                                     new ArrayBlockingQueue<Runnable>(10),
819                                     (ThreadFactory) null);
820              shouldThrow();
# Line 764 | Line 826 | public class ThreadPoolExecutorTest exte
826       */
827      public void testConstructor11() {
828          try {
829 <            new ThreadPoolExecutor(-1, 1,
768 <                                   LONG_DELAY_MS, MILLISECONDS,
829 >            new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
830                                     new ArrayBlockingQueue<Runnable>(10),
831                                     new NoOpREHandler());
832              shouldThrow();
# Line 777 | Line 838 | public class ThreadPoolExecutorTest exte
838       */
839      public void testConstructor12() {
840          try {
841 <            new ThreadPoolExecutor(1, -1,
781 <                                   LONG_DELAY_MS, MILLISECONDS,
841 >            new ThreadPoolExecutor(1, -1, 1L, SECONDS,
842                                     new ArrayBlockingQueue<Runnable>(10),
843                                     new NoOpREHandler());
844              shouldThrow();
# Line 790 | Line 850 | public class ThreadPoolExecutorTest exte
850       */
851      public void testConstructor13() {
852          try {
853 <            new ThreadPoolExecutor(1, 0,
794 <                                   LONG_DELAY_MS, MILLISECONDS,
853 >            new ThreadPoolExecutor(1, 0, 1L, SECONDS,
854                                     new ArrayBlockingQueue<Runnable>(10),
855                                     new NoOpREHandler());
856              shouldThrow();
# Line 803 | Line 862 | public class ThreadPoolExecutorTest exte
862       */
863      public void testConstructor14() {
864          try {
865 <            new ThreadPoolExecutor(1, 2,
807 <                                   -1L, MILLISECONDS,
865 >            new ThreadPoolExecutor(1, 2, -1L, SECONDS,
866                                     new ArrayBlockingQueue<Runnable>(10),
867                                     new NoOpREHandler());
868              shouldThrow();
# Line 816 | Line 874 | public class ThreadPoolExecutorTest exte
874       */
875      public void testConstructor15() {
876          try {
877 <            new ThreadPoolExecutor(2, 1,
820 <                                   LONG_DELAY_MS, MILLISECONDS,
877 >            new ThreadPoolExecutor(2, 1, 1L, SECONDS,
878                                     new ArrayBlockingQueue<Runnable>(10),
879                                     new NoOpREHandler());
880              shouldThrow();
# Line 829 | Line 886 | public class ThreadPoolExecutorTest exte
886       */
887      public void testConstructorNullPointerException4() {
888          try {
889 <            new ThreadPoolExecutor(1, 2,
833 <                                   LONG_DELAY_MS, MILLISECONDS,
889 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
890                                     (BlockingQueue) null,
891                                     new NoOpREHandler());
892              shouldThrow();
# Line 842 | Line 898 | public class ThreadPoolExecutorTest exte
898       */
899      public void testConstructorNullPointerException5() {
900          try {
901 <            new ThreadPoolExecutor(1, 2,
846 <                                   LONG_DELAY_MS, MILLISECONDS,
901 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
902                                     new ArrayBlockingQueue<Runnable>(10),
903                                     (RejectedExecutionHandler) null);
904              shouldThrow();
# Line 855 | Line 910 | public class ThreadPoolExecutorTest exte
910       */
911      public void testConstructor16() {
912          try {
913 <            new ThreadPoolExecutor(-1, 1,
859 <                                   LONG_DELAY_MS, MILLISECONDS,
913 >            new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
914                                     new ArrayBlockingQueue<Runnable>(10),
915                                     new SimpleThreadFactory(),
916                                     new NoOpREHandler());
# Line 869 | Line 923 | public class ThreadPoolExecutorTest exte
923       */
924      public void testConstructor17() {
925          try {
926 <            new ThreadPoolExecutor(1, -1,
873 <                                   LONG_DELAY_MS, MILLISECONDS,
926 >            new ThreadPoolExecutor(1, -1, 1L, SECONDS,
927                                     new ArrayBlockingQueue<Runnable>(10),
928                                     new SimpleThreadFactory(),
929                                     new NoOpREHandler());
# Line 883 | Line 936 | public class ThreadPoolExecutorTest exte
936       */
937      public void testConstructor18() {
938          try {
939 <            new ThreadPoolExecutor(1, 0,
887 <                                   LONG_DELAY_MS, MILLISECONDS,
939 >            new ThreadPoolExecutor(1, 0, 1L, SECONDS,
940                                     new ArrayBlockingQueue<Runnable>(10),
941                                     new SimpleThreadFactory(),
942                                     new NoOpREHandler());
# Line 897 | Line 949 | public class ThreadPoolExecutorTest exte
949       */
950      public void testConstructor19() {
951          try {
952 <            new ThreadPoolExecutor(1, 2,
901 <                                   -1L, MILLISECONDS,
952 >            new ThreadPoolExecutor(1, 2, -1L, SECONDS,
953                                     new ArrayBlockingQueue<Runnable>(10),
954                                     new SimpleThreadFactory(),
955                                     new NoOpREHandler());
# Line 911 | Line 962 | public class ThreadPoolExecutorTest exte
962       */
963      public void testConstructor20() {
964          try {
965 <            new ThreadPoolExecutor(2, 1,
915 <                                   LONG_DELAY_MS, MILLISECONDS,
965 >            new ThreadPoolExecutor(2, 1, 1L, SECONDS,
966                                     new ArrayBlockingQueue<Runnable>(10),
967                                     new SimpleThreadFactory(),
968                                     new NoOpREHandler());
# Line 925 | Line 975 | public class ThreadPoolExecutorTest exte
975       */
976      public void testConstructorNullPointerException6() {
977          try {
978 <            new ThreadPoolExecutor(1, 2,
929 <                                   LONG_DELAY_MS, MILLISECONDS,
978 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
979                                     (BlockingQueue) null,
980                                     new SimpleThreadFactory(),
981                                     new NoOpREHandler());
# Line 939 | Line 988 | public class ThreadPoolExecutorTest exte
988       */
989      public void testConstructorNullPointerException7() {
990          try {
991 <            new ThreadPoolExecutor(1, 2,
943 <                                   LONG_DELAY_MS, MILLISECONDS,
991 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
992                                     new ArrayBlockingQueue<Runnable>(10),
993                                     new SimpleThreadFactory(),
994                                     (RejectedExecutionHandler) null);
# Line 953 | Line 1001 | public class ThreadPoolExecutorTest exte
1001       */
1002      public void testConstructorNullPointerException8() {
1003          try {
1004 <            new ThreadPoolExecutor(1, 2,
957 <                                   LONG_DELAY_MS, MILLISECONDS,
1004 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
1005                                     new ArrayBlockingQueue<Runnable>(10),
1006                                     (ThreadFactory) null,
1007                                     new NoOpREHandler());
# Line 968 | Line 1015 | public class ThreadPoolExecutorTest exte
1015      public void testInterruptedSubmit() throws InterruptedException {
1016          final ThreadPoolExecutor p =
1017              new ThreadPoolExecutor(1, 1,
1018 <                                   60, TimeUnit.SECONDS,
1018 >                                   60, SECONDS,
1019                                     new ArrayBlockingQueue<Runnable>(10));
1020  
1021 <        final CountDownLatch threadStarted = new CountDownLatch(1);
1022 <        final CountDownLatch done = new CountDownLatch(1);
1023 <        try {
1021 >        try (PoolCleaner cleaner = cleaner(p)) {
1022 >            final CountDownLatch threadStarted = new CountDownLatch(1);
1023 >            final CountDownLatch done = new CountDownLatch(1);
1024              Thread t = newStartedThread(new CheckedInterruptedRunnable() {
1025                  public void realRun() throws Exception {
1026                      Callable task = new CheckedCallable<Boolean>() {
# Line 985 | Line 1032 | public class ThreadPoolExecutorTest exte
1032                      p.submit(task).get();
1033                  }});
1034  
1035 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
1035 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
1036              t.interrupt();
1037              awaitTermination(t, MEDIUM_DELAY_MS);
991 –        } finally {
1038              done.countDown();
993 –            joinPool(p);
1039          }
1040      }
1041  
# Line 1242 | Line 1287 | public class ThreadPoolExecutorTest exte
1287       */
1288      public void testExecuteNull() {
1289          ThreadPoolExecutor p =
1290 <            new ThreadPoolExecutor(1, 2,
1246 <                                   LONG_DELAY_MS, MILLISECONDS,
1290 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
1291                                     new ArrayBlockingQueue<Runnable>(10));
1292          try {
1293              p.execute(null);
# Line 1310 | Line 1354 | public class ThreadPoolExecutorTest exte
1354      }
1355  
1356      /**
1357 +     * Configuration changes that allow core pool size greater than
1358 +     * max pool size result in IllegalArgumentException.
1359 +     */
1360 +    public void testPoolSizeInvariants() {
1361 +        ThreadPoolExecutor p =
1362 +            new ThreadPoolExecutor(1, 1,
1363 +                                   LONG_DELAY_MS, MILLISECONDS,
1364 +                                   new ArrayBlockingQueue<Runnable>(10));
1365 +        for (int s = 1; s < 5; s++) {
1366 +            p.setMaximumPoolSize(s);
1367 +            p.setCorePoolSize(s);
1368 +            try {
1369 +                p.setMaximumPoolSize(s - 1);
1370 +                shouldThrow();
1371 +            } catch (IllegalArgumentException success) {}
1372 +            assertEquals(s, p.getCorePoolSize());
1373 +            assertEquals(s, p.getMaximumPoolSize());
1374 +            try {
1375 +                p.setCorePoolSize(s + 1);
1376 +                shouldThrow();
1377 +            } catch (IllegalArgumentException success) {}
1378 +            assertEquals(s, p.getCorePoolSize());
1379 +            assertEquals(s, p.getMaximumPoolSize());
1380 +        }
1381 +        joinPool(p);
1382 +    }
1383 +
1384 +    /**
1385       * setKeepAliveTime throws IllegalArgumentException
1386       * when given a negative value
1387       */
# Line 1345 | Line 1417 | public class ThreadPoolExecutorTest exte
1417          ExtendedTPE p = new ExtendedTPE();
1418          try {
1419              final CountDownLatch done = new CountDownLatch(1);
1420 <            final CheckedRunnable task = new CheckedRunnable() {
1420 >            p.execute(new CheckedRunnable() {
1421                  public void realRun() {
1422                      done.countDown();
1423 <                }};
1352 <            p.execute(task);
1423 >                }});
1424              await(p.afterCalled);
1425              assertEquals(0, done.getCount());
1426              assertTrue(p.afterCalled());
# Line 1826 | Line 1897 | public class ThreadPoolExecutorTest exte
1897              l.add(new StringTask());
1898              l.add(new StringTask());
1899              List<Future<String>> futures =
1900 <                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1900 >                e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
1901              assertEquals(2, futures.size());
1902              for (Future<String> future : futures)
1903                  assertSame(TEST_STRING, future.get());
# Line 1844 | Line 1915 | public class ThreadPoolExecutorTest exte
1915                                     LONG_DELAY_MS, MILLISECONDS,
1916                                     new ArrayBlockingQueue<Runnable>(10));
1917          try {
1918 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1919 <            l.add(new StringTask());
1920 <            l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
1921 <            l.add(new StringTask());
1922 <            List<Future<String>> futures =
1923 <                e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
1924 <            assertEquals(l.size(), futures.size());
1925 <            for (Future future : futures)
1926 <                assertTrue(future.isDone());
1927 <            assertFalse(futures.get(0).isCancelled());
1928 <            assertTrue(futures.get(1).isCancelled());
1918 >            for (long timeout = timeoutMillis();;) {
1919 >                List<Callable<String>> tasks = new ArrayList<>();
1920 >                tasks.add(new StringTask("0"));
1921 >                tasks.add(Executors.callable(new LongPossiblyInterruptedRunnable(), TEST_STRING));
1922 >                tasks.add(new StringTask("2"));
1923 >                long startTime = System.nanoTime();
1924 >                List<Future<String>> futures =
1925 >                    e.invokeAll(tasks, timeout, MILLISECONDS);
1926 >                assertEquals(tasks.size(), futures.size());
1927 >                assertTrue(millisElapsedSince(startTime) >= timeout);
1928 >                for (Future future : futures)
1929 >                    assertTrue(future.isDone());
1930 >                assertTrue(futures.get(1).isCancelled());
1931 >                try {
1932 >                    assertEquals("0", futures.get(0).get());
1933 >                    assertEquals("2", futures.get(2).get());
1934 >                    break;
1935 >                } catch (CancellationException retryWithLongerTimeout) {
1936 >                    timeout *= 2;
1937 >                    if (timeout >= LONG_DELAY_MS / 2)
1938 >                        fail("expected exactly one task to be cancelled");
1939 >                }
1940 >            }
1941          } finally {
1942              joinPool(e);
1943          }
# Line 1900 | Line 1983 | public class ThreadPoolExecutorTest exte
1983       * allowCoreThreadTimeOut(true) causes idle threads to time out
1984       */
1985      public void testAllowCoreThreadTimeOut_true() throws Exception {
1986 <        long coreThreadTimeOut = SHORT_DELAY_MS;
1986 >        long keepAliveTime = timeoutMillis();
1987          final ThreadPoolExecutor p =
1988              new ThreadPoolExecutor(2, 10,
1989 <                                   coreThreadTimeOut, MILLISECONDS,
1989 >                                   keepAliveTime, MILLISECONDS,
1990                                     new ArrayBlockingQueue<Runnable>(10));
1991          final CountDownLatch threadStarted = new CountDownLatch(1);
1992          try {
# Line 1914 | Line 1997 | public class ThreadPoolExecutorTest exte
1997                      assertEquals(1, p.getPoolSize());
1998                  }});
1999              await(threadStarted);
2000 <            delay(coreThreadTimeOut);
2000 >            delay(keepAliveTime);
2001              long startTime = System.nanoTime();
2002              while (p.getPoolSize() > 0
2003                     && millisElapsedSince(startTime) < LONG_DELAY_MS)
# Line 1930 | Line 2013 | public class ThreadPoolExecutorTest exte
2013       * allowCoreThreadTimeOut(false) causes idle threads not to time out
2014       */
2015      public void testAllowCoreThreadTimeOut_false() throws Exception {
2016 <        long coreThreadTimeOut = SHORT_DELAY_MS;
2016 >        long keepAliveTime = timeoutMillis();
2017          final ThreadPoolExecutor p =
2018              new ThreadPoolExecutor(2, 10,
2019 <                                   coreThreadTimeOut, MILLISECONDS,
2019 >                                   keepAliveTime, MILLISECONDS,
2020                                     new ArrayBlockingQueue<Runnable>(10));
2021          final CountDownLatch threadStarted = new CountDownLatch(1);
2022          try {
# Line 1943 | Line 2026 | public class ThreadPoolExecutorTest exte
2026                      threadStarted.countDown();
2027                      assertTrue(p.getPoolSize() >= 1);
2028                  }});
2029 <            delay(2 * coreThreadTimeOut);
2029 >            delay(2 * keepAliveTime);
2030              assertTrue(p.getPoolSize() >= 1);
2031          } finally {
2032              joinPool(p);
# Line 1962 | Line 2045 | public class ThreadPoolExecutorTest exte
2045                  done.countDown();
2046              }};
2047          final ThreadPoolExecutor p =
2048 <            new ThreadPoolExecutor(1, 30, 60, TimeUnit.SECONDS,
2048 >            new ThreadPoolExecutor(1, 30,
2049 >                                   60, SECONDS,
2050                                     new ArrayBlockingQueue(30));
2051          try {
2052              for (int i = 0; i < nTasks; ++i) {
# Line 1977 | Line 2061 | public class ThreadPoolExecutorTest exte
2061              // enough time to run all tasks
2062              assertTrue(done.await(nTasks * SHORT_DELAY_MS, MILLISECONDS));
2063          } finally {
2064 <            p.shutdown();
2064 >            joinPool(p);
2065 >        }
2066 >    }
2067 >
2068 >    /**
2069 >     * get(cancelled task) throws CancellationException
2070 >     */
2071 >    public void testGet_cancelled() throws Exception {
2072 >        final ExecutorService e =
2073 >            new ThreadPoolExecutor(1, 1,
2074 >                                   LONG_DELAY_MS, MILLISECONDS,
2075 >                                   new LinkedBlockingQueue<Runnable>());
2076 >        try {
2077 >            final CountDownLatch blockerStarted = new CountDownLatch(1);
2078 >            final CountDownLatch done = new CountDownLatch(1);
2079 >            final List<Future<?>> futures = new ArrayList<>();
2080 >            for (int i = 0; i < 2; i++) {
2081 >                Runnable r = new CheckedRunnable() { public void realRun()
2082 >                                                         throws Throwable {
2083 >                    blockerStarted.countDown();
2084 >                    assertTrue(done.await(2 * LONG_DELAY_MS, MILLISECONDS));
2085 >                }};
2086 >                futures.add(e.submit(r));
2087 >            }
2088 >            assertTrue(blockerStarted.await(LONG_DELAY_MS, MILLISECONDS));
2089 >            for (Future<?> future : futures) future.cancel(false);
2090 >            for (Future<?> future : futures) {
2091 >                try {
2092 >                    future.get();
2093 >                    shouldThrow();
2094 >                } catch (CancellationException success) {}
2095 >                try {
2096 >                    future.get(LONG_DELAY_MS, MILLISECONDS);
2097 >                    shouldThrow();
2098 >                } catch (CancellationException success) {}
2099 >                assertTrue(future.isCancelled());
2100 >                assertTrue(future.isDone());
2101 >            }
2102 >            done.countDown();
2103 >        } finally {
2104 >            joinPool(e);
2105          }
2106      }
2107  

Diff Legend

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