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.34 by jsr166, Thu Nov 18 19:14:34 2010 UTC vs.
Revision 1.35 by dl, Fri Nov 19 00:20:47 2010 UTC

# Line 428 | Line 428 | public class ForkJoinPoolTest extends JS
428          }
429      }
430  
431 –
431      /**
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();
439 <            AdjustablePolicy policy = new AdjustablePolicy();
440 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
441 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
442 <            Policy.setPolicy(policy);
443 <        } catch (AccessControlException ok) {
444 <            return;
445 <        }
446 <
447 <        try {
448 <            ExecutorService e = new ForkJoinPool(1);
449 <            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 <            }
460 <        } finally {
461 <            Policy.setPolicy(savedPolicy);
462 <        }
443 >                assertSame(TEST_STRING, future.get());
444 >            }};
445 >
446 >        runWithPermissions(r,
447 >                           new RuntimePermission("modifyThread"));
448      }
449  
450      /**
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();
472 <            AdjustablePolicy policy = new AdjustablePolicy();
473 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
474 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
475 <            Policy.setPolicy(policy);
476 <        } catch (AccessControlException ok) {
477 <            return;
478 <        }
479 <
480 <        try {
481 <            ExecutorService e = new ForkJoinPool(1);
482 <            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);
492 <            }
493 <        } finally {
494 <            Policy.setPolicy(savedPolicy);
495 <        }
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();
505 <            AdjustablePolicy policy = new AdjustablePolicy();
506 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
507 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
508 <            Policy.setPolicy(policy);
509 <        } catch (AccessControlException ok) {
510 <            return;
511 <        }
512 <
513 <        try {
514 <            ExecutorService e = new ForkJoinPool(1);
515 <            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 {
529 <            Policy.setPolicy(savedPolicy);
530 <        }
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