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.20 by dl, Wed Aug 11 19:50:02 2010 UTC vs.
Revision 1.34 by jsr166, Thu Nov 18 19:14:34 2010 UTC

# Line 4 | Line 4
4   * http://creativecommons.org/licenses/publicdomain
5   */
6  
7
7   import junit.framework.*;
8 < import java.util.*;
9 < import java.util.concurrent.Executor;
8 > import java.util.ArrayList;
9 > import java.util.Collection;
10 > import java.util.List;
11   import java.util.concurrent.Executors;
12   import java.util.concurrent.ExecutorService;
13   import java.util.concurrent.AbstractExecutorService;
# Line 20 | Line 20 | import java.util.concurrent.RejectedExec
20   import java.util.concurrent.ForkJoinPool;
21   import java.util.concurrent.ForkJoinTask;
22   import java.util.concurrent.ForkJoinWorkerThread;
23 import java.util.concurrent.RecursiveAction;
23   import java.util.concurrent.RecursiveTask;
24   import java.util.concurrent.TimeUnit;
25 < import java.util.concurrent.locks.*;
26 < import java.security.*;
25 > import java.util.concurrent.locks.ReentrantLock;
26 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
27 > import java.security.AccessControlException;
28 > import java.security.Policy;
29 > import java.security.PrivilegedAction;
30 > import java.security.PrivilegedExceptionAction;
31  
32   public class ForkJoinPoolTest extends JSR166TestCase {
33      public static void main(String[] args) {
34 <        junit.textui.TestRunner.run (suite());
34 >        junit.textui.TestRunner.run(suite());
35      }
36 +
37      public static Test suite() {
38          return new TestSuite(ForkJoinPoolTest.class);
39      }
# Line 156 | Line 160 | public class ForkJoinPoolTest extends JS
160       * tasks, and quiescent running state.
161       */
162      public void testDefaultInitialState() {
163 <        ForkJoinPool p = null;
163 >        ForkJoinPool p = new ForkJoinPool(1);
164          try {
165 <            p = new ForkJoinPool(1);
166 <            assertTrue(p.getFactory() ==
163 <                       ForkJoinPool.defaultForkJoinWorkerThreadFactory);
165 >            assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
166 >                       p.getFactory());
167              assertTrue(p.isQuiescent());
168              assertFalse(p.getAsyncMode());
169 <            assertTrue(p.getActiveThreadCount() == 0);
170 <            assertTrue(p.getStealCount() == 0);
171 <            assertTrue(p.getQueuedTaskCount() == 0);
172 <            assertTrue(p.getQueuedSubmissionCount() == 0);
169 >            assertEquals(0, p.getActiveThreadCount());
170 >            assertEquals(0, p.getStealCount());
171 >            assertEquals(0, p.getQueuedTaskCount());
172 >            assertEquals(0, p.getQueuedSubmissionCount());
173              assertFalse(p.hasQueuedSubmissions());
174              assertFalse(p.isShutdown());
175              assertFalse(p.isTerminating());
# Line 201 | Line 204 | public class ForkJoinPoolTest extends JS
204       * getParallelism returns size set in constructor
205       */
206      public void testGetParallelism() {
207 <        ForkJoinPool p = null;
207 >        ForkJoinPool p = new ForkJoinPool(1);
208          try {
209 <            p = new ForkJoinPool(1);
207 <            assertTrue(p.getParallelism() == 1);
209 >            assertEquals(1, p.getParallelism());
210          } finally {
211              joinPool(p);
212          }
# Line 214 | Line 216 | public class ForkJoinPoolTest extends JS
216       * getPoolSize returns number of started workers.
217       */
218      public void testGetPoolSize() {
219 <        ForkJoinPool p = null;
219 >        ForkJoinPool p = new ForkJoinPool(1);
220          try {
221 <            p = new ForkJoinPool(1);
220 <            assertTrue(p.getActiveThreadCount() == 0);
221 >            assertEquals(0, p.getActiveThreadCount());
222              Future<String> future = p.submit(new StringTask());
223 <            assertTrue(p.getPoolSize() == 1);
223 <
223 >            assertEquals(1, p.getPoolSize());
224          } finally {
225              joinPool(p);
226          }
# Line 233 | Line 233 | public class ForkJoinPoolTest extends JS
233       * performs its defined action
234       */
235      public void testSetUncaughtExceptionHandler() throws InterruptedException {
236 <        ForkJoinPool p = null;
237 <        try {
238 <            MyHandler eh = new MyHandler();
239 <            p = new ForkJoinPool(1, new FailingThreadFactory(), eh, false);
240 <            assert(eh == p.getUncaughtExceptionHandler());
241 <            p.execute(new FailingTask());
242 <            Thread.sleep(MEDIUM_DELAY_MS);
243 <            assertTrue(eh.catches > 0);
236 >        final CountDownLatch uehInvoked = new CountDownLatch(1);
237 >        final Thread.UncaughtExceptionHandler eh =
238 >            new Thread.UncaughtExceptionHandler() {
239 >                public void uncaughtException(Thread t, Throwable e) {
240 >                    uehInvoked.countDown();
241 >                }};
242 >        ForkJoinPool p = new ForkJoinPool(1, new FailingThreadFactory(),
243 >                                          eh, false);
244 >        try {
245 >            assertSame(eh, p.getUncaughtExceptionHandler());
246 >            p.execute(new FibTask(8));
247 >            assertTrue(uehInvoked.await(MEDIUM_DELAY_MS, MILLISECONDS));
248          } finally {
249 <            p.shutdownNow();
249 >            p.shutdownNow(); // failure might have prevented processing task
250              joinPool(p);
251          }
252      }
# Line 253 | Line 257 | public class ForkJoinPoolTest extends JS
257       * construction parameters continue to hold
258       */
259      public void testisQuiescent() throws InterruptedException {
260 <        ForkJoinPool p = null;
260 >        ForkJoinPool p = new ForkJoinPool(2);
261          try {
262 <            p = new ForkJoinPool(2);
262 >            assertTrue(p.isQuiescent());
263              p.invoke(new FibTask(20));
264 <            assertTrue(p.getFactory() ==
265 <                       ForkJoinPool.defaultForkJoinWorkerThreadFactory);
266 <            Thread.sleep(MEDIUM_DELAY_MS);
264 >            assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
265 >                       p.getFactory());
266 >            Thread.sleep(SMALL_DELAY_MS);
267              assertTrue(p.isQuiescent());
268              assertFalse(p.getAsyncMode());
269 <            assertTrue(p.getActiveThreadCount() == 0);
270 <            assertTrue(p.getQueuedTaskCount() == 0);
271 <            assertTrue(p.getQueuedSubmissionCount() == 0);
269 >            assertEquals(0, p.getActiveThreadCount());
270 >            assertEquals(0, p.getQueuedTaskCount());
271 >            assertEquals(0, p.getQueuedSubmissionCount());
272              assertFalse(p.hasQueuedSubmissions());
273              assertFalse(p.isShutdown());
274              assertFalse(p.isTerminating());
# Line 278 | Line 282 | public class ForkJoinPoolTest extends JS
282       * Completed submit(ForkJoinTask) returns result
283       */
284      public void testSubmitForkJoinTask() throws Throwable {
285 <        ForkJoinPool p = null;
285 >        ForkJoinPool p = new ForkJoinPool(1);
286          try {
283            p = new ForkJoinPool(1);
287              ForkJoinTask<Integer> f = p.submit(new FibTask(8));
288 <            int r = f.get();
286 <            assertTrue(r == 21);
288 >            assertEquals(21, (int) f.get());
289          } finally {
290              joinPool(p);
291          }
# Line 293 | Line 295 | public class ForkJoinPoolTest extends JS
295       * A task submitted after shutdown is rejected
296       */
297      public void testSubmitAfterShutdown() {
298 <        ForkJoinPool p = null;
298 >        ForkJoinPool p = new ForkJoinPool(1);
299          try {
298            p = new ForkJoinPool(1);
300              p.shutdown();
301              assertTrue(p.isShutdown());
302 <            ForkJoinTask<Integer> f = p.submit(new FibTask(8));
303 <            shouldThrow();
304 <        } catch (RejectedExecutionException success) {
302 >            try {
303 >                ForkJoinTask<Integer> f = p.submit(new FibTask(8));
304 >                shouldThrow();
305 >            } catch (RejectedExecutionException success) {}
306          } finally {
307              joinPool(p);
308          }
# Line 310 | Line 312 | public class ForkJoinPoolTest extends JS
312       * Pool maintains parallelism when using ManagedBlocker
313       */
314      public void testBlockingForkJoinTask() throws Throwable {
315 <        ForkJoinPool p = null;
315 >        ForkJoinPool p = new ForkJoinPool(4);
316          try {
315            p = new ForkJoinPool(4);
317              ReentrantLock lock = new ReentrantLock();
318              ManagedLocker locker = new ManagedLocker(lock);
319 <            ForkJoinTask<Integer> f = new LockingFibTask(30, locker, lock);
319 >            ForkJoinTask<Integer> f = new LockingFibTask(20, locker, lock);
320              p.execute(f);
321 <            int r = f.get();
321 <            assertTrue(r == 832040);
321 >            assertEquals(6765, (int) f.get());
322          } finally {
323              p.shutdownNow(); // don't wait out shutdown
324          }
# Line 328 | Line 328 | public class ForkJoinPoolTest extends JS
328       * pollSubmission returns unexecuted submitted task, if present
329       */
330      public void testPollSubmission() {
331 <        SubFJP p = null;
331 >        SubFJP p = new SubFJP();
332          try {
333 <            p = new SubFJP();
334 <            ForkJoinTask a = p.submit(new MediumRunnable());
335 <            ForkJoinTask b = p.submit(new MediumRunnable());
336 <            ForkJoinTask c = p.submit(new MediumRunnable());
333 >            ForkJoinTask a = p.submit(new ShortRunnable());
334 >            ForkJoinTask b = p.submit(new ShortRunnable());
335 >            ForkJoinTask c = p.submit(new ShortRunnable());
336              ForkJoinTask r = p.pollSubmission();
337              assertTrue(r == a || r == b || r == c);
338              assertFalse(r.isDone());
# Line 346 | Line 345 | public class ForkJoinPoolTest extends JS
345       * drainTasksTo transfers unexecuted submitted tasks, if present
346       */
347      public void testDrainTasksTo() {
348 <        SubFJP p = null;
348 >        SubFJP p = new SubFJP();
349          try {
350 <            p = new SubFJP();
351 <            ForkJoinTask a = p.submit(new MediumRunnable());
352 <            ForkJoinTask b = p.submit(new MediumRunnable());
354 <            ForkJoinTask c = p.submit(new MediumRunnable());
350 >            ForkJoinTask a = p.submit(new ShortRunnable());
351 >            ForkJoinTask b = p.submit(new ShortRunnable());
352 >            ForkJoinTask c = p.submit(new ShortRunnable());
353              ArrayList<ForkJoinTask> al = new ArrayList();
354              p.drainTasksTo(al);
355              assertTrue(al.size() > 0);
# Line 372 | Line 370 | public class ForkJoinPoolTest extends JS
370       */
371      public void testExecuteRunnable() throws Throwable {
372          ExecutorService e = new ForkJoinPool(1);
373 <        TrackedShortRunnable task = new TrackedShortRunnable();
374 <        assertFalse(task.done);
375 <        Future<?> future = e.submit(task);
376 <        future.get();
377 <        assertTrue(task.done);
373 >        try {
374 >            TrackedRunnable task = trackedRunnable(SHORT_DELAY_MS);
375 >            assertFalse(task.isDone());
376 >            Future<?> future = e.submit(task);
377 >            assertNull(future.get());
378 >            assertTrue(task.isDone());
379 >            assertFalse(future.isCancelled());
380 >        } finally {
381 >            joinPool(e);
382 >        }
383      }
384  
385  
# Line 385 | Line 388 | public class ForkJoinPoolTest extends JS
388       */
389      public void testSubmitCallable() throws Throwable {
390          ExecutorService e = new ForkJoinPool(1);
391 <        Future<String> future = e.submit(new StringTask());
392 <        String result = future.get();
393 <        assertSame(TEST_STRING, result);
391 >        try {
392 >            Future<String> future = e.submit(new StringTask());
393 >            assertSame(TEST_STRING, future.get());
394 >            assertTrue(future.isDone());
395 >            assertFalse(future.isCancelled());
396 >        } finally {
397 >            joinPool(e);
398 >        }
399      }
400  
401      /**
# Line 395 | Line 403 | public class ForkJoinPoolTest extends JS
403       */
404      public void testSubmitRunnable() throws Throwable {
405          ExecutorService e = new ForkJoinPool(1);
406 <        Future<?> future = e.submit(new NoOpRunnable());
407 <        future.get();
408 <        assertTrue(future.isDone());
406 >        try {
407 >            Future<?> future = e.submit(new NoOpRunnable());
408 >            assertNull(future.get());
409 >            assertTrue(future.isDone());
410 >            assertFalse(future.isCancelled());
411 >        } finally {
412 >            joinPool(e);
413 >        }
414      }
415  
416      /**
# Line 405 | Line 418 | public class ForkJoinPoolTest extends JS
418       */
419      public void testSubmitRunnable2() throws Throwable {
420          ExecutorService e = new ForkJoinPool(1);
421 <        Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
422 <        String result = future.get();
423 <        assertSame(TEST_STRING, result);
421 >        try {
422 >            Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
423 >            assertSame(TEST_STRING, future.get());
424 >            assertTrue(future.isDone());
425 >            assertFalse(future.isCancelled());
426 >        } finally {
427 >            joinPool(e);
428 >        }
429      }
430  
431  
432      /**
433 <     * A submitted privileged action to completion
433 >     * A submitted privileged action runs to completion
434       */
435      public void testSubmitPrivilegedAction() throws Throwable {
436          Policy savedPolicy = null;
# Line 425 | Line 443 | public class ForkJoinPoolTest extends JS
443          } catch (AccessControlException ok) {
444              return;
445          }
446 +
447          try {
448              ExecutorService e = new ForkJoinPool(1);
449 <            Future future = e.submit(Executors.callable(new PrivilegedAction() {
449 >            try {
450 >                Future future = e.submit(Executors.callable(new PrivilegedAction() {
451                      public Object run() {
452                          return TEST_STRING;
453                      }}));
454  
455 <            Object result = future.get();
456 <            assertSame(TEST_STRING, result);
457 <        }
458 <        finally {
455 >                Object result = future.get();
456 >                assertSame(TEST_STRING, result);
457 >            } finally {
458 >                joinPool(e);
459 >            }
460 >        } finally {
461              Policy.setPolicy(savedPolicy);
462          }
463      }
464  
465      /**
466 <     * A submitted a privileged exception action runs to completion
466 >     * A submitted privileged exception action runs to completion
467       */
468      public void testSubmitPrivilegedExceptionAction() throws Throwable {
469          Policy savedPolicy = null;
# Line 457 | Line 479 | public class ForkJoinPoolTest extends JS
479  
480          try {
481              ExecutorService e = new ForkJoinPool(1);
482 <            Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
482 >            try {
483 >                Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
484                      public Object run() {
485                          return TEST_STRING;
486                      }}));
487  
488 <            Object result = future.get();
489 <            assertSame(TEST_STRING, result);
490 <        }
491 <        finally {
488 >                Object result = future.get();
489 >                assertSame(TEST_STRING, result);
490 >            } finally {
491 >                joinPool(e);
492 >            }
493 >        } finally {
494              Policy.setPolicy(savedPolicy);
495          }
496      }
# Line 485 | Line 510 | public class ForkJoinPoolTest extends JS
510              return;
511          }
512  
488
513          try {
514              ExecutorService e = new ForkJoinPool(1);
515 <            Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
515 >            try {
516 >                Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
517                      public Object run() throws Exception {
518                          throw new IndexOutOfBoundsException();
519                      }}));
520  
521 <            Object result = future.get();
522 <            shouldThrow();
523 <        } catch (ExecutionException success) {
524 <            assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
521 >                Object result = future.get();
522 >                shouldThrow();
523 >            } catch (ExecutionException success) {
524 >                assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
525 >            } finally {
526 >                joinPool(e);
527 >            }
528          } finally {
529              Policy.setPolicy(savedPolicy);
530          }
# Line 506 | Line 534 | public class ForkJoinPoolTest extends JS
534       * execute(null runnable) throws NullPointerException
535       */
536      public void testExecuteNullRunnable() {
537 +        ExecutorService e = new ForkJoinPool(1);
538          try {
539 <            ExecutorService e = new ForkJoinPool(1);
511 <            TrackedShortRunnable task = null;
512 <            Future<?> future = e.submit(task);
539 >            Future<?> future = e.submit((Runnable) null);
540              shouldThrow();
541 <        } catch (NullPointerException success) {}
541 >        } catch (NullPointerException success) {
542 >        } finally {
543 >            joinPool(e);
544 >        }
545      }
546  
547  
# Line 519 | Line 549 | public class ForkJoinPoolTest extends JS
549       * submit(null callable) throws NullPointerException
550       */
551      public void testSubmitNullCallable() {
552 +        ExecutorService e = new ForkJoinPool(1);
553          try {
554 <            ExecutorService e = new ForkJoinPool(1);
524 <            StringTask t = null;
525 <            Future<String> future = e.submit(t);
554 >            Future<String> future = e.submit((Callable) null);
555              shouldThrow();
556 <        } catch (NullPointerException success) {}
556 >        } catch (NullPointerException success) {
557 >        } finally {
558 >            joinPool(e);
559 >        }
560      }
561  
562  
563      /**
564 <     * Blocking on submit(callable) throws InterruptedException if
533 <     * caller interrupted.
564 >     * submit(callable).get() throws InterruptedException if interrupted
565       */
566      public void testInterruptedSubmit() throws InterruptedException {
567 <        final ForkJoinPool p = new ForkJoinPool(1);
568 <
569 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
570 <            public void realRun() throws Throwable {
571 <                p.submit(new CheckedCallable<Object>() {
572 <                    public Object realCall() throws Throwable {
573 <                        try {
574 <                            Thread.sleep(MEDIUM_DELAY_MS);
575 <                        } catch (InterruptedException ok) {
576 <                        }
577 <                        return null;
578 <                    }}).get();
579 <            }});
580 <
581 <        t.start();
582 <        Thread.sleep(SHORT_DELAY_MS);
583 <        t.interrupt();
584 <        t.join();
585 <        p.shutdownNow();
586 <        joinPool(p);
567 >        final CountDownLatch submitted    = new CountDownLatch(1);
568 >        final CountDownLatch quittingTime = new CountDownLatch(1);
569 >        final ExecutorService p = new ForkJoinPool(1);
570 >        final Callable<Void> awaiter = new CheckedCallable<Void>() {
571 >            public Void realCall() throws InterruptedException {
572 >                assertTrue(quittingTime.await(MEDIUM_DELAY_MS, MILLISECONDS));
573 >                return null;
574 >            }};
575 >        try {
576 >            Thread t = new Thread(new CheckedInterruptedRunnable() {
577 >                public void realRun() throws Exception {
578 >                    Future<Void> future = p.submit(awaiter);
579 >                    submitted.countDown();
580 >                    future.get();
581 >                }});
582 >            t.start();
583 >            assertTrue(submitted.await(MEDIUM_DELAY_MS, MILLISECONDS));
584 >            t.interrupt();
585 >            t.join();
586 >        } finally {
587 >            quittingTime.countDown();
588 >            joinPool(p);
589 >        }
590      }
591  
592      /**
# Line 570 | Line 604 | public class ForkJoinPoolTest extends JS
604              shouldThrow();
605          } catch (ExecutionException success) {
606              assertTrue(success.getCause() instanceof ArithmeticException);
607 +        } finally {
608 +            joinPool(p);
609          }
574        
575        joinPool(p);
610      }
611  
612      /**
# Line 761 | Line 795 | public class ForkJoinPoolTest extends JS
795      public void testTimedInvokeAny1() throws Throwable {
796          ExecutorService e = new ForkJoinPool(1);
797          try {
798 <            e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
798 >            e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
799              shouldThrow();
800          } catch (NullPointerException success) {
801          } finally {
# Line 792 | Line 826 | public class ForkJoinPoolTest extends JS
826          ExecutorService e = new ForkJoinPool(1);
827          try {
828              e.invokeAny(new ArrayList<Callable<String>>(),
829 <                        MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
829 >                        MEDIUM_DELAY_MS, MILLISECONDS);
830              shouldThrow();
831          } catch (IllegalArgumentException success) {
832          } finally {
# Line 810 | Line 844 | public class ForkJoinPoolTest extends JS
844          l.add(latchAwaitingStringTask(latch));
845          l.add(null);
846          try {
847 <            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
847 >            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
848              shouldThrow();
849          } catch (NullPointerException success) {
850          } finally {
# Line 827 | Line 861 | public class ForkJoinPoolTest extends JS
861          List<Callable<String>> l = new ArrayList<Callable<String>>();
862          l.add(new NPETask());
863          try {
864 <            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
864 >            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
865              shouldThrow();
866          } catch (ExecutionException success) {
867              assertTrue(success.getCause() instanceof NullPointerException);
# Line 845 | Line 879 | public class ForkJoinPoolTest extends JS
879              List<Callable<String>> l = new ArrayList<Callable<String>>();
880              l.add(new StringTask());
881              l.add(new StringTask());
882 <            String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
882 >            String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
883              assertSame(TEST_STRING, result);
884          } finally {
885              joinPool(e);
# Line 858 | Line 892 | public class ForkJoinPoolTest extends JS
892      public void testTimedInvokeAll1() throws Throwable {
893          ExecutorService e = new ForkJoinPool(1);
894          try {
895 <            e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
895 >            e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
896              shouldThrow();
897          } catch (NullPointerException success) {
898          } finally {
# Line 890 | Line 924 | public class ForkJoinPoolTest extends JS
924          try {
925              List<Future<String>> r
926                  = e.invokeAll(new ArrayList<Callable<String>>(),
927 <                              MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
927 >                              MEDIUM_DELAY_MS, MILLISECONDS);
928              assertTrue(r.isEmpty());
929          } finally {
930              joinPool(e);
# Line 906 | Line 940 | public class ForkJoinPoolTest extends JS
940          l.add(new StringTask());
941          l.add(null);
942          try {
943 <            e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
943 >            e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
944              shouldThrow();
945          } catch (NullPointerException success) {
946          } finally {
# Line 922 | Line 956 | public class ForkJoinPoolTest extends JS
956          List<Callable<String>> l = new ArrayList<Callable<String>>();
957          l.add(new NPETask());
958          List<Future<String>> futures
959 <            = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
959 >            = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
960          assertEquals(1, futures.size());
961          try {
962              futures.get(0).get();
# Line 944 | Line 978 | public class ForkJoinPoolTest extends JS
978              l.add(new StringTask());
979              l.add(new StringTask());
980              List<Future<String>> futures
981 <                = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
981 >                = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
982              assertEquals(2, futures.size());
983              for (Future<String> future : futures)
984                  assertSame(TEST_STRING, future.get());

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines