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.57 by jsr166, Mon Sep 14 00:42:48 2015 UTC vs.
Revision 1.82 by jsr166, Sun Oct 4 02:26:47 2015 UTC

# Line 14 | Line 14 | 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.CancellationException;
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;
# Line 29 | Line 29 | import java.util.concurrent.SynchronousQ
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;
# Line 86 | 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();
93 <            }};
94 <        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));
97 <        } finally {
98 <            joinPool(p);
95 >            assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
96          }
97      }
98  
# Line 108 | 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 118 | 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());
123 –        } finally {
120              done.countDown();
125 –            joinPool(p);
121          }
122      }
123  
# Line 131 | 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 149 | 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 169 | 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 191 | Line 200 | public class ThreadPoolExecutorTest exte
200                      fail("timed out");
201                  Thread.yield();
202              }
194 –        } finally {
195 –            joinPool(p);
203          }
204      }
205  
# Line 204 | 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 216 | Line 224 | public class ThreadPoolExecutorTest exte
224              new ThreadPoolExecutor(2, 2,
225                                     1000, MILLISECONDS,
226                                     new ArrayBlockingQueue<Runnable>(10));
227 <        assertEquals(1, p.getKeepAliveTime(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 243 | 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 257 | 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 {
265 <            joinPool(p);
271 >        try (PoolCleaner cleaner = cleaner(p)) {
272 >            try {
273 >                p.setThreadFactory(null);
274 >                shouldThrow();
275 >            } catch (NullPointerException success) {}
276          }
277      }
278  
# Line 270 | 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 289 | 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 303 | 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 {
311 <            joinPool(p);
318 >        try (PoolCleaner cleaner = cleaner(p)) {
319 >            try {
320 >                p.setRejectedExecutionHandler(null);
321 >                shouldThrow();
322 >            } catch (NullPointerException success) {}
323          }
324      }
325  
# Line 322 | 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 333 | Line 344 | public class ThreadPoolExecutorTest exte
344                          done.await();
345                          assertEquals(THREADS, p.getLargestPoolSize());
346                      }});
347 <            assertTrue(threadsStarted.await(SMALL_DELAY_MS, MILLISECONDS));
337 <            assertEquals(THREADS, p.getLargestPoolSize());
338 <        } finally {
339 <            done.countDown();
340 <            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 351 | 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 364 | 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 374 | 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 {
380 <            done.countDown();
381 <            joinPool(p);
393 >            done.countDown();   // release pool
394          }
395      }
396  
# Line 390 | 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 400 | 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());
405 –        } finally {
417              done.countDown();
407 –            joinPool(p);
418          }
419      }
420  
# Line 416 | Line 426 | public class ThreadPoolExecutorTest exte
426              new ThreadPoolExecutor(1, 1,
427                                     LONG_DELAY_MS, MILLISECONDS,
428                                     new ArrayBlockingQueue<Runnable>(10));
429 <        assertFalse(p.isShutdown());
430 <        try { p.shutdown(); } catch (SecurityException ok) { return; }
431 <        assertTrue(p.isShutdown());
432 <        joinPool(p);
429 >        try (PoolCleaner cleaner = cleaner(p)) {
430 >            assertFalse(p.isShutdown());
431 >            try { p.shutdown(); } catch (SecurityException ok) { return; }
432 >            assertTrue(p.isShutdown());
433 >        }
434      }
435  
436      /**
# Line 470 | Line 481 | public class ThreadPoolExecutorTest exte
481                      threadStarted.countDown();
482                      done.await();
483                  }});
484 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
484 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
485              assertFalse(p.isTerminating());
486              done.countDown();
487          } finally {
# Line 498 | Line 509 | public class ThreadPoolExecutorTest exte
509                      threadStarted.countDown();
510                      done.await();
511                  }});
512 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
512 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
513              assertFalse(p.isTerminating());
514              done.countDown();
515          } finally {
# Line 533 | Line 544 | public class ThreadPoolExecutorTest exte
544                  tasks[i] = new FutureTask(task);
545                  p.execute(tasks[i]);
546              }
547 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
547 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
548              assertSame(q, p.getQueue());
549              assertFalse(q.contains(tasks[0]));
550              assertTrue(q.contains(tasks[tasks.length - 1]));
# Line 565 | Line 576 | public class ThreadPoolExecutorTest exte
576                      }};
577                  p.execute(tasks[i]);
578              }
579 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
579 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
580              assertFalse(p.remove(tasks[0]));
581              assertTrue(q.contains(tasks[4]));
582              assertTrue(q.contains(tasks[3]));
# Line 604 | Line 615 | public class ThreadPoolExecutorTest exte
615                  tasks[i] = new FutureTask(task);
616                  p.execute(tasks[i]);
617              }
618 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
618 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
619              assertEquals(tasks.length, p.getTaskCount());
620              assertEquals(tasks.length - 1, q.size());
621              assertEquals(1L, p.getActiveCount());
# Line 624 | Line 635 | public class ThreadPoolExecutorTest exte
635      }
636  
637      /**
638 <     * shutdownNow returns a list containing tasks that were not run
638 >     * shutdownNow returns a list containing tasks that were not run,
639 >     * and those tasks are drained from the queue
640       */
641 <    public void testShutdownNow() {
641 >    public void testShutdownNow() throws InterruptedException {
642 >        final int poolSize = 2;
643 >        final int count = 5;
644 >        final AtomicInteger ran = new AtomicInteger(0);
645          final ThreadPoolExecutor p =
646 <            new ThreadPoolExecutor(1, 1,
646 >            new ThreadPoolExecutor(poolSize, poolSize,
647                                     LONG_DELAY_MS, MILLISECONDS,
648                                     new ArrayBlockingQueue<Runnable>(10));
649 <        List l;
650 <        try {
651 <            for (int i = 0; i < 5; i++)
637 <                p.execute(new MediumPossiblyInterruptedRunnable());
638 <        }
639 <        finally {
649 >        CountDownLatch threadsStarted = new CountDownLatch(poolSize);
650 >        Runnable waiter = new CheckedRunnable() { public void realRun() {
651 >            threadsStarted.countDown();
652              try {
653 <                l = p.shutdownNow();
654 <            } catch (SecurityException ok) { return; }
653 >                MILLISECONDS.sleep(2 * LONG_DELAY_MS);
654 >            } catch (InterruptedException success) {}
655 >            ran.getAndIncrement();
656 >        }};
657 >        for (int i = 0; i < count; i++)
658 >            p.execute(waiter);
659 >        assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
660 >        assertEquals(poolSize, p.getActiveCount());
661 >        assertEquals(0, p.getCompletedTaskCount());
662 >        final List<Runnable> queuedTasks;
663 >        try {
664 >            queuedTasks = p.shutdownNow();
665 >        } catch (SecurityException ok) {
666 >            return; // Allowed in case test doesn't have privs
667          }
668          assertTrue(p.isShutdown());
669 <        assertTrue(l.size() <= 4);
669 >        assertTrue(p.getQueue().isEmpty());
670 >        assertEquals(count - poolSize, queuedTasks.size());
671 >        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
672 >        assertTrue(p.isTerminated());
673 >        assertEquals(poolSize, ran.get());
674 >        assertEquals(poolSize, p.getCompletedTaskCount());
675      }
676  
677      // Exception Tests
# Line 1008 | Line 1037 | public class ThreadPoolExecutorTest exte
1037                      p.submit(task).get();
1038                  }});
1039  
1040 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
1040 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
1041              t.interrupt();
1042              awaitTermination(t, MEDIUM_DELAY_MS);
1043          } finally {
# Line 1875 | Line 1904 | public class ThreadPoolExecutorTest exte
1904              l.add(new StringTask());
1905              l.add(new StringTask());
1906              List<Future<String>> futures =
1907 <                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1907 >                e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
1908              assertEquals(2, futures.size());
1909              for (Future<String> future : futures)
1910                  assertSame(TEST_STRING, future.get());
# Line 1895 | Line 1924 | public class ThreadPoolExecutorTest exte
1924          try {
1925              for (long timeout = timeoutMillis();;) {
1926                  List<Callable<String>> tasks = new ArrayList<>();
1927 <                tasks.add(new StringTask());
1927 >                tasks.add(new StringTask("0"));
1928                  tasks.add(Executors.callable(new LongPossiblyInterruptedRunnable(), TEST_STRING));
1929 <                tasks.add(new StringTask());
1929 >                tasks.add(new StringTask("2"));
1930                  long startTime = System.nanoTime();
1931                  List<Future<String>> futures =
1932                      e.invokeAll(tasks, timeout, MILLISECONDS);
# Line 1907 | Line 1936 | public class ThreadPoolExecutorTest exte
1936                      assertTrue(future.isDone());
1937                  assertTrue(futures.get(1).isCancelled());
1938                  try {
1939 <                    assertEquals(TEST_STRING, futures.get(0).get());
1940 <                    assertEquals(TEST_STRING, futures.get(2).get());
1939 >                    assertEquals("0", futures.get(0).get());
1940 >                    assertEquals("2", futures.get(2).get());
1941                      break;
1942                  } catch (CancellationException retryWithLongerTimeout) {
1943                      timeout *= 2;
# Line 2043 | Line 2072 | public class ThreadPoolExecutorTest exte
2072          }
2073      }
2074  
2075 +    /**
2076 +     * get(cancelled task) throws CancellationException
2077 +     */
2078 +    public void testGet_cancelled() throws Exception {
2079 +        final ExecutorService e =
2080 +            new ThreadPoolExecutor(1, 1,
2081 +                                   LONG_DELAY_MS, MILLISECONDS,
2082 +                                   new LinkedBlockingQueue<Runnable>());
2083 +        try {
2084 +            final CountDownLatch blockerStarted = new CountDownLatch(1);
2085 +            final CountDownLatch done = new CountDownLatch(1);
2086 +            final List<Future<?>> futures = new ArrayList<>();
2087 +            for (int i = 0; i < 2; i++) {
2088 +                Runnable r = new CheckedRunnable() { public void realRun()
2089 +                                                         throws Throwable {
2090 +                    blockerStarted.countDown();
2091 +                    assertTrue(done.await(2 * LONG_DELAY_MS, MILLISECONDS));
2092 +                }};
2093 +                futures.add(e.submit(r));
2094 +            }
2095 +            assertTrue(blockerStarted.await(LONG_DELAY_MS, MILLISECONDS));
2096 +            for (Future<?> future : futures) future.cancel(false);
2097 +            for (Future<?> future : futures) {
2098 +                try {
2099 +                    future.get();
2100 +                    shouldThrow();
2101 +                } catch (CancellationException success) {}
2102 +                try {
2103 +                    future.get(LONG_DELAY_MS, MILLISECONDS);
2104 +                    shouldThrow();
2105 +                } catch (CancellationException success) {}
2106 +                assertTrue(future.isCancelled());
2107 +                assertTrue(future.isDone());
2108 +            }
2109 +            done.countDown();
2110 +        } finally {
2111 +            joinPool(e);
2112 +        }
2113 +    }
2114 +
2115   }

Diff Legend

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