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.17 by jsr166, Tue Jan 5 02:08:37 2010 UTC vs.
Revision 1.26 by jsr166, Thu Sep 16 00:52:49 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.*;
10 < import static java.util.concurrent.TimeUnit.MILLISECONDS;
11 < import java.util.concurrent.locks.*;
12 < import java.security.*;
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;
14 > import java.util.concurrent.CountDownLatch;
15 > import java.util.concurrent.Callable;
16 > import java.util.concurrent.Future;
17 > import java.util.concurrent.ExecutionException;
18 > import java.util.concurrent.CancellationException;
19 > import java.util.concurrent.RejectedExecutionException;
20 > import java.util.concurrent.ForkJoinPool;
21 > import java.util.concurrent.ForkJoinTask;
22 > import java.util.concurrent.ForkJoinWorkerThread;
23 > import java.util.concurrent.RecursiveTask;
24 > import java.util.concurrent.TimeUnit;
25 > import java.util.concurrent.locks.ReentrantLock;
26 > import java.security.AccessControlException;
27 > import java.security.Policy;
28 > import java.security.PrivilegedAction;
29 > import java.security.PrivilegedExceptionAction;
30  
31   public class ForkJoinPoolTest extends JSR166TestCase {
32      public static void main(String[] args) {
33 <        junit.textui.TestRunner.run (suite());
33 >        junit.textui.TestRunner.run(suite());
34      }
35 +
36      public static Test suite() {
37          return new TestSuite(ForkJoinPoolTest.class);
38      }
# Line 39 | Line 56 | public class ForkJoinPoolTest extends JS
56      // Some classes to test extension and factory methods
57  
58      static class MyHandler implements Thread.UncaughtExceptionHandler {
59 <        int catches = 0;
59 >        volatile int catches = 0;
60          public void uncaughtException(Thread t, Throwable e) {
61              ++catches;
62          }
# Line 48 | Line 65 | public class ForkJoinPoolTest extends JS
65      // to test handlers
66      static class FailingFJWSubclass extends ForkJoinWorkerThread {
67          public FailingFJWSubclass(ForkJoinPool p) { super(p) ; }
68 <        protected void onStart() { throw new Error(); }
68 >        protected void onStart() { super.onStart(); throw new Error(); }
69      }
70  
71      static class FailingThreadFactory
72              implements ForkJoinPool.ForkJoinWorkerThreadFactory {
73 <        int calls = 0;
73 >        volatile int calls = 0;
74          public ForkJoinWorkerThread newThread(ForkJoinPool p) {
75              if (++calls > 1) return null;
76              return new FailingFJWSubclass(p);
# Line 142 | Line 159 | public class ForkJoinPoolTest extends JS
159       * tasks, and quiescent running state.
160       */
161      public void testDefaultInitialState() {
162 <        ForkJoinPool p = null;
162 >        ForkJoinPool p = new ForkJoinPool(1);
163          try {
164 <            p = new ForkJoinPool(1);
165 <            assertTrue(p.getFactory() ==
149 <                       ForkJoinPool.defaultForkJoinWorkerThreadFactory);
164 >            assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
165 >                       p.getFactory());
166              assertTrue(p.isQuiescent());
151 –            assertTrue(p.getMaintainsParallelism());
167              assertFalse(p.getAsyncMode());
168 <            assertTrue(p.getActiveThreadCount() == 0);
169 <            assertTrue(p.getStealCount() == 0);
170 <            assertTrue(p.getQueuedTaskCount() == 0);
171 <            assertTrue(p.getQueuedSubmissionCount() == 0);
168 >            assertEquals(0, p.getActiveThreadCount());
169 >            assertEquals(0, p.getStealCount());
170 >            assertEquals(0, p.getQueuedTaskCount());
171 >            assertEquals(0, p.getQueuedSubmissionCount());
172              assertFalse(p.hasQueuedSubmissions());
173              assertFalse(p.isShutdown());
174              assertFalse(p.isTerminating());
# Line 178 | Line 193 | public class ForkJoinPoolTest extends JS
193       */
194      public void testConstructor2() {
195          try {
196 <            new ForkJoinPool(1, null);
196 >            new ForkJoinPool(1, null, null, false);
197              shouldThrow();
198          } catch (NullPointerException success) {}
199      }
# Line 188 | Line 203 | public class ForkJoinPoolTest extends JS
203       * getParallelism returns size set in constructor
204       */
205      public void testGetParallelism() {
206 <        ForkJoinPool p = null;
192 <        try {
193 <            p = new ForkJoinPool(1);
194 <            assertTrue(p.getParallelism() == 1);
195 <        } finally {
196 <            joinPool(p);
197 <        }
198 <    }
199 <
200 <    /**
201 <     * setParallelism changes reported parallelism level.
202 <     */
203 <    public void testSetParallelism() {
204 <        ForkJoinPool p = null;
205 <        try {
206 <            p = new ForkJoinPool(1);
207 <            assertTrue(p.getParallelism() == 1);
208 <            p.setParallelism(2);
209 <            assertTrue(p.getParallelism() == 2);
210 <        } finally {
211 <            joinPool(p);
212 <        }
213 <    }
214 <
215 <    /**
216 <     * setParallelism with argument <= 0 throws exception
217 <     */
218 <    public void testSetParallelism2() {
219 <        ForkJoinPool p = null;
206 >        ForkJoinPool p = new ForkJoinPool(1);
207          try {
208 <            p = new ForkJoinPool(1);
222 <            assertTrue(p.getParallelism() == 1);
223 <            p.setParallelism(-2);
224 <            shouldThrow();
225 <        } catch (IllegalArgumentException success) {
208 >            assertEquals(1, p.getParallelism());
209          } finally {
210              joinPool(p);
211          }
# Line 232 | Line 215 | public class ForkJoinPoolTest extends JS
215       * getPoolSize returns number of started workers.
216       */
217      public void testGetPoolSize() {
218 <        ForkJoinPool p = null;
218 >        ForkJoinPool p = new ForkJoinPool(1);
219          try {
220 <            p = new ForkJoinPool(1);
238 <            assertTrue(p.getPoolSize() == 0);
220 >            assertEquals(0, p.getActiveThreadCount());
221              Future<String> future = p.submit(new StringTask());
222 <            assertTrue(p.getPoolSize() == 1);
241 <
242 <        } finally {
243 <            joinPool(p);
244 <        }
245 <    }
246 <
247 <    /**
248 <     * setMaximumPoolSize changes size reported by getMaximumPoolSize.
249 <     */
250 <    public void testSetMaximumPoolSize() {
251 <        ForkJoinPool p = null;
252 <        try {
253 <            p = new ForkJoinPool(1);
254 <            p.setMaximumPoolSize(2);
255 <            assertTrue(p.getMaximumPoolSize() == 2);
256 <        } finally {
257 <            joinPool(p);
258 <        }
259 <    }
260 <
261 <    /**
262 <     * setMaximumPoolSize with argument <= 0 throws exception
263 <     */
264 <    public void testSetMaximumPoolSize2() {
265 <        ForkJoinPool p = null;
266 <        try {
267 <            p = new ForkJoinPool(1);
268 <            p.setMaximumPoolSize(-2);
269 <            shouldThrow();
270 <        } catch (IllegalArgumentException success) {
271 <        } finally {
272 <            joinPool(p);
273 <        }
274 <    }
275 <
276 <    /**
277 <     * setMaintainsParallelism changes policy reported by
278 <     * getMaintainsParallelism.
279 <     */
280 <    public void testSetMaintainsParallelism() {
281 <        ForkJoinPool p = null;
282 <        try {
283 <            p = new ForkJoinPool(1);
284 <            p.setMaintainsParallelism(false);
285 <            assertFalse(p.getMaintainsParallelism());
286 <        } finally {
287 <            joinPool(p);
288 <        }
289 <    }
290 <
291 <    /**
292 <     * setAsyncMode changes policy reported by
293 <     * getAsyncMode.
294 <     */
295 <    public void testSetAsyncMode() {
296 <        ForkJoinPool p = null;
297 <        try {
298 <            p = new ForkJoinPool(1);
299 <            p.setAsyncMode(true);
300 <            assertTrue(p.getAsyncMode());
222 >            assertEquals(1, p.getPoolSize());
223          } finally {
224              joinPool(p);
225          }
# Line 310 | Line 232 | public class ForkJoinPoolTest extends JS
232       * performs its defined action
233       */
234      public void testSetUncaughtExceptionHandler() throws InterruptedException {
235 <        ForkJoinPool p = null;
235 >        MyHandler eh = new MyHandler();
236 >        ForkJoinPool p = new ForkJoinPool(1, new FailingThreadFactory(),
237 >                                          eh, false);
238          try {
239 <            p = new ForkJoinPool(1, new FailingThreadFactory());
316 <            MyHandler eh = new MyHandler();
317 <            p.setUncaughtExceptionHandler(eh);
318 <            assertEquals(eh, p.getUncaughtExceptionHandler());
239 >            assertSame(eh, p.getUncaughtExceptionHandler());
240              p.execute(new FailingTask());
241              Thread.sleep(MEDIUM_DELAY_MS);
242              assertTrue(eh.catches > 0);
243          } finally {
244 +            p.shutdownNow();
245              joinPool(p);
246          }
247      }
248  
249      /**
328 –     * setUncaughtExceptionHandler of null removes handler
329 –     */
330 –    public void testSetUncaughtExceptionHandler2() {
331 –        ForkJoinPool p = null;
332 –        try {
333 –            p = new ForkJoinPool(1);
334 –            p.setUncaughtExceptionHandler(null);
335 –            assertNull(p.getUncaughtExceptionHandler());
336 –        } finally {
337 –            joinPool(p);
338 –        }
339 –    }
340 –
341 –
342 –    /**
250       * After invoking a single task, isQuiescent is true,
251       * queues are empty, threads are not active, and
252       * construction parameters continue to hold
253       */
254      public void testisQuiescent() throws InterruptedException {
255 <        ForkJoinPool p = null;
255 >        ForkJoinPool p = new ForkJoinPool(2);
256          try {
350 –            p = new ForkJoinPool(2);
257              p.invoke(new FibTask(20));
258 <            assertTrue(p.getFactory() ==
259 <                       ForkJoinPool.defaultForkJoinWorkerThreadFactory);
258 >            assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
259 >                       p.getFactory());
260              Thread.sleep(MEDIUM_DELAY_MS);
261              assertTrue(p.isQuiescent());
356 –            assertTrue(p.getMaintainsParallelism());
262              assertFalse(p.getAsyncMode());
263 <            assertTrue(p.getActiveThreadCount() == 0);
264 <            assertTrue(p.getQueuedTaskCount() == 0);
265 <            assertTrue(p.getQueuedSubmissionCount() == 0);
263 >            assertEquals(0, p.getActiveThreadCount());
264 >            assertEquals(0, p.getQueuedTaskCount());
265 >            assertEquals(0, p.getQueuedSubmissionCount());
266              assertFalse(p.hasQueuedSubmissions());
267              assertFalse(p.isShutdown());
268              assertFalse(p.isTerminating());
# Line 371 | Line 276 | public class ForkJoinPoolTest extends JS
276       * Completed submit(ForkJoinTask) returns result
277       */
278      public void testSubmitForkJoinTask() throws Throwable {
279 <        ForkJoinPool p = null;
279 >        ForkJoinPool p = new ForkJoinPool(1);
280          try {
376 –            p = new ForkJoinPool(1);
281              ForkJoinTask<Integer> f = p.submit(new FibTask(8));
282 <            int r = f.get();
379 <            assertTrue(r == 21);
282 >            assertEquals(21, (int) f.get());
283          } finally {
284              joinPool(p);
285          }
# Line 386 | Line 289 | public class ForkJoinPoolTest extends JS
289       * A task submitted after shutdown is rejected
290       */
291      public void testSubmitAfterShutdown() {
292 <        ForkJoinPool p = null;
292 >        ForkJoinPool p = new ForkJoinPool(1);
293          try {
391 –            p = new ForkJoinPool(1);
294              p.shutdown();
295              assertTrue(p.isShutdown());
296 <            ForkJoinTask<Integer> f = p.submit(new FibTask(8));
297 <            shouldThrow();
298 <        } catch (RejectedExecutionException success) {
296 >            try {
297 >                ForkJoinTask<Integer> f = p.submit(new FibTask(8));
298 >                shouldThrow();
299 >            } catch (RejectedExecutionException success) {}
300          } finally {
301              joinPool(p);
302          }
# Line 403 | Line 306 | public class ForkJoinPoolTest extends JS
306       * Pool maintains parallelism when using ManagedBlocker
307       */
308      public void testBlockingForkJoinTask() throws Throwable {
309 <        ForkJoinPool p = null;
309 >        ForkJoinPool p = new ForkJoinPool(4);
310          try {
408 –            p = new ForkJoinPool(4);
311              ReentrantLock lock = new ReentrantLock();
312              ManagedLocker locker = new ManagedLocker(lock);
313              ForkJoinTask<Integer> f = new LockingFibTask(30, locker, lock);
314              p.execute(f);
315 <            assertTrue(p.getPoolSize() >= 4);
414 <            int r = f.get();
415 <            assertTrue(r == 832040);
315 >            assertEquals(832040, (int) f.get());
316          } finally {
317              p.shutdownNow(); // don't wait out shutdown
318          }
# Line 422 | Line 322 | public class ForkJoinPoolTest extends JS
322       * pollSubmission returns unexecuted submitted task, if present
323       */
324      public void testPollSubmission() {
325 <        SubFJP p = null;
325 >        SubFJP p = new SubFJP();
326          try {
427 –            p = new SubFJP();
327              ForkJoinTask a = p.submit(new MediumRunnable());
328              ForkJoinTask b = p.submit(new MediumRunnable());
329              ForkJoinTask c = p.submit(new MediumRunnable());
# Line 440 | Line 339 | public class ForkJoinPoolTest extends JS
339       * drainTasksTo transfers unexecuted submitted tasks, if present
340       */
341      public void testDrainTasksTo() {
342 <        SubFJP p = null;
342 >        SubFJP p = new SubFJP();
343          try {
445 –            p = new SubFJP();
344              ForkJoinTask a = p.submit(new MediumRunnable());
345              ForkJoinTask b = p.submit(new MediumRunnable());
346              ForkJoinTask c = p.submit(new MediumRunnable());
# Line 466 | Line 364 | public class ForkJoinPoolTest extends JS
364       */
365      public void testExecuteRunnable() throws Throwable {
366          ExecutorService e = new ForkJoinPool(1);
367 <        TrackedShortRunnable task = new TrackedShortRunnable();
368 <        assertFalse(task.done);
369 <        Future<?> future = e.submit(task);
370 <        future.get();
371 <        assertTrue(task.done);
367 >        try {
368 >            TrackedShortRunnable task = new TrackedShortRunnable();
369 >            assertFalse(task.done);
370 >            Future<?> future = e.submit(task);
371 >            future.get();
372 >            assertTrue(task.done);
373 >        } finally {
374 >            joinPool(e);
375 >        }
376      }
377  
378  
# Line 479 | Line 381 | public class ForkJoinPoolTest extends JS
381       */
382      public void testSubmitCallable() throws Throwable {
383          ExecutorService e = new ForkJoinPool(1);
384 <        Future<String> future = e.submit(new StringTask());
385 <        String result = future.get();
386 <        assertSame(TEST_STRING, result);
384 >        try {
385 >            Future<String> future = e.submit(new StringTask());
386 >            String result = future.get();
387 >            assertSame(TEST_STRING, result);
388 >        } finally {
389 >            joinPool(e);
390 >        }
391      }
392  
393      /**
# Line 489 | Line 395 | public class ForkJoinPoolTest extends JS
395       */
396      public void testSubmitRunnable() throws Throwable {
397          ExecutorService e = new ForkJoinPool(1);
398 <        Future<?> future = e.submit(new NoOpRunnable());
399 <        future.get();
400 <        assertTrue(future.isDone());
398 >        try {
399 >            Future<?> future = e.submit(new NoOpRunnable());
400 >            future.get();
401 >            assertTrue(future.isDone());
402 >        } finally {
403 >            joinPool(e);
404 >        }
405      }
406  
407      /**
# Line 499 | Line 409 | public class ForkJoinPoolTest extends JS
409       */
410      public void testSubmitRunnable2() throws Throwable {
411          ExecutorService e = new ForkJoinPool(1);
412 <        Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
413 <        String result = future.get();
414 <        assertSame(TEST_STRING, result);
412 >        try {
413 >            Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
414 >            String result = future.get();
415 >            assertSame(TEST_STRING, result);
416 >        } finally {
417 >            joinPool(e);
418 >        }
419      }
420  
421 +
422      /**
423 <     * A submitted privileged action runs to completion
423 >     * A submitted privileged action to completion
424       */
425      public void testSubmitPrivilegedAction() throws Throwable {
426 <        Runnable r = new CheckedRunnable() {
427 <            public void realRun() throws Exception {
428 <                ExecutorService e = new ForkJoinPool(1);
426 >        Policy savedPolicy = null;
427 >        try {
428 >            savedPolicy = Policy.getPolicy();
429 >            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 {
438 >            ExecutorService e = new ForkJoinPool(1);
439 >            try {
440                  Future future = e.submit(Executors.callable(new PrivilegedAction() {
441                      public Object run() {
442                          return TEST_STRING;
# Line 518 | Line 444 | public class ForkJoinPoolTest extends JS
444  
445                  Object result = future.get();
446                  assertSame(TEST_STRING, result);
447 <            }};
448 <
449 <        runWithPermissions(r, new RuntimePermission("modifyThread"));
447 >            } finally {
448 >                joinPool(e);
449 >            }
450 >        } finally {
451 >            Policy.setPolicy(savedPolicy);
452 >        }
453      }
454  
455      /**
456 <     * A submitted privileged exception action runs to completion
456 >     * A submitted a privileged exception action runs to completion
457       */
458      public void testSubmitPrivilegedExceptionAction() throws Throwable {
459 <        Runnable r = new CheckedRunnable() {
460 <            public void realRun() throws Exception {
461 <                ExecutorService e = new ForkJoinPool(1);
459 >        Policy savedPolicy = null;
460 >        try {
461 >            savedPolicy = Policy.getPolicy();
462 >            AdjustablePolicy policy = new AdjustablePolicy();
463 >            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 {
471 >            ExecutorService e = new ForkJoinPool(1);
472 >            try {
473                  Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
474                      public Object run() {
475                          return TEST_STRING;
# Line 537 | Line 477 | public class ForkJoinPoolTest extends JS
477  
478                  Object result = future.get();
479                  assertSame(TEST_STRING, result);
480 <            }};
481 <
482 <        runWithPermissions(r, new RuntimePermission("modifyThread"));
480 >            } finally {
481 >                joinPool(e);
482 >            }
483 >        } finally {
484 >            Policy.setPolicy(savedPolicy);
485 >        }
486      }
487  
488      /**
489       * A submitted failed privileged exception action reports exception
490       */
491      public void testSubmitFailedPrivilegedExceptionAction() throws Throwable {
492 <        Runnable r = new CheckedRunnable() {
493 <            public void realRun() throws Exception {
494 <                ExecutorService e = new ForkJoinPool(1);
492 >        Policy savedPolicy = null;
493 >        try {
494 >            savedPolicy = Policy.getPolicy();
495 >            AdjustablePolicy policy = new AdjustablePolicy();
496 >            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 {
504 >            ExecutorService e = new ForkJoinPool(1);
505 >            try {
506                  Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
507                      public Object run() throws Exception {
508                          throw new IndexOutOfBoundsException();
509                      }}));
510  
511 <                try {
512 <                    Object result = future.get();
513 <                    shouldThrow();
514 <                } catch (ExecutionException success) {
515 <                    assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
516 <                }}};
517 <
518 <        runWithPermissions(r, new RuntimePermission("modifyThread"));
511 >                Object result = future.get();
512 >                shouldThrow();
513 >            } catch (ExecutionException success) {
514 >                assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
515 >            } finally {
516 >                joinPool(e);
517 >            }
518 >        } finally {
519 >            Policy.setPolicy(savedPolicy);
520 >        }
521      }
522  
523      /**
524       * execute(null runnable) throws NullPointerException
525       */
526      public void testExecuteNullRunnable() {
527 +        ExecutorService e = new ForkJoinPool(1);
528 +        TrackedShortRunnable task = null;
529          try {
572 –            ExecutorService e = new ForkJoinPool(1);
573 –            TrackedShortRunnable task = null;
530              Future<?> future = e.submit(task);
531              shouldThrow();
532 <        } catch (NullPointerException success) {}
532 >        } catch (NullPointerException success) {
533 >        } finally {
534 >            joinPool(e);
535 >        }
536      }
537  
538  
# Line 581 | Line 540 | public class ForkJoinPoolTest extends JS
540       * submit(null callable) throws NullPointerException
541       */
542      public void testSubmitNullCallable() {
543 +        ExecutorService e = new ForkJoinPool(1);
544 +        StringTask t = null;
545          try {
585 –            ExecutorService e = new ForkJoinPool(1);
586 –            StringTask t = null;
546              Future<String> future = e.submit(t);
547              shouldThrow();
548 <        } catch (NullPointerException success) {}
548 >        } catch (NullPointerException success) {
549 >        } finally {
550 >            joinPool(e);
551 >        }
552      }
553  
554  
# Line 632 | Line 594 | public class ForkJoinPoolTest extends JS
594              shouldThrow();
595          } catch (ExecutionException success) {
596              assertTrue(success.getCause() instanceof ArithmeticException);
597 +        } finally {
598 +            joinPool(p);
599          }
636 –
637 –        joinPool(p);
600      }
601  
602      /**
# Line 823 | Line 785 | public class ForkJoinPoolTest extends JS
785      public void testTimedInvokeAny1() throws Throwable {
786          ExecutorService e = new ForkJoinPool(1);
787          try {
788 <            e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
788 >            e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
789              shouldThrow();
790          } catch (NullPointerException success) {
791          } finally {
# Line 854 | Line 816 | public class ForkJoinPoolTest extends JS
816          ExecutorService e = new ForkJoinPool(1);
817          try {
818              e.invokeAny(new ArrayList<Callable<String>>(),
819 <                        MEDIUM_DELAY_MS, MILLISECONDS);
819 >                        MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
820              shouldThrow();
821          } catch (IllegalArgumentException success) {
822          } finally {
# Line 872 | Line 834 | public class ForkJoinPoolTest extends JS
834          l.add(latchAwaitingStringTask(latch));
835          l.add(null);
836          try {
837 <            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
837 >            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
838              shouldThrow();
839          } catch (NullPointerException success) {
840          } finally {
# Line 889 | Line 851 | public class ForkJoinPoolTest extends JS
851          List<Callable<String>> l = new ArrayList<Callable<String>>();
852          l.add(new NPETask());
853          try {
854 <            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
854 >            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
855              shouldThrow();
856          } catch (ExecutionException success) {
857              assertTrue(success.getCause() instanceof NullPointerException);
# Line 907 | Line 869 | public class ForkJoinPoolTest extends JS
869              List<Callable<String>> l = new ArrayList<Callable<String>>();
870              l.add(new StringTask());
871              l.add(new StringTask());
872 <            String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
872 >            String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
873              assertSame(TEST_STRING, result);
874          } finally {
875              joinPool(e);
# Line 920 | Line 882 | public class ForkJoinPoolTest extends JS
882      public void testTimedInvokeAll1() throws Throwable {
883          ExecutorService e = new ForkJoinPool(1);
884          try {
885 <            e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
885 >            e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
886              shouldThrow();
887          } catch (NullPointerException success) {
888          } finally {
# Line 952 | Line 914 | public class ForkJoinPoolTest extends JS
914          try {
915              List<Future<String>> r
916                  = e.invokeAll(new ArrayList<Callable<String>>(),
917 <                              MEDIUM_DELAY_MS, MILLISECONDS);
917 >                              MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
918              assertTrue(r.isEmpty());
919          } finally {
920              joinPool(e);
# Line 968 | Line 930 | public class ForkJoinPoolTest extends JS
930          l.add(new StringTask());
931          l.add(null);
932          try {
933 <            e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
933 >            e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
934              shouldThrow();
935          } catch (NullPointerException success) {
936          } finally {
# Line 984 | Line 946 | public class ForkJoinPoolTest extends JS
946          List<Callable<String>> l = new ArrayList<Callable<String>>();
947          l.add(new NPETask());
948          List<Future<String>> futures
949 <            = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
949 >            = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
950          assertEquals(1, futures.size());
951          try {
952              futures.get(0).get();
# Line 1006 | Line 968 | public class ForkJoinPoolTest extends JS
968              l.add(new StringTask());
969              l.add(new StringTask());
970              List<Future<String>> futures
971 <                = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
971 >                = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
972              assertEquals(2, futures.size());
973              for (Future<String> future : futures)
974                  assertSame(TEST_STRING, future.get());

Diff Legend

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