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.31 by jsr166, Sat Oct 9 19:46:42 2010 UTC vs.
Revision 1.35 by dl, Fri Nov 19 00:20:47 2010 UTC

# Line 316 | Line 316 | public class ForkJoinPoolTest extends JS
316          try {
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 <            assertEquals(832040, (int) f.get());
321 >            assertEquals(6765, (int) f.get());
322          } finally {
323              p.shutdownNow(); // don't wait out shutdown
324          }
# Line 330 | Line 330 | public class ForkJoinPoolTest extends JS
330      public void testPollSubmission() {
331          SubFJP p = new SubFJP();
332          try {
333 <            ForkJoinTask a = p.submit(new MediumRunnable());
334 <            ForkJoinTask b = p.submit(new MediumRunnable());
335 <            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 347 | Line 347 | public class ForkJoinPoolTest extends JS
347      public void testDrainTasksTo() {
348          SubFJP p = new SubFJP();
349          try {
350 <            ForkJoinTask a = p.submit(new MediumRunnable());
351 <            ForkJoinTask b = p.submit(new MediumRunnable());
352 <            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 371 | Line 371 | public class ForkJoinPoolTest extends JS
371      public void testExecuteRunnable() throws Throwable {
372          ExecutorService e = new ForkJoinPool(1);
373          try {
374 <            TrackedShortRunnable task = new TrackedShortRunnable();
375 <            assertFalse(task.done);
374 >            TrackedRunnable task = trackedRunnable(SHORT_DELAY_MS);
375 >            assertFalse(task.isDone());
376              Future<?> future = e.submit(task);
377 <            future.get();
378 <            assertTrue(task.done);
377 >            assertNull(future.get());
378 >            assertTrue(task.isDone());
379 >            assertFalse(future.isCancelled());
380          } finally {
381              joinPool(e);
382          }
# Line 389 | Line 390 | public class ForkJoinPoolTest extends JS
390          ExecutorService e = new ForkJoinPool(1);
391          try {
392              Future<String> future = e.submit(new StringTask());
393 <            String result = future.get();
394 <            assertSame(TEST_STRING, result);
393 >            assertSame(TEST_STRING, future.get());
394 >            assertTrue(future.isDone());
395 >            assertFalse(future.isCancelled());
396          } finally {
397              joinPool(e);
398          }
# Line 403 | Line 405 | public class ForkJoinPoolTest extends JS
405          ExecutorService e = new ForkJoinPool(1);
406          try {
407              Future<?> future = e.submit(new NoOpRunnable());
408 <            future.get();
408 >            assertNull(future.get());
409              assertTrue(future.isDone());
410 +            assertFalse(future.isCancelled());
411          } finally {
412              joinPool(e);
413          }
# Line 417 | Line 420 | public class ForkJoinPoolTest extends JS
420          ExecutorService e = new ForkJoinPool(1);
421          try {
422              Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
423 <            String result = future.get();
424 <            assertSame(TEST_STRING, result);
423 >            assertSame(TEST_STRING, future.get());
424 >            assertTrue(future.isDone());
425 >            assertFalse(future.isCancelled());
426          } finally {
427              joinPool(e);
428          }
429      }
430  
427 –
431      /**
432 <     * A submitted privileged action to completion
432 >     * A submitted privileged action runs to completion
433       */
434 <    public void testSubmitPrivilegedAction() throws Throwable {
435 <        Policy savedPolicy = null;
436 <        try {
437 <            savedPolicy = Policy.getPolicy();
435 <            AdjustablePolicy policy = new AdjustablePolicy();
436 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
437 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
438 <            Policy.setPolicy(policy);
439 <        } catch (AccessControlException ok) {
440 <            return;
441 <        }
442 <
443 <        try {
444 <            ExecutorService e = new ForkJoinPool(1);
445 <            try {
434 >    public void testSubmitPrivilegedAction() throws Exception {
435 >        Runnable r = new CheckedRunnable() {
436 >            public void realRun() throws Exception {
437 >                ExecutorService e = new ForkJoinPool(1);
438                  Future future = e.submit(Executors.callable(new PrivilegedAction() {
439                      public Object run() {
440                          return TEST_STRING;
441                      }}));
442  
443 <                Object result = future.get();
444 <                assertSame(TEST_STRING, result);
445 <            } finally {
446 <                joinPool(e);
447 <            }
456 <        } finally {
457 <            Policy.setPolicy(savedPolicy);
458 <        }
443 >                assertSame(TEST_STRING, future.get());
444 >            }};
445 >
446 >        runWithPermissions(r,
447 >                           new RuntimePermission("modifyThread"));
448      }
449  
450      /**
451 <     * A submitted a privileged exception action runs to completion
451 >     * A submitted privileged exception action runs to completion
452       */
453 <    public void testSubmitPrivilegedExceptionAction() throws Throwable {
454 <        Policy savedPolicy = null;
455 <        try {
456 <            savedPolicy = Policy.getPolicy();
468 <            AdjustablePolicy policy = new AdjustablePolicy();
469 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
470 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
471 <            Policy.setPolicy(policy);
472 <        } catch (AccessControlException ok) {
473 <            return;
474 <        }
475 <
476 <        try {
477 <            ExecutorService e = new ForkJoinPool(1);
478 <            try {
453 >    public void testSubmitPrivilegedExceptionAction() throws Exception {
454 >        Runnable r = new CheckedRunnable() {
455 >            public void realRun() throws Exception {
456 >                ExecutorService e = new ForkJoinPool(1);
457                  Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
458                      public Object run() {
459                          return TEST_STRING;
460                      }}));
461  
462 <                Object result = future.get();
463 <                assertSame(TEST_STRING, result);
464 <            } finally {
465 <                joinPool(e);
488 <            }
489 <        } finally {
490 <            Policy.setPolicy(savedPolicy);
491 <        }
462 >                assertSame(TEST_STRING, future.get());
463 >            }};
464 >
465 >        runWithPermissions(r, new RuntimePermission("modifyThread"));
466      }
467  
468      /**
469       * A submitted failed privileged exception action reports exception
470       */
471 <    public void testSubmitFailedPrivilegedExceptionAction() throws Throwable {
472 <        Policy savedPolicy = null;
473 <        try {
474 <            savedPolicy = Policy.getPolicy();
501 <            AdjustablePolicy policy = new AdjustablePolicy();
502 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
503 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
504 <            Policy.setPolicy(policy);
505 <        } catch (AccessControlException ok) {
506 <            return;
507 <        }
508 <
509 <        try {
510 <            ExecutorService e = new ForkJoinPool(1);
511 <            try {
471 >    public void testSubmitFailedPrivilegedExceptionAction() throws Exception {
472 >        Runnable r = new CheckedRunnable() {
473 >            public void realRun() throws Exception {
474 >                ExecutorService e = new ForkJoinPool(1);
475                  Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
476                      public Object run() throws Exception {
477                          throw new IndexOutOfBoundsException();
478                      }}));
479  
480 <                Object result = future.get();
481 <                shouldThrow();
482 <            } catch (ExecutionException success) {
483 <                assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
484 <            } finally {
485 <                joinPool(e);
486 <            }
487 <        } finally {
525 <            Policy.setPolicy(savedPolicy);
526 <        }
480 >                try {
481 >                    future.get();
482 >                    shouldThrow();
483 >                } catch (ExecutionException success) {
484 >                    assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
485 >                }}};
486 >
487 >        runWithPermissions(r, new RuntimePermission("modifyThread"));
488      }
489  
490      /**

Diff Legend

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