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.37 by jsr166, Mon Oct 11 07:21:32 2010 UTC vs.
Revision 1.80 by jsr166, Sun Oct 4 02:21:43 2015 UTC

# Line 1 | Line 1
1   /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at
4 < * http://creativecommons.org/licenses/publicdomain
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5   * Other contributors include Andrew Wright, Jeffrey Hayes,
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);
43      }
44  
45      static class ExtendedTPE extends ThreadPoolExecutor {
46 <        volatile boolean beforeCalled = false;
47 <        volatile boolean afterCalled = false;
48 <        volatile boolean terminatedCalled = false;
46 >        final CountDownLatch beforeCalled = new CountDownLatch(1);
47 >        final CountDownLatch afterCalled = new CountDownLatch(1);
48 >        final CountDownLatch terminatedCalled = new CountDownLatch(1);
49 >
50          public ExtendedTPE() {
51              super(1, 1, LONG_DELAY_MS, MILLISECONDS, new SynchronousQueue<Runnable>());
52          }
53          protected void beforeExecute(Thread t, Runnable r) {
54 <            beforeCalled = true;
54 >            beforeCalled.countDown();
55          }
56          protected void afterExecute(Runnable r, Throwable t) {
57 <            afterCalled = true;
57 >            afterCalled.countDown();
58          }
59          protected void terminated() {
60 <            terminatedCalled = true;
60 >            terminatedCalled.countDown();
61 >        }
62 >
63 >        public boolean beforeCalled() {
64 >            return beforeCalled.getCount() == 0;
65 >        }
66 >        public boolean afterCalled() {
67 >            return afterCalled.getCount() == 0;
68 >        }
69 >        public boolean terminatedCalled() {
70 >            return terminatedCalled.getCount() == 0;
71          }
72      }
73  
# Line 46 | Line 79 | public class ThreadPoolExecutorTest exte
79          }
80      }
81  
49 –
82      /**
83       * execute successfully executes a runnable
84       */
# Line 55 | 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();
62 <            }};
63 <        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));
66 <        } finally {
67 <            joinPool(p);
95 >            assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
96          }
97      }
98  
# Line 77 | 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 87 | 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());
92 –        } finally {
120              done.countDown();
94 –            joinPool(p);
121          }
122      }
123  
# Line 100 | 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 118 | 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 138 | 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 150 | Line 190 | public class ThreadPoolExecutorTest exte
190                      threadProceed.await();
191                      threadDone.countDown();
192                  }});
193 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
193 >            await(threadStarted);
194              assertEquals(0, p.getCompletedTaskCount());
195              threadProceed.countDown();
196              threadDone.await();
197 <            Thread.sleep(SHORT_DELAY_MS);
198 <            assertEquals(1, p.getCompletedTaskCount());
199 <        } finally {
200 <            joinPool(p);
197 >            long startTime = System.nanoTime();
198 >            while (p.getCompletedTaskCount() != 1) {
199 >                if (millisElapsedSince(startTime) > LONG_DELAY_MS)
200 >                    fail("timed out");
201 >                Thread.yield();
202 >            }
203          }
204      }
205  
# Line 169 | 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 181 | 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  
188 –
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 209 | 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  
218 –
263      /**
264       * setThreadFactory(null) throws NPE
265       */
# Line 224 | 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 {
232 <            joinPool(p);
271 >        try (PoolCleaner cleaner = cleaner(p)) {
272 >            try {
273 >                p.setThreadFactory(null);
274 >                shouldThrow();
275 >            } catch (NullPointerException success) {}
276          }
277      }
278  
# Line 237 | 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 256 | 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  
265 –
310      /**
311       * setRejectedExecutionHandler(null) throws NPE
312       */
# Line 271 | 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 {
279 <            joinPool(p);
318 >        try (PoolCleaner cleaner = cleaner(p)) {
319 >            try {
320 >                p.setRejectedExecutionHandler(null);
321 >                shouldThrow();
322 >            } catch (NullPointerException success) {}
323          }
324      }
325  
283 –
326      /**
327       * getLargestPoolSize increases, but doesn't overestimate, when
328       * multiple threads active
# Line 291 | 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 302 | Line 344 | public class ThreadPoolExecutorTest exte
344                          done.await();
345                          assertEquals(THREADS, p.getLargestPoolSize());
346                      }});
347 <            assertTrue(threadsStarted.await(SMALL_DELAY_MS, MILLISECONDS));
306 <            assertEquals(THREADS, p.getLargestPoolSize());
307 <        } finally {
308 <            done.countDown();
309 <            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 320 | 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 333 | 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 343 | 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 {
349 <            done.countDown();
350 <            joinPool(p);
393 >            done.countDown();   // release pool
394          }
395      }
396  
# Line 369 | 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());
417          } finally {
418              done.countDown();
# Line 378 | Line 421 | public class ThreadPoolExecutorTest exte
421      }
422  
423      /**
424 <     * isShutDown is false before shutdown, true after
424 >     * isShutdown is false before shutdown, true after
425       */
426      public void testIsShutdown() {
427          final ThreadPoolExecutor p =
# Line 391 | Line 434 | public class ThreadPoolExecutorTest exte
434          joinPool(p);
435      }
436  
437 +    /**
438 +     * awaitTermination on a non-shutdown pool times out
439 +     */
440 +    public void testAwaitTermination_timesOut() throws InterruptedException {
441 +        final ThreadPoolExecutor p =
442 +            new ThreadPoolExecutor(1, 1,
443 +                                   LONG_DELAY_MS, MILLISECONDS,
444 +                                   new ArrayBlockingQueue<Runnable>(10));
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 +        p.shutdown();
463 +        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
464 +        assertTrue(p.isTerminated());
465 +    }
466  
467      /**
468       * isTerminated is false before termination, true after
# Line 406 | Line 478 | public class ThreadPoolExecutorTest exte
478          try {
479              p.execute(new CheckedRunnable() {
480                  public void realRun() throws InterruptedException {
409 –                    threadStarted.countDown();
481                      assertFalse(p.isTerminated());
482 +                    threadStarted.countDown();
483                      done.await();
484                  }});
485 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
485 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
486 >            assertFalse(p.isTerminating());
487              done.countDown();
488          } finally {
489              try { p.shutdown(); } catch (SecurityException ok) { return; }
# Line 433 | Line 506 | public class ThreadPoolExecutorTest exte
506              assertFalse(p.isTerminating());
507              p.execute(new CheckedRunnable() {
508                  public void realRun() throws InterruptedException {
436 –                    threadStarted.countDown();
509                      assertFalse(p.isTerminating());
510 +                    threadStarted.countDown();
511                      done.await();
512                  }});
513 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
513 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
514              assertFalse(p.isTerminating());
515              done.countDown();
516          } finally {
# Line 472 | 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]));
# Line 504 | Line 577 | public class ThreadPoolExecutorTest exte
577                      }};
578                  p.execute(tasks[i]);
579              }
580 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
580 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
581              assertFalse(p.remove(tasks[0]));
582              assertTrue(q.contains(tasks[4]));
583              assertTrue(q.contains(tasks[3]));
# Line 543 | Line 616 | public class ThreadPoolExecutorTest exte
616                  tasks[i] = new FutureTask(task);
617                  p.execute(tasks[i]);
618              }
619 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
619 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
620              assertEquals(tasks.length, p.getTaskCount());
621              assertEquals(tasks.length - 1, q.size());
622              assertEquals(1L, p.getActiveCount());
# Line 563 | Line 636 | public class ThreadPoolExecutorTest exte
636      }
637  
638      /**
639 <     * shutDownNow returns a list containing tasks that were not run
639 >     * shutdownNow returns a list containing tasks that were not run,
640 >     * and those tasks are drained from the queue
641       */
642 <    public void testShutDownNow() {
642 >    public void testShutdownNow() throws InterruptedException {
643 >        final int poolSize = 2;
644 >        final int count = 5;
645 >        final AtomicInteger ran = new AtomicInteger(0);
646          final ThreadPoolExecutor p =
647 <            new ThreadPoolExecutor(1, 1,
647 >            new ThreadPoolExecutor(poolSize, poolSize,
648                                     LONG_DELAY_MS, MILLISECONDS,
649                                     new ArrayBlockingQueue<Runnable>(10));
650 <        List l;
651 <        try {
652 <            for (int i = 0; i < 5; i++)
576 <                p.execute(new MediumPossiblyInterruptedRunnable());
577 <        }
578 <        finally {
650 >        CountDownLatch threadsStarted = new CountDownLatch(poolSize);
651 >        Runnable waiter = new CheckedRunnable() { public void realRun() {
652 >            threadsStarted.countDown();
653              try {
654 <                l = p.shutdownNow();
655 <            } catch (SecurityException ok) { return; }
654 >                MILLISECONDS.sleep(2 * LONG_DELAY_MS);
655 >            } catch (InterruptedException success) {}
656 >            ran.getAndIncrement();
657 >        }};
658 >        for (int i = 0; i < count; i++)
659 >            p.execute(waiter);
660 >        assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
661 >        assertEquals(poolSize, p.getActiveCount());
662 >        assertEquals(0, p.getCompletedTaskCount());
663 >        final List<Runnable> queuedTasks;
664 >        try {
665 >            queuedTasks = p.shutdownNow();
666 >        } catch (SecurityException ok) {
667 >            return; // Allowed in case test doesn't have privs
668          }
669          assertTrue(p.isShutdown());
670 <        assertTrue(l.size() <= 4);
670 >        assertTrue(p.getQueue().isEmpty());
671 >        assertEquals(count - poolSize, queuedTasks.size());
672 >        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
673 >        assertTrue(p.isTerminated());
674 >        assertEquals(poolSize, ran.get());
675 >        assertEquals(poolSize, p.getCompletedTaskCount());
676      }
677  
678      // Exception Tests
679  
589 –
680      /**
681       * Constructor throws if corePoolSize argument is less than zero
682       */
683      public void testConstructor1() {
684          try {
685 <            new ThreadPoolExecutor(-1, 1,
596 <                                   LONG_DELAY_MS, MILLISECONDS,
685 >            new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
686                                     new ArrayBlockingQueue<Runnable>(10));
687              shouldThrow();
688          } catch (IllegalArgumentException success) {}
# Line 604 | Line 693 | public class ThreadPoolExecutorTest exte
693       */
694      public void testConstructor2() {
695          try {
696 <            new ThreadPoolExecutor(1, -1,
608 <                                   LONG_DELAY_MS, MILLISECONDS,
696 >            new ThreadPoolExecutor(1, -1, 1L, SECONDS,
697                                     new ArrayBlockingQueue<Runnable>(10));
698              shouldThrow();
699          } catch (IllegalArgumentException success) {}
# Line 616 | Line 704 | public class ThreadPoolExecutorTest exte
704       */
705      public void testConstructor3() {
706          try {
707 <            new ThreadPoolExecutor(1, 0,
620 <                                   LONG_DELAY_MS, MILLISECONDS,
707 >            new ThreadPoolExecutor(1, 0, 1L, SECONDS,
708                                     new ArrayBlockingQueue<Runnable>(10));
709              shouldThrow();
710          } catch (IllegalArgumentException success) {}
# Line 628 | Line 715 | public class ThreadPoolExecutorTest exte
715       */
716      public void testConstructor4() {
717          try {
718 <            new ThreadPoolExecutor(1, 2,
632 <                                   -1L, MILLISECONDS,
718 >            new ThreadPoolExecutor(1, 2, -1L, SECONDS,
719                                     new ArrayBlockingQueue<Runnable>(10));
720              shouldThrow();
721          } catch (IllegalArgumentException success) {}
# Line 640 | Line 726 | public class ThreadPoolExecutorTest exte
726       */
727      public void testConstructor5() {
728          try {
729 <            new ThreadPoolExecutor(2, 1,
644 <                                   LONG_DELAY_MS, MILLISECONDS,
729 >            new ThreadPoolExecutor(2, 1, 1L, SECONDS,
730                                     new ArrayBlockingQueue<Runnable>(10));
731              shouldThrow();
732          } catch (IllegalArgumentException success) {}
# Line 652 | Line 737 | public class ThreadPoolExecutorTest exte
737       */
738      public void testConstructorNullPointerException() {
739          try {
740 <            new ThreadPoolExecutor(1, 2,
656 <                                   LONG_DELAY_MS, MILLISECONDS,
740 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
741                                     (BlockingQueue) null);
742              shouldThrow();
743          } catch (NullPointerException success) {}
744      }
745  
662 –
663 –
746      /**
747       * Constructor throws if corePoolSize argument is less than zero
748       */
749      public void testConstructor6() {
750          try {
751 <            new ThreadPoolExecutor(-1, 1,
670 <                                   LONG_DELAY_MS, MILLISECONDS,
751 >            new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
752                                     new ArrayBlockingQueue<Runnable>(10),
753                                     new SimpleThreadFactory());
754              shouldThrow();
# Line 679 | Line 760 | public class ThreadPoolExecutorTest exte
760       */
761      public void testConstructor7() {
762          try {
763 <            new ThreadPoolExecutor(1, -1,
683 <                                   LONG_DELAY_MS, MILLISECONDS,
763 >            new ThreadPoolExecutor(1, -1, 1L, SECONDS,
764                                     new ArrayBlockingQueue<Runnable>(10),
765                                     new SimpleThreadFactory());
766              shouldThrow();
# Line 692 | Line 772 | public class ThreadPoolExecutorTest exte
772       */
773      public void testConstructor8() {
774          try {
775 <            new ThreadPoolExecutor(1, 0,
696 <                                   LONG_DELAY_MS, MILLISECONDS,
775 >            new ThreadPoolExecutor(1, 0, 1L, SECONDS,
776                                     new ArrayBlockingQueue<Runnable>(10),
777                                     new SimpleThreadFactory());
778              shouldThrow();
# Line 705 | Line 784 | public class ThreadPoolExecutorTest exte
784       */
785      public void testConstructor9() {
786          try {
787 <            new ThreadPoolExecutor(1, 2,
709 <                                   -1L, MILLISECONDS,
787 >            new ThreadPoolExecutor(1, 2, -1L, SECONDS,
788                                     new ArrayBlockingQueue<Runnable>(10),
789                                     new SimpleThreadFactory());
790              shouldThrow();
# Line 718 | Line 796 | public class ThreadPoolExecutorTest exte
796       */
797      public void testConstructor10() {
798          try {
799 <            new ThreadPoolExecutor(2, 1,
722 <                                   LONG_DELAY_MS, MILLISECONDS,
799 >            new ThreadPoolExecutor(2, 1, 1L, SECONDS,
800                                     new ArrayBlockingQueue<Runnable>(10),
801                                     new SimpleThreadFactory());
802              shouldThrow();
# Line 731 | Line 808 | public class ThreadPoolExecutorTest exte
808       */
809      public void testConstructorNullPointerException2() {
810          try {
811 <            new ThreadPoolExecutor(1, 2,
735 <                                   LONG_DELAY_MS, MILLISECONDS,
811 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
812                                     (BlockingQueue) null,
813                                     new SimpleThreadFactory());
814              shouldThrow();
# Line 744 | Line 820 | public class ThreadPoolExecutorTest exte
820       */
821      public void testConstructorNullPointerException3() {
822          try {
823 <            new ThreadPoolExecutor(1, 2,
748 <                                   LONG_DELAY_MS, MILLISECONDS,
823 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
824                                     new ArrayBlockingQueue<Runnable>(10),
825                                     (ThreadFactory) null);
826              shouldThrow();
827          } catch (NullPointerException success) {}
828      }
829  
755 –
830      /**
831       * Constructor throws if corePoolSize argument is less than zero
832       */
833      public void testConstructor11() {
834          try {
835 <            new ThreadPoolExecutor(-1, 1,
762 <                                   LONG_DELAY_MS, MILLISECONDS,
835 >            new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
836                                     new ArrayBlockingQueue<Runnable>(10),
837                                     new NoOpREHandler());
838              shouldThrow();
# Line 771 | Line 844 | public class ThreadPoolExecutorTest exte
844       */
845      public void testConstructor12() {
846          try {
847 <            new ThreadPoolExecutor(1, -1,
775 <                                   LONG_DELAY_MS, MILLISECONDS,
847 >            new ThreadPoolExecutor(1, -1, 1L, SECONDS,
848                                     new ArrayBlockingQueue<Runnable>(10),
849                                     new NoOpREHandler());
850              shouldThrow();
# Line 784 | Line 856 | public class ThreadPoolExecutorTest exte
856       */
857      public void testConstructor13() {
858          try {
859 <            new ThreadPoolExecutor(1, 0,
788 <                                   LONG_DELAY_MS, MILLISECONDS,
859 >            new ThreadPoolExecutor(1, 0, 1L, SECONDS,
860                                     new ArrayBlockingQueue<Runnable>(10),
861                                     new NoOpREHandler());
862              shouldThrow();
# Line 797 | Line 868 | public class ThreadPoolExecutorTest exte
868       */
869      public void testConstructor14() {
870          try {
871 <            new ThreadPoolExecutor(1, 2,
801 <                                   -1L, MILLISECONDS,
871 >            new ThreadPoolExecutor(1, 2, -1L, SECONDS,
872                                     new ArrayBlockingQueue<Runnable>(10),
873                                     new NoOpREHandler());
874              shouldThrow();
# Line 810 | Line 880 | public class ThreadPoolExecutorTest exte
880       */
881      public void testConstructor15() {
882          try {
883 <            new ThreadPoolExecutor(2, 1,
814 <                                   LONG_DELAY_MS, MILLISECONDS,
883 >            new ThreadPoolExecutor(2, 1, 1L, SECONDS,
884                                     new ArrayBlockingQueue<Runnable>(10),
885                                     new NoOpREHandler());
886              shouldThrow();
# Line 823 | Line 892 | public class ThreadPoolExecutorTest exte
892       */
893      public void testConstructorNullPointerException4() {
894          try {
895 <            new ThreadPoolExecutor(1, 2,
827 <                                   LONG_DELAY_MS, MILLISECONDS,
895 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
896                                     (BlockingQueue) null,
897                                     new NoOpREHandler());
898              shouldThrow();
# Line 836 | Line 904 | public class ThreadPoolExecutorTest exte
904       */
905      public void testConstructorNullPointerException5() {
906          try {
907 <            new ThreadPoolExecutor(1, 2,
840 <                                   LONG_DELAY_MS, MILLISECONDS,
907 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
908                                     new ArrayBlockingQueue<Runnable>(10),
909                                     (RejectedExecutionHandler) null);
910              shouldThrow();
911          } catch (NullPointerException success) {}
912      }
913  
847 –
914      /**
915       * Constructor throws if corePoolSize argument is less than zero
916       */
917      public void testConstructor16() {
918          try {
919 <            new ThreadPoolExecutor(-1, 1,
854 <                                   LONG_DELAY_MS, MILLISECONDS,
919 >            new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
920                                     new ArrayBlockingQueue<Runnable>(10),
921                                     new SimpleThreadFactory(),
922                                     new NoOpREHandler());
# Line 864 | Line 929 | public class ThreadPoolExecutorTest exte
929       */
930      public void testConstructor17() {
931          try {
932 <            new ThreadPoolExecutor(1, -1,
868 <                                   LONG_DELAY_MS, MILLISECONDS,
932 >            new ThreadPoolExecutor(1, -1, 1L, SECONDS,
933                                     new ArrayBlockingQueue<Runnable>(10),
934                                     new SimpleThreadFactory(),
935                                     new NoOpREHandler());
# Line 878 | Line 942 | public class ThreadPoolExecutorTest exte
942       */
943      public void testConstructor18() {
944          try {
945 <            new ThreadPoolExecutor(1, 0,
882 <                                   LONG_DELAY_MS, MILLISECONDS,
945 >            new ThreadPoolExecutor(1, 0, 1L, SECONDS,
946                                     new ArrayBlockingQueue<Runnable>(10),
947                                     new SimpleThreadFactory(),
948                                     new NoOpREHandler());
# Line 892 | Line 955 | public class ThreadPoolExecutorTest exte
955       */
956      public void testConstructor19() {
957          try {
958 <            new ThreadPoolExecutor(1, 2,
896 <                                   -1L, MILLISECONDS,
958 >            new ThreadPoolExecutor(1, 2, -1L, SECONDS,
959                                     new ArrayBlockingQueue<Runnable>(10),
960                                     new SimpleThreadFactory(),
961                                     new NoOpREHandler());
# Line 906 | Line 968 | public class ThreadPoolExecutorTest exte
968       */
969      public void testConstructor20() {
970          try {
971 <            new ThreadPoolExecutor(2, 1,
910 <                                   LONG_DELAY_MS, MILLISECONDS,
971 >            new ThreadPoolExecutor(2, 1, 1L, SECONDS,
972                                     new ArrayBlockingQueue<Runnable>(10),
973                                     new SimpleThreadFactory(),
974                                     new NoOpREHandler());
# Line 920 | Line 981 | public class ThreadPoolExecutorTest exte
981       */
982      public void testConstructorNullPointerException6() {
983          try {
984 <            new ThreadPoolExecutor(1, 2,
924 <                                   LONG_DELAY_MS, MILLISECONDS,
984 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
985                                     (BlockingQueue) null,
986                                     new SimpleThreadFactory(),
987                                     new NoOpREHandler());
# Line 934 | Line 994 | public class ThreadPoolExecutorTest exte
994       */
995      public void testConstructorNullPointerException7() {
996          try {
997 <            new ThreadPoolExecutor(1, 2,
938 <                                   LONG_DELAY_MS, MILLISECONDS,
997 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
998                                     new ArrayBlockingQueue<Runnable>(10),
999                                     new SimpleThreadFactory(),
1000                                     (RejectedExecutionHandler) null);
# Line 948 | Line 1007 | public class ThreadPoolExecutorTest exte
1007       */
1008      public void testConstructorNullPointerException8() {
1009          try {
1010 <            new ThreadPoolExecutor(1, 2,
952 <                                   LONG_DELAY_MS, MILLISECONDS,
1010 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
1011                                     new ArrayBlockingQueue<Runnable>(10),
1012                                     (ThreadFactory) null,
1013                                     new NoOpREHandler());
# Line 963 | Line 1021 | public class ThreadPoolExecutorTest exte
1021      public void testInterruptedSubmit() throws InterruptedException {
1022          final ThreadPoolExecutor p =
1023              new ThreadPoolExecutor(1, 1,
1024 <                                   60, TimeUnit.SECONDS,
1024 >                                   60, SECONDS,
1025                                     new ArrayBlockingQueue<Runnable>(10));
1026  
1027          final CountDownLatch threadStarted = new CountDownLatch(1);
# Line 980 | Line 1038 | public class ThreadPoolExecutorTest exte
1038                      p.submit(task).get();
1039                  }});
1040  
1041 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
1041 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
1042              t.interrupt();
1043              awaitTermination(t, MEDIUM_DELAY_MS);
1044          } finally {
# Line 1211 | Line 1269 | public class ThreadPoolExecutorTest exte
1269          }
1270      }
1271  
1214 –
1272      /**
1273       * execute using DiscardOldestPolicy drops task on shutdown
1274       */
# Line 1233 | Line 1290 | public class ThreadPoolExecutorTest exte
1290          }
1291      }
1292  
1236 –
1293      /**
1294       * execute(null) throws NPE
1295       */
1296      public void testExecuteNull() {
1297          ThreadPoolExecutor p =
1298 <            new ThreadPoolExecutor(1, 2,
1243 <                                   LONG_DELAY_MS, MILLISECONDS,
1298 >            new ThreadPoolExecutor(1, 2, 1L, SECONDS,
1299                                     new ArrayBlockingQueue<Runnable>(10));
1300          try {
1301              p.execute(null);
# Line 1306 | Line 1361 | public class ThreadPoolExecutorTest exte
1361          joinPool(p);
1362      }
1363  
1364 +    /**
1365 +     * Configuration changes that allow core pool size greater than
1366 +     * max pool size result in IllegalArgumentException.
1367 +     */
1368 +    public void testPoolSizeInvariants() {
1369 +        ThreadPoolExecutor p =
1370 +            new ThreadPoolExecutor(1, 1,
1371 +                                   LONG_DELAY_MS, MILLISECONDS,
1372 +                                   new ArrayBlockingQueue<Runnable>(10));
1373 +        for (int s = 1; s < 5; s++) {
1374 +            p.setMaximumPoolSize(s);
1375 +            p.setCorePoolSize(s);
1376 +            try {
1377 +                p.setMaximumPoolSize(s - 1);
1378 +                shouldThrow();
1379 +            } catch (IllegalArgumentException success) {}
1380 +            assertEquals(s, p.getCorePoolSize());
1381 +            assertEquals(s, p.getMaximumPoolSize());
1382 +            try {
1383 +                p.setCorePoolSize(s + 1);
1384 +                shouldThrow();
1385 +            } catch (IllegalArgumentException success) {}
1386 +            assertEquals(s, p.getCorePoolSize());
1387 +            assertEquals(s, p.getMaximumPoolSize());
1388 +        }
1389 +        joinPool(p);
1390 +    }
1391  
1392      /**
1393       * setKeepAliveTime throws IllegalArgumentException
# Line 1332 | Line 1414 | public class ThreadPoolExecutorTest exte
1414      public void testTerminated() {
1415          ExtendedTPE p = new ExtendedTPE();
1416          try { p.shutdown(); } catch (SecurityException ok) { return; }
1417 <        assertTrue(p.terminatedCalled);
1417 >        assertTrue(p.terminatedCalled());
1418          joinPool(p);
1419      }
1420  
# Line 1342 | Line 1424 | public class ThreadPoolExecutorTest exte
1424      public void testBeforeAfter() throws InterruptedException {
1425          ExtendedTPE p = new ExtendedTPE();
1426          try {
1427 <            TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1428 <            p.execute(r);
1429 <            Thread.sleep(SHORT_DELAY_MS);
1430 <            assertTrue(r.done);
1431 <            assertTrue(p.beforeCalled);
1432 <            assertTrue(p.afterCalled);
1427 >            final CountDownLatch done = new CountDownLatch(1);
1428 >            p.execute(new CheckedRunnable() {
1429 >                public void realRun() {
1430 >                    done.countDown();
1431 >                }});
1432 >            await(p.afterCalled);
1433 >            assertEquals(0, done.getCount());
1434 >            assertTrue(p.afterCalled());
1435 >            assertTrue(p.beforeCalled());
1436              try { p.shutdown(); } catch (SecurityException ok) { return; }
1437          } finally {
1438              joinPool(p);
# Line 1405 | Line 1490 | public class ThreadPoolExecutorTest exte
1490          }
1491      }
1492  
1408 –
1493      /**
1494       * invokeAny(null) throws NPE
1495       */
# Line 1599 | Line 1683 | public class ThreadPoolExecutorTest exte
1683          }
1684      }
1685  
1602 –
1603 –
1686      /**
1687       * timed invokeAny(null) throws NPE
1688       */
# Line 1823 | Line 1905 | public class ThreadPoolExecutorTest exte
1905              l.add(new StringTask());
1906              l.add(new StringTask());
1907              List<Future<String>> futures =
1908 <                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1908 >                e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
1909              assertEquals(2, futures.size());
1910              for (Future<String> future : futures)
1911                  assertSame(TEST_STRING, future.get());
# Line 1841 | Line 1923 | public class ThreadPoolExecutorTest exte
1923                                     LONG_DELAY_MS, MILLISECONDS,
1924                                     new ArrayBlockingQueue<Runnable>(10));
1925          try {
1926 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1927 <            l.add(new StringTask());
1928 <            l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
1929 <            l.add(new StringTask());
1930 <            List<Future<String>> futures =
1931 <                e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
1932 <            assertEquals(3, futures.size());
1933 <            Iterator<Future<String>> it = futures.iterator();
1934 <            Future<String> f1 = it.next();
1935 <            Future<String> f2 = it.next();
1936 <            Future<String> f3 = it.next();
1937 <            assertTrue(f1.isDone());
1938 <            assertTrue(f2.isDone());
1939 <            assertTrue(f3.isDone());
1940 <            assertFalse(f1.isCancelled());
1941 <            assertTrue(f2.isCancelled());
1926 >            for (long timeout = timeoutMillis();;) {
1927 >                List<Callable<String>> tasks = new ArrayList<>();
1928 >                tasks.add(new StringTask("0"));
1929 >                tasks.add(Executors.callable(new LongPossiblyInterruptedRunnable(), TEST_STRING));
1930 >                tasks.add(new StringTask("2"));
1931 >                long startTime = System.nanoTime();
1932 >                List<Future<String>> futures =
1933 >                    e.invokeAll(tasks, timeout, MILLISECONDS);
1934 >                assertEquals(tasks.size(), futures.size());
1935 >                assertTrue(millisElapsedSince(startTime) >= timeout);
1936 >                for (Future future : futures)
1937 >                    assertTrue(future.isDone());
1938 >                assertTrue(futures.get(1).isCancelled());
1939 >                try {
1940 >                    assertEquals("0", futures.get(0).get());
1941 >                    assertEquals("2", futures.get(2).get());
1942 >                    break;
1943 >                } catch (CancellationException retryWithLongerTimeout) {
1944 >                    timeout *= 2;
1945 >                    if (timeout >= LONG_DELAY_MS / 2)
1946 >                        fail("expected exactly one task to be cancelled");
1947 >                }
1948 >            }
1949          } finally {
1950              joinPool(e);
1951          }
# Line 1902 | Line 1991 | public class ThreadPoolExecutorTest exte
1991       * allowCoreThreadTimeOut(true) causes idle threads to time out
1992       */
1993      public void testAllowCoreThreadTimeOut_true() throws Exception {
1994 +        long keepAliveTime = timeoutMillis();
1995          final ThreadPoolExecutor p =
1996              new ThreadPoolExecutor(2, 10,
1997 <                                   SHORT_DELAY_MS, MILLISECONDS,
1997 >                                   keepAliveTime, MILLISECONDS,
1998                                     new ArrayBlockingQueue<Runnable>(10));
1999          final CountDownLatch threadStarted = new CountDownLatch(1);
2000          try {
2001              p.allowCoreThreadTimeOut(true);
2002              p.execute(new CheckedRunnable() {
2003 <                public void realRun() throws InterruptedException {
2003 >                public void realRun() {
2004                      threadStarted.countDown();
2005                      assertEquals(1, p.getPoolSize());
2006                  }});
2007 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
2008 <            for (int i = 0; i < (MEDIUM_DELAY_MS/10); i++) {
2009 <                if (p.getPoolSize() == 0)
2010 <                    break;
2011 <                Thread.sleep(10);
2012 <            }
2007 >            await(threadStarted);
2008 >            delay(keepAliveTime);
2009 >            long startTime = System.nanoTime();
2010 >            while (p.getPoolSize() > 0
2011 >                   && millisElapsedSince(startTime) < LONG_DELAY_MS)
2012 >                Thread.yield();
2013 >            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
2014              assertEquals(0, p.getPoolSize());
2015          } finally {
2016              joinPool(p);
# Line 1930 | Line 2021 | public class ThreadPoolExecutorTest exte
2021       * allowCoreThreadTimeOut(false) causes idle threads not to time out
2022       */
2023      public void testAllowCoreThreadTimeOut_false() throws Exception {
2024 +        long keepAliveTime = timeoutMillis();
2025          final ThreadPoolExecutor p =
2026              new ThreadPoolExecutor(2, 10,
2027 <                                   SHORT_DELAY_MS, MILLISECONDS,
2027 >                                   keepAliveTime, MILLISECONDS,
2028                                     new ArrayBlockingQueue<Runnable>(10));
2029          final CountDownLatch threadStarted = new CountDownLatch(1);
2030          try {
# Line 1942 | Line 2034 | public class ThreadPoolExecutorTest exte
2034                      threadStarted.countDown();
2035                      assertTrue(p.getPoolSize() >= 1);
2036                  }});
2037 <            Thread.sleep(SMALL_DELAY_MS);
2037 >            delay(2 * keepAliveTime);
2038              assertTrue(p.getPoolSize() >= 1);
2039          } finally {
2040              joinPool(p);
# Line 1961 | Line 2053 | public class ThreadPoolExecutorTest exte
2053                  done.countDown();
2054              }};
2055          final ThreadPoolExecutor p =
2056 <            new ThreadPoolExecutor(1, 30, 60, TimeUnit.SECONDS,
2056 >            new ThreadPoolExecutor(1, 30,
2057 >                                   60, SECONDS,
2058                                     new ArrayBlockingQueue(30));
2059          try {
2060              for (int i = 0; i < nTasks; ++i) {
# Line 1976 | Line 2069 | public class ThreadPoolExecutorTest exte
2069              // enough time to run all tasks
2070              assertTrue(done.await(nTasks * SHORT_DELAY_MS, MILLISECONDS));
2071          } finally {
2072 <            p.shutdown();
2072 >            joinPool(p);
2073 >        }
2074 >    }
2075 >
2076 >    /**
2077 >     * get(cancelled task) throws CancellationException
2078 >     */
2079 >    public void testGet_cancelled() throws Exception {
2080 >        final ExecutorService e =
2081 >            new ThreadPoolExecutor(1, 1,
2082 >                                   LONG_DELAY_MS, MILLISECONDS,
2083 >                                   new LinkedBlockingQueue<Runnable>());
2084 >        try {
2085 >            final CountDownLatch blockerStarted = new CountDownLatch(1);
2086 >            final CountDownLatch done = new CountDownLatch(1);
2087 >            final List<Future<?>> futures = new ArrayList<>();
2088 >            for (int i = 0; i < 2; i++) {
2089 >                Runnable r = new CheckedRunnable() { public void realRun()
2090 >                                                         throws Throwable {
2091 >                    blockerStarted.countDown();
2092 >                    assertTrue(done.await(2 * LONG_DELAY_MS, MILLISECONDS));
2093 >                }};
2094 >                futures.add(e.submit(r));
2095 >            }
2096 >            assertTrue(blockerStarted.await(LONG_DELAY_MS, MILLISECONDS));
2097 >            for (Future<?> future : futures) future.cancel(false);
2098 >            for (Future<?> future : futures) {
2099 >                try {
2100 >                    future.get();
2101 >                    shouldThrow();
2102 >                } catch (CancellationException success) {}
2103 >                try {
2104 >                    future.get(LONG_DELAY_MS, MILLISECONDS);
2105 >                    shouldThrow();
2106 >                } catch (CancellationException success) {}
2107 >                assertTrue(future.isCancelled());
2108 >                assertTrue(future.isDone());
2109 >            }
2110 >            done.countDown();
2111 >        } finally {
2112 >            joinPool(e);
2113          }
2114      }
2115  

Diff Legend

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