ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ForkJoinPoolTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ForkJoinPoolTest.java (file contents):
Revision 1.25 by jsr166, Mon Sep 13 20:48:58 2010 UTC vs.
Revision 1.70 by jsr166, Tue Oct 13 21:18:28 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   */
6  
7 < import junit.framework.*;
7 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
8 > import static java.util.concurrent.TimeUnit.NANOSECONDS;
9 >
10 > import java.security.PrivilegedAction;
11 > import java.security.PrivilegedExceptionAction;
12   import java.util.ArrayList;
13   import java.util.Collection;
14   import java.util.List;
11 import java.util.concurrent.Executors;
12 import java.util.concurrent.ExecutorService;
13 import java.util.concurrent.AbstractExecutorService;
14 import java.util.concurrent.CountDownLatch;
15   import java.util.concurrent.Callable;
16 < import java.util.concurrent.Future;
16 > import java.util.concurrent.CountDownLatch;
17   import java.util.concurrent.ExecutionException;
18 < import java.util.concurrent.CancellationException;
19 < import java.util.concurrent.RejectedExecutionException;
18 > import java.util.concurrent.Executors;
19 > import java.util.concurrent.ExecutorService;
20   import java.util.concurrent.ForkJoinPool;
21   import java.util.concurrent.ForkJoinTask;
22   import java.util.concurrent.ForkJoinWorkerThread;
23 + import java.util.concurrent.Future;
24   import java.util.concurrent.RecursiveTask;
25 < import java.util.concurrent.TimeUnit;
25 > import java.util.concurrent.RejectedExecutionException;
26 > import java.util.concurrent.atomic.AtomicBoolean;
27   import java.util.concurrent.locks.ReentrantLock;
28 < import java.security.AccessControlException;
29 < import java.security.Policy;
30 < import java.security.PrivilegedAction;
31 < import java.security.PrivilegedExceptionAction;
28 >
29 > import junit.framework.AssertionFailedError;
30 > import junit.framework.Test;
31 > import junit.framework.TestSuite;
32  
33   public class ForkJoinPoolTest extends JSR166TestCase {
34      public static void main(String[] args) {
35 <        junit.textui.TestRunner.run(suite());
35 >        main(suite(), args);
36      }
37  
38      public static Test suite() {
39          return new TestSuite(ForkJoinPoolTest.class);
40      }
41  
42 <    /**
42 >    /*
43       * Testing coverage notes:
44       *
45       * 1. shutdown and related methods are tested via super.joinPool.
# Line 62 | Line 64 | public class ForkJoinPoolTest extends JS
64          }
65      }
66  
67 +    static class MyError extends Error {}
68 +
69      // to test handlers
70      static class FailingFJWSubclass extends ForkJoinWorkerThread {
71          public FailingFJWSubclass(ForkJoinPool p) { super(p) ; }
72 <        protected void onStart() { super.onStart(); throw new Error(); }
72 >        protected void onStart() { super.onStart(); throw new MyError(); }
73      }
74  
75      static class FailingThreadFactory
# Line 105 | Line 109 | public class ForkJoinPoolTest extends JS
109      static final class FibTask extends RecursiveTask<Integer> {
110          final int number;
111          FibTask(int n) { number = n; }
112 <        public Integer compute() {
112 >        protected Integer compute() {
113              int n = number;
114              if (n <= 1)
115                  return n;
# Line 133 | Line 137 | public class ForkJoinPoolTest extends JS
137              this.locker = locker;
138              this.lock = lock;
139          }
140 <        public Integer compute() {
140 >        protected Integer compute() {
141              int n;
142              LockingFibTask f1 = null;
143              LockingFibTask f2 = null;
# Line 160 | Line 164 | public class ForkJoinPoolTest extends JS
164       */
165      public void testDefaultInitialState() {
166          ForkJoinPool p = new ForkJoinPool(1);
167 <        try {
168 <            assertTrue(p.getFactory() ==
169 <                       ForkJoinPool.defaultForkJoinWorkerThreadFactory);
166 <            assertTrue(p.isQuiescent());
167 >        try (PoolCleaner cleaner = cleaner(p)) {
168 >            assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
169 >                       p.getFactory());
170              assertFalse(p.getAsyncMode());
171 <            assertTrue(p.getActiveThreadCount() == 0);
172 <            assertTrue(p.getStealCount() == 0);
173 <            assertTrue(p.getQueuedTaskCount() == 0);
174 <            assertTrue(p.getQueuedSubmissionCount() == 0);
171 >            assertEquals(0, p.getActiveThreadCount());
172 >            assertEquals(0, p.getStealCount());
173 >            assertEquals(0, p.getQueuedTaskCount());
174 >            assertEquals(0, p.getQueuedSubmissionCount());
175              assertFalse(p.hasQueuedSubmissions());
176              assertFalse(p.isShutdown());
177              assertFalse(p.isTerminating());
178              assertFalse(p.isTerminated());
176        } finally {
177            joinPool(p);
179          }
180      }
181  
# Line 198 | Line 199 | public class ForkJoinPoolTest extends JS
199          } catch (NullPointerException success) {}
200      }
201  
201
202      /**
203       * getParallelism returns size set in constructor
204       */
205      public void testGetParallelism() {
206          ForkJoinPool p = new ForkJoinPool(1);
207 <        try {
208 <            assertTrue(p.getParallelism() == 1);
209 <        } finally {
210 <            joinPool(p);
207 >        try (PoolCleaner cleaner = cleaner(p)) {
208 >            assertEquals(1, p.getParallelism());
209          }
210      }
211  
# Line 215 | Line 213 | public class ForkJoinPoolTest extends JS
213       * getPoolSize returns number of started workers.
214       */
215      public void testGetPoolSize() {
216 +        final CountDownLatch taskStarted = new CountDownLatch(1);
217 +        final CountDownLatch done = new CountDownLatch(1);
218 +        final ForkJoinPool p = new ForkJoinPool(1);
219 +        try (PoolCleaner cleaner = cleaner(p)) {
220 +            assertEquals(0, p.getActiveThreadCount());
221 +            final Runnable task = new CheckedRunnable() {
222 +                public void realRun() throws InterruptedException {
223 +                    taskStarted.countDown();
224 +                    assertEquals(1, p.getPoolSize());
225 +                    assertEquals(1, p.getActiveThreadCount());
226 +                    done.await();
227 +                }};
228 +            Future<?> future = p.submit(task);
229 +            await(taskStarted);
230 +            assertEquals(1, p.getPoolSize());
231 +            assertEquals(1, p.getActiveThreadCount());
232 +            done.countDown();
233 +        }
234 +        assertEquals(0, p.getPoolSize());
235 +        assertEquals(0, p.getActiveThreadCount());
236 +    }
237 +
238 +    /**
239 +     * awaitTermination on a non-shutdown pool times out
240 +     */
241 +    public void testAwaitTermination_timesOut() throws InterruptedException {
242          ForkJoinPool p = new ForkJoinPool(1);
243 <        try {
244 <            assertTrue(p.getActiveThreadCount() == 0);
245 <            Future<String> future = p.submit(new StringTask());
246 <            assertTrue(p.getPoolSize() == 1);
247 <        } finally {
248 <            joinPool(p);
243 >        try (PoolCleaner cleaner = cleaner(p)) {
244 >            assertFalse(p.isTerminated());
245 >            assertFalse(p.awaitTermination(Long.MIN_VALUE, NANOSECONDS));
246 >            assertFalse(p.awaitTermination(Long.MIN_VALUE, MILLISECONDS));
247 >            assertFalse(p.awaitTermination(-1L, NANOSECONDS));
248 >            assertFalse(p.awaitTermination(-1L, MILLISECONDS));
249 >            assertFalse(p.awaitTermination(0L, NANOSECONDS));
250 >            assertFalse(p.awaitTermination(0L, MILLISECONDS));
251 >            long timeoutNanos = 999999L;
252 >            long startTime = System.nanoTime();
253 >            assertFalse(p.awaitTermination(timeoutNanos, NANOSECONDS));
254 >            assertTrue(System.nanoTime() - startTime >= timeoutNanos);
255 >            assertFalse(p.isTerminated());
256 >            startTime = System.nanoTime();
257 >            long timeoutMillis = timeoutMillis();
258 >            assertFalse(p.awaitTermination(timeoutMillis, MILLISECONDS));
259 >            assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
260 >            assertFalse(p.isTerminated());
261 >            p.shutdown();
262 >            assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
263 >            assertTrue(p.isTerminated());
264          }
265      }
266  
# Line 232 | Line 271 | public class ForkJoinPoolTest extends JS
271       * performs its defined action
272       */
273      public void testSetUncaughtExceptionHandler() throws InterruptedException {
274 <        MyHandler eh = new MyHandler();
275 <        ForkJoinPool p = new ForkJoinPool(1, new FailingThreadFactory(), eh, false);
276 <        try {
277 <            assert(eh == p.getUncaughtExceptionHandler());
278 <            p.execute(new FailingTask());
279 <            Thread.sleep(MEDIUM_DELAY_MS);
280 <            assertTrue(eh.catches > 0);
281 <        } finally {
282 <            p.shutdownNow();
283 <            joinPool(p);
274 >        final CountDownLatch uehInvoked = new CountDownLatch(1);
275 >        final Thread.UncaughtExceptionHandler ueh =
276 >            new Thread.UncaughtExceptionHandler() {
277 >                public void uncaughtException(Thread t, Throwable e) {
278 >                    threadAssertTrue(e instanceof MyError);
279 >                    threadAssertTrue(t instanceof FailingFJWSubclass);
280 >                    uehInvoked.countDown();
281 >                }};
282 >        ForkJoinPool p = new ForkJoinPool(1, new FailingThreadFactory(),
283 >                                          ueh, false);
284 >        try (PoolCleaner cleaner = cleaner(p)) {
285 >            assertSame(ueh, p.getUncaughtExceptionHandler());
286 >            try {
287 >                p.execute(new FibTask(8));
288 >                await(uehInvoked);
289 >            } finally {
290 >                p.shutdownNow(); // failure might have prevented processing task
291 >            }
292          }
293      }
294  
295      /**
296 <     * After invoking a single task, isQuiescent is true,
297 <     * queues are empty, threads are not active, and
298 <     * construction parameters continue to hold
296 >     * After invoking a single task, isQuiescent eventually becomes
297 >     * true, at which time queues are empty, threads are not active,
298 >     * the task has completed successfully, and construction
299 >     * parameters continue to hold
300       */
301 <    public void testisQuiescent() throws InterruptedException {
301 >    public void testIsQuiescent() throws Exception {
302          ForkJoinPool p = new ForkJoinPool(2);
303 <        try {
304 <            p.invoke(new FibTask(20));
305 <            assertTrue(p.getFactory() ==
306 <                       ForkJoinPool.defaultForkJoinWorkerThreadFactory);
307 <            Thread.sleep(MEDIUM_DELAY_MS);
303 >        try (PoolCleaner cleaner = cleaner(p)) {
304 >            assertTrue(p.isQuiescent());
305 >            long startTime = System.nanoTime();
306 >            FibTask f = new FibTask(20);
307 >            p.invoke(f);
308 >            assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
309 >                       p.getFactory());
310 >            while (! p.isQuiescent()) {
311 >                if (millisElapsedSince(startTime) > LONG_DELAY_MS)
312 >                    throw new AssertionFailedError("timed out");
313 >                assertFalse(p.getAsyncMode());
314 >                assertFalse(p.isShutdown());
315 >                assertFalse(p.isTerminating());
316 >                assertFalse(p.isTerminated());
317 >                Thread.yield();
318 >            }
319 >
320              assertTrue(p.isQuiescent());
321              assertFalse(p.getAsyncMode());
322 <            assertTrue(p.getActiveThreadCount() == 0);
323 <            assertTrue(p.getQueuedTaskCount() == 0);
264 <            assertTrue(p.getQueuedSubmissionCount() == 0);
322 >            assertEquals(0, p.getQueuedTaskCount());
323 >            assertEquals(0, p.getQueuedSubmissionCount());
324              assertFalse(p.hasQueuedSubmissions());
325 +            while (p.getActiveThreadCount() != 0
326 +                   && millisElapsedSince(startTime) < LONG_DELAY_MS)
327 +                Thread.yield();
328              assertFalse(p.isShutdown());
329              assertFalse(p.isTerminating());
330              assertFalse(p.isTerminated());
331 <        } finally {
332 <            joinPool(p);
331 >            assertTrue(f.isDone());
332 >            assertEquals(6765, (int) f.get());
333 >            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
334          }
335      }
336  
# Line 276 | Line 339 | public class ForkJoinPoolTest extends JS
339       */
340      public void testSubmitForkJoinTask() throws Throwable {
341          ForkJoinPool p = new ForkJoinPool(1);
342 <        try {
342 >        try (PoolCleaner cleaner = cleaner(p)) {
343              ForkJoinTask<Integer> f = p.submit(new FibTask(8));
344 <            int r = f.get();
282 <            assertTrue(r == 21);
283 <        } finally {
284 <            joinPool(p);
344 >            assertEquals(21, (int) f.get());
345          }
346      }
347  
# Line 290 | Line 350 | public class ForkJoinPoolTest extends JS
350       */
351      public void testSubmitAfterShutdown() {
352          ForkJoinPool p = new ForkJoinPool(1);
353 <        try {
353 >        try (PoolCleaner cleaner = cleaner(p)) {
354              p.shutdown();
355              assertTrue(p.isShutdown());
356 <            ForkJoinTask<Integer> f = p.submit(new FibTask(8));
357 <            shouldThrow();
358 <        } catch (RejectedExecutionException success) {
359 <        } finally {
300 <            joinPool(p);
356 >            try {
357 >                ForkJoinTask<Integer> f = p.submit(new FibTask(8));
358 >                shouldThrow();
359 >            } catch (RejectedExecutionException success) {}
360          }
361      }
362  
# Line 309 | Line 368 | public class ForkJoinPoolTest extends JS
368          try {
369              ReentrantLock lock = new ReentrantLock();
370              ManagedLocker locker = new ManagedLocker(lock);
371 <            ForkJoinTask<Integer> f = new LockingFibTask(30, locker, lock);
371 >            ForkJoinTask<Integer> f = new LockingFibTask(20, locker, lock);
372              p.execute(f);
373 <            int r = f.get();
315 <            assertTrue(r == 832040);
373 >            assertEquals(6765, (int) f.get());
374          } finally {
375              p.shutdownNow(); // don't wait out shutdown
376          }
# Line 322 | Line 380 | public class ForkJoinPoolTest extends JS
380       * pollSubmission returns unexecuted submitted task, if present
381       */
382      public void testPollSubmission() {
383 +        final CountDownLatch done = new CountDownLatch(1);
384          SubFJP p = new SubFJP();
385 <        try {
386 <            ForkJoinTask a = p.submit(new MediumRunnable());
387 <            ForkJoinTask b = p.submit(new MediumRunnable());
388 <            ForkJoinTask c = p.submit(new MediumRunnable());
385 >        try (PoolCleaner cleaner = cleaner(p)) {
386 >            ForkJoinTask a = p.submit(awaiter(done));
387 >            ForkJoinTask b = p.submit(awaiter(done));
388 >            ForkJoinTask c = p.submit(awaiter(done));
389              ForkJoinTask r = p.pollSubmission();
390              assertTrue(r == a || r == b || r == c);
391              assertFalse(r.isDone());
392 <        } finally {
334 <            joinPool(p);
392 >            done.countDown();
393          }
394      }
395  
# Line 339 | Line 397 | public class ForkJoinPoolTest extends JS
397       * drainTasksTo transfers unexecuted submitted tasks, if present
398       */
399      public void testDrainTasksTo() {
400 +        final CountDownLatch done = new CountDownLatch(1);
401          SubFJP p = new SubFJP();
402 <        try {
403 <            ForkJoinTask a = p.submit(new MediumRunnable());
404 <            ForkJoinTask b = p.submit(new MediumRunnable());
405 <            ForkJoinTask c = p.submit(new MediumRunnable());
402 >        try (PoolCleaner cleaner = cleaner(p)) {
403 >            ForkJoinTask a = p.submit(awaiter(done));
404 >            ForkJoinTask b = p.submit(awaiter(done));
405 >            ForkJoinTask c = p.submit(awaiter(done));
406              ArrayList<ForkJoinTask> al = new ArrayList();
407              p.drainTasksTo(al);
408              assertTrue(al.size() > 0);
# Line 351 | Line 410 | public class ForkJoinPoolTest extends JS
410                  assertTrue(r == a || r == b || r == c);
411                  assertFalse(r.isDone());
412              }
413 <        } finally {
355 <            joinPool(p);
413 >            done.countDown();
414          }
415      }
416  
359
417      // FJ Versions of AbstractExecutorService tests
418  
419      /**
# Line 364 | Line 421 | public class ForkJoinPoolTest extends JS
421       */
422      public void testExecuteRunnable() throws Throwable {
423          ExecutorService e = new ForkJoinPool(1);
424 <        try {
425 <            TrackedShortRunnable task = new TrackedShortRunnable();
426 <            assertFalse(task.done);
427 <            Future<?> future = e.submit(task);
428 <            future.get();
429 <            assertTrue(task.done);
430 <        } finally {
431 <            joinPool(e);
424 >        try (PoolCleaner cleaner = cleaner(e)) {
425 >            final AtomicBoolean done = new AtomicBoolean(false);
426 >            Future<?> future = e.submit(new CheckedRunnable() {
427 >                public void realRun() {
428 >                    done.set(true);
429 >                }});
430 >            assertNull(future.get());
431 >            assertNull(future.get(0, MILLISECONDS));
432 >            assertTrue(done.get());
433 >            assertTrue(future.isDone());
434 >            assertFalse(future.isCancelled());
435          }
436      }
437  
378
438      /**
439       * Completed submit(callable) returns result
440       */
441      public void testSubmitCallable() throws Throwable {
442          ExecutorService e = new ForkJoinPool(1);
443 <        try {
443 >        try (PoolCleaner cleaner = cleaner(e)) {
444              Future<String> future = e.submit(new StringTask());
445 <            String result = future.get();
446 <            assertSame(TEST_STRING, result);
447 <        } finally {
389 <            joinPool(e);
445 >            assertSame(TEST_STRING, future.get());
446 >            assertTrue(future.isDone());
447 >            assertFalse(future.isCancelled());
448          }
449      }
450  
# Line 395 | Line 453 | public class ForkJoinPoolTest extends JS
453       */
454      public void testSubmitRunnable() throws Throwable {
455          ExecutorService e = new ForkJoinPool(1);
456 <        try {
456 >        try (PoolCleaner cleaner = cleaner(e)) {
457              Future<?> future = e.submit(new NoOpRunnable());
458 <            future.get();
458 >            assertNull(future.get());
459              assertTrue(future.isDone());
460 <        } finally {
403 <            joinPool(e);
460 >            assertFalse(future.isCancelled());
461          }
462      }
463  
# Line 409 | Line 466 | public class ForkJoinPoolTest extends JS
466       */
467      public void testSubmitRunnable2() throws Throwable {
468          ExecutorService e = new ForkJoinPool(1);
469 <        try {
469 >        try (PoolCleaner cleaner = cleaner(e)) {
470              Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
471 <            String result = future.get();
472 <            assertSame(TEST_STRING, result);
473 <        } finally {
417 <            joinPool(e);
471 >            assertSame(TEST_STRING, future.get());
472 >            assertTrue(future.isDone());
473 >            assertFalse(future.isCancelled());
474          }
475      }
476  
421
477      /**
478 <     * A submitted privileged action to completion
478 >     * A submitted privileged action runs to completion
479       */
480 <    public void testSubmitPrivilegedAction() throws Throwable {
481 <        Policy savedPolicy = null;
482 <        try {
483 <            savedPolicy = Policy.getPolicy();
484 <            AdjustablePolicy policy = new AdjustablePolicy();
430 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
431 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
432 <            Policy.setPolicy(policy);
433 <        } catch (AccessControlException ok) {
434 <            return;
435 <        }
436 <
437 <        try {
480 >    public void testSubmitPrivilegedAction() throws Exception {
481 >        final Callable callable = Executors.callable(new PrivilegedAction() {
482 >                public Object run() { return TEST_STRING; }});
483 >        Runnable r = new CheckedRunnable() {
484 >        public void realRun() throws Exception {
485              ExecutorService e = new ForkJoinPool(1);
486 <            try {
487 <                Future future = e.submit(Executors.callable(new PrivilegedAction() {
488 <                    public Object run() {
442 <                        return TEST_STRING;
443 <                    }}));
444 <
445 <                Object result = future.get();
446 <                assertSame(TEST_STRING, result);
447 <            } finally {
448 <                joinPool(e);
486 >            try (PoolCleaner cleaner = cleaner(e)) {
487 >                Future future = e.submit(callable);
488 >                assertSame(TEST_STRING, future.get());
489              }
490 <        } finally {
491 <            Policy.setPolicy(savedPolicy);
492 <        }
490 >        }};
491 >
492 >        runWithPermissions(r, new RuntimePermission("modifyThread"));
493      }
494  
495      /**
496 <     * A submitted a privileged exception action runs to completion
496 >     * A submitted privileged exception action runs to completion
497       */
498 <    public void testSubmitPrivilegedExceptionAction() throws Throwable {
499 <        Policy savedPolicy = null;
500 <        try {
501 <            savedPolicy = Policy.getPolicy();
502 <            AdjustablePolicy policy = new AdjustablePolicy();
503 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
464 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
465 <            Policy.setPolicy(policy);
466 <        } catch (AccessControlException ok) {
467 <            return;
468 <        }
469 <
470 <        try {
498 >    public void testSubmitPrivilegedExceptionAction() throws Exception {
499 >        final Callable callable =
500 >            Executors.callable(new PrivilegedExceptionAction() {
501 >                public Object run() { return TEST_STRING; }});
502 >        Runnable r = new CheckedRunnable() {
503 >        public void realRun() throws Exception {
504              ExecutorService e = new ForkJoinPool(1);
505 <            try {
506 <                Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
507 <                    public Object run() {
475 <                        return TEST_STRING;
476 <                    }}));
477 <
478 <                Object result = future.get();
479 <                assertSame(TEST_STRING, result);
480 <            } finally {
481 <                joinPool(e);
505 >            try (PoolCleaner cleaner = cleaner(e)) {
506 >                Future future = e.submit(callable);
507 >                assertSame(TEST_STRING, future.get());
508              }
509 <        } finally {
510 <            Policy.setPolicy(savedPolicy);
511 <        }
509 >        }};
510 >
511 >        runWithPermissions(r, new RuntimePermission("modifyThread"));
512      }
513  
514      /**
515       * A submitted failed privileged exception action reports exception
516       */
517 <    public void testSubmitFailedPrivilegedExceptionAction() throws Throwable {
518 <        Policy savedPolicy = null;
519 <        try {
520 <            savedPolicy = Policy.getPolicy();
521 <            AdjustablePolicy policy = new AdjustablePolicy();
522 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
497 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
498 <            Policy.setPolicy(policy);
499 <        } catch (AccessControlException ok) {
500 <            return;
501 <        }
502 <
503 <        try {
517 >    public void testSubmitFailedPrivilegedExceptionAction() throws Exception {
518 >        final Callable callable =
519 >            Executors.callable(new PrivilegedExceptionAction() {
520 >                public Object run() { throw new IndexOutOfBoundsException(); }});
521 >        Runnable r = new CheckedRunnable() {
522 >        public void realRun() throws Exception {
523              ExecutorService e = new ForkJoinPool(1);
524 <            try {
525 <                Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
526 <                    public Object run() throws Exception {
527 <                        throw new IndexOutOfBoundsException();
528 <                    }}));
529 <
530 <                Object result = future.get();
531 <                shouldThrow();
513 <            } catch (ExecutionException success) {
514 <                assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
515 <            } finally {
516 <                joinPool(e);
524 >            try (PoolCleaner cleaner = cleaner(e)) {
525 >                Future future = e.submit(callable);
526 >                try {
527 >                    future.get();
528 >                    shouldThrow();
529 >                } catch (ExecutionException success) {
530 >                    assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
531 >                }
532              }
533 <        } finally {
534 <            Policy.setPolicy(savedPolicy);
535 <        }
533 >        }};
534 >
535 >        runWithPermissions(r, new RuntimePermission("modifyThread"));
536      }
537  
538      /**
# Line 525 | Line 540 | public class ForkJoinPoolTest extends JS
540       */
541      public void testExecuteNullRunnable() {
542          ExecutorService e = new ForkJoinPool(1);
543 <        try {
544 <            TrackedShortRunnable task = null;
545 <            Future<?> future = e.submit(task);
546 <            shouldThrow();
547 <        } catch (NullPointerException success) {
533 <        } finally {
534 <            joinPool(e);
543 >        try (PoolCleaner cleaner = cleaner(e)) {
544 >            try {
545 >                Future<?> future = e.submit((Runnable) null);
546 >                shouldThrow();
547 >            } catch (NullPointerException success) {}
548          }
549      }
550  
538
551      /**
552       * submit(null callable) throws NullPointerException
553       */
554      public void testSubmitNullCallable() {
555          ExecutorService e = new ForkJoinPool(1);
556 <        try {
557 <            StringTask t = null;
558 <            Future<String> future = e.submit(t);
559 <            shouldThrow();
560 <        } catch (NullPointerException success) {
549 <        } finally {
550 <            joinPool(e);
556 >        try (PoolCleaner cleaner = cleaner(e)) {
557 >            try {
558 >                Future<String> future = e.submit((Callable) null);
559 >                shouldThrow();
560 >            } catch (NullPointerException success) {}
561          }
562      }
563  
554
564      /**
565 <     * Blocking on submit(callable) throws InterruptedException if
557 <     * caller interrupted.
565 >     * submit(callable).get() throws InterruptedException if interrupted
566       */
567      public void testInterruptedSubmit() throws InterruptedException {
568 <        final ForkJoinPool p = new ForkJoinPool(1);
569 <
570 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
571 <            public void realRun() throws Throwable {
572 <                p.submit(new CheckedCallable<Object>() {
573 <                    public Object realCall() throws Throwable {
574 <                        try {
575 <                            Thread.sleep(MEDIUM_DELAY_MS);
576 <                        } catch (InterruptedException ok) {
577 <                        }
578 <                        return null;
579 <                    }}).get();
580 <            }});
581 <
582 <        t.start();
583 <        Thread.sleep(SHORT_DELAY_MS);
584 <        t.interrupt();
585 <        t.join();
586 <        p.shutdownNow();
587 <        joinPool(p);
568 >        final CountDownLatch submitted    = new CountDownLatch(1);
569 >        final CountDownLatch quittingTime = new CountDownLatch(1);
570 >        final Callable<Void> awaiter = new CheckedCallable<Void>() {
571 >            public Void realCall() throws InterruptedException {
572 >                assertTrue(quittingTime.await(2*LONG_DELAY_MS, MILLISECONDS));
573 >                return null;
574 >            }};
575 >        final ExecutorService p = new ForkJoinPool(1);
576 >        try (PoolCleaner cleaner = cleaner(p, quittingTime)) {
577 >            Thread t = new Thread(new CheckedInterruptedRunnable() {
578 >                public void realRun() throws Exception {
579 >                    Future<Void> future = p.submit(awaiter);
580 >                    submitted.countDown();
581 >                    future.get();
582 >                }});
583 >            t.start();
584 >            await(submitted);
585 >            t.interrupt();
586 >            awaitTermination(t);
587 >        }
588      }
589  
590      /**
# Line 585 | Line 593 | public class ForkJoinPoolTest extends JS
593       */
594      public void testSubmitEE() throws Throwable {
595          ForkJoinPool p = new ForkJoinPool(1);
596 <        try {
597 <            p.submit(new Callable() {
598 <                public Object call() {
599 <                    int i = 5/0;
600 <                    return Boolean.TRUE;
601 <                }}).get();
602 <            shouldThrow();
603 <        } catch (ExecutionException success) {
604 <            assertTrue(success.getCause() instanceof ArithmeticException);
597 <        } finally {
598 <            joinPool(p);
596 >        try (PoolCleaner cleaner = cleaner(p)) {
597 >            try {
598 >                p.submit(new Callable() {
599 >                        public Object call() { throw new ArithmeticException(); }})
600 >                    .get();
601 >                shouldThrow();
602 >            } catch (ExecutionException success) {
603 >                assertTrue(success.getCause() instanceof ArithmeticException);
604 >            }
605          }
606      }
607  
# Line 604 | Line 610 | public class ForkJoinPoolTest extends JS
610       */
611      public void testInvokeAny1() throws Throwable {
612          ExecutorService e = new ForkJoinPool(1);
613 <        try {
614 <            e.invokeAny(null);
615 <            shouldThrow();
616 <        } catch (NullPointerException success) {
617 <        } finally {
612 <            joinPool(e);
613 >        try (PoolCleaner cleaner = cleaner(e)) {
614 >            try {
615 >                e.invokeAny(null);
616 >                shouldThrow();
617 >            } catch (NullPointerException success) {}
618          }
619      }
620  
# Line 618 | Line 623 | public class ForkJoinPoolTest extends JS
623       */
624      public void testInvokeAny2() throws Throwable {
625          ExecutorService e = new ForkJoinPool(1);
626 <        try {
627 <            e.invokeAny(new ArrayList<Callable<String>>());
628 <            shouldThrow();
629 <        } catch (IllegalArgumentException success) {
630 <        } finally {
626 <            joinPool(e);
626 >        try (PoolCleaner cleaner = cleaner(e)) {
627 >            try {
628 >                e.invokeAny(new ArrayList<Callable<String>>());
629 >                shouldThrow();
630 >            } catch (IllegalArgumentException success) {}
631          }
632      }
633  
# Line 632 | Line 636 | public class ForkJoinPoolTest extends JS
636       */
637      public void testInvokeAny3() throws Throwable {
638          ExecutorService e = new ForkJoinPool(1);
639 <        List<Callable<String>> l = new ArrayList<Callable<String>>();
640 <        l.add(null);
641 <        try {
642 <            e.invokeAny(l);
643 <            shouldThrow();
644 <        } catch (NullPointerException success) {
645 <        } finally {
642 <            joinPool(e);
639 >        try (PoolCleaner cleaner = cleaner(e)) {
640 >            List<Callable<String>> l = new ArrayList<Callable<String>>();
641 >            l.add(null);
642 >            try {
643 >                e.invokeAny(l);
644 >                shouldThrow();
645 >            } catch (NullPointerException success) {}
646          }
647      }
648  
# Line 649 | Line 652 | public class ForkJoinPoolTest extends JS
652      public void testInvokeAny4() throws Throwable {
653          CountDownLatch latch = new CountDownLatch(1);
654          ExecutorService e = new ForkJoinPool(1);
655 <        List<Callable<String>> l = new ArrayList<Callable<String>>();
656 <        l.add(latchAwaitingStringTask(latch));
657 <        l.add(null);
658 <        try {
659 <            e.invokeAny(l);
660 <            shouldThrow();
661 <        } catch (NullPointerException success) {
662 <        } finally {
655 >        try (PoolCleaner cleaner = cleaner(e)) {
656 >            List<Callable<String>> l = new ArrayList<Callable<String>>();
657 >            l.add(latchAwaitingStringTask(latch));
658 >            l.add(null);
659 >            try {
660 >                e.invokeAny(l);
661 >                shouldThrow();
662 >            } catch (NullPointerException success) {}
663              latch.countDown();
661            joinPool(e);
664          }
665      }
666  
# Line 667 | Line 669 | public class ForkJoinPoolTest extends JS
669       */
670      public void testInvokeAny5() throws Throwable {
671          ExecutorService e = new ForkJoinPool(1);
672 <        List<Callable<String>> l = new ArrayList<Callable<String>>();
673 <        l.add(new NPETask());
674 <        try {
675 <            e.invokeAny(l);
676 <            shouldThrow();
677 <        } catch (ExecutionException success) {
678 <            assertTrue(success.getCause() instanceof NullPointerException);
679 <        } finally {
680 <            joinPool(e);
672 >        try (PoolCleaner cleaner = cleaner(e)) {
673 >            List<Callable<String>> l = new ArrayList<Callable<String>>();
674 >            l.add(new NPETask());
675 >            try {
676 >                e.invokeAny(l);
677 >                shouldThrow();
678 >            } catch (ExecutionException success) {
679 >                assertTrue(success.getCause() instanceof NullPointerException);
680 >            }
681          }
682      }
683  
# Line 684 | Line 686 | public class ForkJoinPoolTest extends JS
686       */
687      public void testInvokeAny6() throws Throwable {
688          ExecutorService e = new ForkJoinPool(1);
689 <        try {
689 >        try (PoolCleaner cleaner = cleaner(e)) {
690              List<Callable<String>> l = new ArrayList<Callable<String>>();
691              l.add(new StringTask());
692              l.add(new StringTask());
693              String result = e.invokeAny(l);
694              assertSame(TEST_STRING, result);
693        } finally {
694            joinPool(e);
695          }
696      }
697  
# Line 700 | Line 700 | public class ForkJoinPoolTest extends JS
700       */
701      public void testInvokeAll1() throws Throwable {
702          ExecutorService e = new ForkJoinPool(1);
703 <        try {
704 <            e.invokeAll(null);
705 <            shouldThrow();
706 <        } catch (NullPointerException success) {
707 <        } finally {
708 <            joinPool(e);
703 >        try (PoolCleaner cleaner = cleaner(e)) {
704 >            try {
705 >                e.invokeAll(null);
706 >                shouldThrow();
707 >            } catch (NullPointerException success) {}
708          }
709      }
710  
# Line 714 | Line 713 | public class ForkJoinPoolTest extends JS
713       */
714      public void testInvokeAll2() throws InterruptedException {
715          ExecutorService e = new ForkJoinPool(1);
716 <        try {
716 >        try (PoolCleaner cleaner = cleaner(e)) {
717              List<Future<String>> r
718                  = e.invokeAll(new ArrayList<Callable<String>>());
719              assertTrue(r.isEmpty());
721        } finally {
722            joinPool(e);
720          }
721      }
722  
# Line 728 | Line 725 | public class ForkJoinPoolTest extends JS
725       */
726      public void testInvokeAll3() throws InterruptedException {
727          ExecutorService e = new ForkJoinPool(1);
728 <        List<Callable<String>> l = new ArrayList<Callable<String>>();
729 <        l.add(new StringTask());
730 <        l.add(null);
731 <        try {
732 <            e.invokeAll(l);
733 <            shouldThrow();
734 <        } catch (NullPointerException success) {
735 <        } finally {
739 <            joinPool(e);
728 >        try (PoolCleaner cleaner = cleaner(e)) {
729 >            List<Callable<String>> l = new ArrayList<Callable<String>>();
730 >            l.add(new StringTask());
731 >            l.add(null);
732 >            try {
733 >                e.invokeAll(l);
734 >                shouldThrow();
735 >            } catch (NullPointerException success) {}
736          }
737      }
738  
# Line 746 | Line 742 | public class ForkJoinPoolTest extends JS
742       */
743      public void testInvokeAll4() throws Throwable {
744          ExecutorService e = new ForkJoinPool(1);
745 <        List<Callable<String>> l = new ArrayList<Callable<String>>();
746 <        l.add(new NPETask());
747 <        List<Future<String>> futures = e.invokeAll(l);
748 <        assertEquals(1, futures.size());
749 <        try {
750 <            futures.get(0).get();
751 <            shouldThrow();
752 <        } catch (ExecutionException success) {
753 <            assertTrue(success.getCause() instanceof NullPointerException);
754 <        } finally {
755 <            joinPool(e);
745 >        try (PoolCleaner cleaner = cleaner(e)) {
746 >            List<Callable<String>> l = new ArrayList<Callable<String>>();
747 >            l.add(new NPETask());
748 >            List<Future<String>> futures = e.invokeAll(l);
749 >            assertEquals(1, futures.size());
750 >            try {
751 >                futures.get(0).get();
752 >                shouldThrow();
753 >            } catch (ExecutionException success) {
754 >                assertTrue(success.getCause() instanceof NullPointerException);
755 >            }
756          }
757      }
758  
# Line 765 | Line 761 | public class ForkJoinPoolTest extends JS
761       */
762      public void testInvokeAll5() throws Throwable {
763          ExecutorService e = new ForkJoinPool(1);
764 <        try {
764 >        try (PoolCleaner cleaner = cleaner(e)) {
765              List<Callable<String>> l = new ArrayList<Callable<String>>();
766              l.add(new StringTask());
767              l.add(new StringTask());
# Line 773 | Line 769 | public class ForkJoinPoolTest extends JS
769              assertEquals(2, futures.size());
770              for (Future<String> future : futures)
771                  assertSame(TEST_STRING, future.get());
776        } finally {
777            joinPool(e);
772          }
773      }
774  
781
775      /**
776       * timed invokeAny(null) throws NullPointerException
777       */
778      public void testTimedInvokeAny1() throws Throwable {
779          ExecutorService e = new ForkJoinPool(1);
780 <        try {
781 <            e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
782 <            shouldThrow();
783 <        } catch (NullPointerException success) {
784 <        } finally {
792 <            joinPool(e);
780 >        try (PoolCleaner cleaner = cleaner(e)) {
781 >            try {
782 >                e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
783 >                shouldThrow();
784 >            } catch (NullPointerException success) {}
785          }
786      }
787  
# Line 798 | Line 790 | public class ForkJoinPoolTest extends JS
790       */
791      public void testTimedInvokeAnyNullTimeUnit() throws Throwable {
792          ExecutorService e = new ForkJoinPool(1);
793 <        List<Callable<String>> l = new ArrayList<Callable<String>>();
794 <        l.add(new StringTask());
795 <        try {
796 <            e.invokeAny(l, MEDIUM_DELAY_MS, null);
797 <            shouldThrow();
798 <        } catch (NullPointerException success) {
799 <        } finally {
808 <            joinPool(e);
793 >        try (PoolCleaner cleaner = cleaner(e)) {
794 >            List<Callable<String>> l = new ArrayList<Callable<String>>();
795 >            l.add(new StringTask());
796 >            try {
797 >                e.invokeAny(l, MEDIUM_DELAY_MS, null);
798 >                shouldThrow();
799 >            } catch (NullPointerException success) {}
800          }
801      }
802  
# Line 814 | Line 805 | public class ForkJoinPoolTest extends JS
805       */
806      public void testTimedInvokeAny2() throws Throwable {
807          ExecutorService e = new ForkJoinPool(1);
808 <        try {
809 <            e.invokeAny(new ArrayList<Callable<String>>(),
810 <                        MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
811 <            shouldThrow();
812 <        } catch (IllegalArgumentException success) {
813 <        } finally {
823 <            joinPool(e);
808 >        try (PoolCleaner cleaner = cleaner(e)) {
809 >            try {
810 >                e.invokeAny(new ArrayList<Callable<String>>(),
811 >                            MEDIUM_DELAY_MS, MILLISECONDS);
812 >                shouldThrow();
813 >            } catch (IllegalArgumentException success) {}
814          }
815      }
816  
# Line 830 | Line 820 | public class ForkJoinPoolTest extends JS
820      public void testTimedInvokeAny3() throws Throwable {
821          CountDownLatch latch = new CountDownLatch(1);
822          ExecutorService e = new ForkJoinPool(1);
823 <        List<Callable<String>> l = new ArrayList<Callable<String>>();
824 <        l.add(latchAwaitingStringTask(latch));
825 <        l.add(null);
826 <        try {
827 <            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
828 <            shouldThrow();
829 <        } catch (NullPointerException success) {
830 <        } finally {
823 >        try (PoolCleaner cleaner = cleaner(e)) {
824 >            List<Callable<String>> l = new ArrayList<Callable<String>>();
825 >            l.add(latchAwaitingStringTask(latch));
826 >            l.add(null);
827 >            try {
828 >                e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
829 >                shouldThrow();
830 >            } catch (NullPointerException success) {}
831              latch.countDown();
842            joinPool(e);
832          }
833      }
834  
# Line 848 | Line 837 | public class ForkJoinPoolTest extends JS
837       */
838      public void testTimedInvokeAny4() throws Throwable {
839          ExecutorService e = new ForkJoinPool(1);
840 <        List<Callable<String>> l = new ArrayList<Callable<String>>();
841 <        l.add(new NPETask());
842 <        try {
843 <            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
844 <            shouldThrow();
845 <        } catch (ExecutionException success) {
846 <            assertTrue(success.getCause() instanceof NullPointerException);
847 <        } finally {
848 <            joinPool(e);
840 >        try (PoolCleaner cleaner = cleaner(e)) {
841 >            long startTime = System.nanoTime();
842 >            List<Callable<String>> l = new ArrayList<Callable<String>>();
843 >            l.add(new NPETask());
844 >            try {
845 >                e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
846 >                shouldThrow();
847 >            } catch (ExecutionException success) {
848 >                assertTrue(success.getCause() instanceof NullPointerException);
849 >            }
850 >            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
851          }
852      }
853  
# Line 865 | Line 856 | public class ForkJoinPoolTest extends JS
856       */
857      public void testTimedInvokeAny5() throws Throwable {
858          ExecutorService e = new ForkJoinPool(1);
859 <        try {
859 >        try (PoolCleaner cleaner = cleaner(e)) {
860 >            long startTime = System.nanoTime();
861              List<Callable<String>> l = new ArrayList<Callable<String>>();
862              l.add(new StringTask());
863              l.add(new StringTask());
864 <            String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
864 >            String result = e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
865              assertSame(TEST_STRING, result);
866 <        } finally {
875 <            joinPool(e);
866 >            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
867          }
868      }
869  
# Line 881 | Line 872 | public class ForkJoinPoolTest extends JS
872       */
873      public void testTimedInvokeAll1() throws Throwable {
874          ExecutorService e = new ForkJoinPool(1);
875 <        try {
876 <            e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
877 <            shouldThrow();
878 <        } catch (NullPointerException success) {
879 <        } finally {
889 <            joinPool(e);
875 >        try (PoolCleaner cleaner = cleaner(e)) {
876 >            try {
877 >                e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
878 >                shouldThrow();
879 >            } catch (NullPointerException success) {}
880          }
881      }
882  
# Line 895 | Line 885 | public class ForkJoinPoolTest extends JS
885       */
886      public void testTimedInvokeAllNullTimeUnit() throws Throwable {
887          ExecutorService e = new ForkJoinPool(1);
888 <        List<Callable<String>> l = new ArrayList<Callable<String>>();
889 <        l.add(new StringTask());
890 <        try {
891 <            e.invokeAll(l, MEDIUM_DELAY_MS, null);
892 <            shouldThrow();
893 <        } catch (NullPointerException success) {
894 <        } finally {
905 <            joinPool(e);
888 >        try (PoolCleaner cleaner = cleaner(e)) {
889 >            List<Callable<String>> l = new ArrayList<Callable<String>>();
890 >            l.add(new StringTask());
891 >            try {
892 >                e.invokeAll(l, MEDIUM_DELAY_MS, null);
893 >                shouldThrow();
894 >            } catch (NullPointerException success) {}
895          }
896      }
897  
# Line 911 | Line 900 | public class ForkJoinPoolTest extends JS
900       */
901      public void testTimedInvokeAll2() throws InterruptedException {
902          ExecutorService e = new ForkJoinPool(1);
903 <        try {
903 >        try (PoolCleaner cleaner = cleaner(e)) {
904              List<Future<String>> r
905                  = e.invokeAll(new ArrayList<Callable<String>>(),
906 <                              MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
906 >                              MEDIUM_DELAY_MS, MILLISECONDS);
907              assertTrue(r.isEmpty());
919        } finally {
920            joinPool(e);
908          }
909      }
910  
# Line 926 | Line 913 | public class ForkJoinPoolTest extends JS
913       */
914      public void testTimedInvokeAll3() throws InterruptedException {
915          ExecutorService e = new ForkJoinPool(1);
916 <        List<Callable<String>> l = new ArrayList<Callable<String>>();
917 <        l.add(new StringTask());
918 <        l.add(null);
919 <        try {
920 <            e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
921 <            shouldThrow();
922 <        } catch (NullPointerException success) {
923 <        } finally {
937 <            joinPool(e);
916 >        try (PoolCleaner cleaner = cleaner(e)) {
917 >            List<Callable<String>> l = new ArrayList<Callable<String>>();
918 >            l.add(new StringTask());
919 >            l.add(null);
920 >            try {
921 >                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
922 >                shouldThrow();
923 >            } catch (NullPointerException success) {}
924          }
925      }
926  
# Line 943 | Line 929 | public class ForkJoinPoolTest extends JS
929       */
930      public void testTimedInvokeAll4() throws Throwable {
931          ExecutorService e = new ForkJoinPool(1);
932 <        List<Callable<String>> l = new ArrayList<Callable<String>>();
933 <        l.add(new NPETask());
934 <        List<Future<String>> futures
935 <            = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
936 <        assertEquals(1, futures.size());
937 <        try {
938 <            futures.get(0).get();
939 <            shouldThrow();
940 <        } catch (ExecutionException success) {
941 <            assertTrue(success.getCause() instanceof NullPointerException);
942 <        } finally {
943 <            joinPool(e);
932 >        try (PoolCleaner cleaner = cleaner(e)) {
933 >            List<Callable<String>> l = new ArrayList<Callable<String>>();
934 >            l.add(new NPETask());
935 >            List<Future<String>> futures
936 >                = e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
937 >            assertEquals(1, futures.size());
938 >            try {
939 >                futures.get(0).get();
940 >                shouldThrow();
941 >            } catch (ExecutionException success) {
942 >                assertTrue(success.getCause() instanceof NullPointerException);
943 >            }
944          }
945      }
946  
# Line 962 | Line 948 | public class ForkJoinPoolTest extends JS
948       * timed invokeAll(c) returns results of all completed tasks in c
949       */
950      public void testTimedInvokeAll5() throws Throwable {
951 <        ExecutorService e = new ForkJoinPool(1);
952 <        try {
951 >        ForkJoinPool e = new ForkJoinPool(1);
952 >        try (PoolCleaner cleaner = cleaner(e)) {
953              List<Callable<String>> l = new ArrayList<Callable<String>>();
954              l.add(new StringTask());
955              l.add(new StringTask());
956              List<Future<String>> futures
957 <                = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
957 >                = e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
958              assertEquals(2, futures.size());
959              for (Future<String> future : futures)
960                  assertSame(TEST_STRING, future.get());
975        } finally {
976            joinPool(e);
961          }
962      }
963  

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines