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

Comparing jsr166/src/test/tck/ExecutorsTest.java (file contents):
Revision 1.28 by jsr166, Wed Dec 2 19:17:01 2009 UTC vs.
Revision 1.31 by jsr166, Thu Sep 16 00:52:49 2010 UTC

# Line 16 | Line 16 | import java.security.*;
16  
17   public class ExecutorsTest extends JSR166TestCase {
18      public static void main(String[] args) {
19 <        junit.textui.TestRunner.run (suite());
19 >        junit.textui.TestRunner.run(suite());
20      }
21      public static Test suite() {
22          return new TestSuite(ExecutorsTest.class);
# Line 258 | Line 258 | public class ExecutorsTest extends JSR16
258       */
259      public void testDefaultThreadFactory() throws Exception {
260          final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
261 <        Runnable r = new Runnable() {
262 <                public void run() {
263 <                    try {
264 <                        Thread current = Thread.currentThread();
265 <                        threadAssertTrue(!current.isDaemon());
266 <                        threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
267 <                        ThreadGroup g = current.getThreadGroup();
268 <                        SecurityManager s = System.getSecurityManager();
269 <                        if (s != null)
270 <                            threadAssertTrue(g == s.getThreadGroup());
271 <                        else
272 <                            threadAssertTrue(g == egroup);
273 <                        String name = current.getName();
274 <                        threadAssertTrue(name.endsWith("thread-1"));
275 <                    } catch (SecurityException ok) {
276 <                        // Also pass if not allowed to change setting
277 <                    }
261 >        Runnable r = new CheckedRunnable() {
262 >            public void realRun() {
263 >                try {
264 >                    Thread current = Thread.currentThread();
265 >                    assertTrue(!current.isDaemon());
266 >                    assertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
267 >                    ThreadGroup g = current.getThreadGroup();
268 >                    SecurityManager s = System.getSecurityManager();
269 >                    if (s != null)
270 >                        assertTrue(g == s.getThreadGroup());
271 >                    else
272 >                        assertTrue(g == egroup);
273 >                    String name = current.getName();
274 >                    assertTrue(name.endsWith("thread-1"));
275 >                } catch (SecurityException ok) {
276 >                    // Also pass if not allowed to change setting
277                  }
278 <            };
278 >            }};
279          ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
280  
281          e.execute(r);
# Line 298 | Line 297 | public class ExecutorsTest extends JSR16
297       * access control context and context class loader
298       */
299      public void testPrivilegedThreadFactory() throws Exception {
300 <        Policy savedPolicy = null;
301 <        try {
302 <            savedPolicy = Policy.getPolicy();
303 <            AdjustablePolicy policy = new AdjustablePolicy();
304 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
305 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
306 <            Policy.setPolicy(policy);
308 <        } catch (AccessControlException ok) {
309 <            return;
310 <        }
311 <        final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
312 <        final ClassLoader thisccl = Thread.currentThread().getContextClassLoader();
313 <        final AccessControlContext thisacc = AccessController.getContext();
314 <        Runnable r = new Runnable() {
315 <                public void run() {
316 <                    try {
300 >        Runnable r = new CheckedRunnable() {
301 >            public void realRun() throws Exception {
302 >                final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
303 >                final ClassLoader thisccl = Thread.currentThread().getContextClassLoader();
304 >                final AccessControlContext thisacc = AccessController.getContext();
305 >                Runnable r = new CheckedRunnable() {
306 >                    public void realRun() {
307                          Thread current = Thread.currentThread();
308 <                        threadAssertTrue(!current.isDaemon());
309 <                        threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
308 >                        assertTrue(!current.isDaemon());
309 >                        assertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
310                          ThreadGroup g = current.getThreadGroup();
311                          SecurityManager s = System.getSecurityManager();
312                          if (s != null)
313 <                            threadAssertTrue(g == s.getThreadGroup());
313 >                            assertTrue(g == s.getThreadGroup());
314                          else
315 <                            threadAssertTrue(g == egroup);
315 >                            assertTrue(g == egroup);
316                          String name = current.getName();
317 <                        threadAssertTrue(name.endsWith("thread-1"));
318 <                        threadAssertTrue(thisccl == current.getContextClassLoader());
319 <                        threadAssertTrue(thisacc.equals(AccessController.getContext()));
320 <                    } catch (SecurityException ok) {
321 <                        // Also pass if not allowed to change settings
322 <                    }
323 <                }
324 <            };
325 <        ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
317 >                        assertTrue(name.endsWith("thread-1"));
318 >                        assertSame(thisccl, current.getContextClassLoader());
319 >                        assertEquals(thisacc, AccessController.getContext());
320 >                    }};
321 >                ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
322 >                e.execute(r);
323 >                e.shutdown();
324 >                Thread.sleep(SHORT_DELAY_MS);
325 >                joinPool(e);
326 >            }};
327 >
328 >        runWithPermissions(r,
329 >                           new RuntimePermission("getClassLoader"),
330 >                           new RuntimePermission("setContextClassLoader"),
331 >                           new RuntimePermission("modifyThread"));
332 >    }
333  
334 <        Policy.setPolicy(savedPolicy);
335 <        e.execute(r);
336 <        try {
337 <            e.shutdown();
338 <        } catch (SecurityException ok) {
339 <        }
340 <        try {
341 <            Thread.sleep(SHORT_DELAY_MS);
342 <        } finally {
346 <            joinPool(e);
334 >    boolean haveCCLPermissions() {
335 >        SecurityManager sm = System.getSecurityManager();
336 >        if (sm != null) {
337 >            try {
338 >                sm.checkPermission(new RuntimePermission("setContextClassLoader"));
339 >                sm.checkPermission(new RuntimePermission("getClassLoader"));
340 >            } catch (AccessControlException e) {
341 >                return false;
342 >            }
343          }
344 +        return true;
345      }
346  
347      void checkCCL() {
# Line 368 | Line 365 | public class ExecutorsTest extends JSR16
365       * privilegedCallableUsingCurrentClassLoader throws ACE
366       */
367      public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() {
368 <        Policy savedPolicy = null;
369 <        try {
370 <            savedPolicy = Policy.getPolicy();
371 <            AdjustablePolicy policy = new AdjustablePolicy();
372 <            Policy.setPolicy(policy);
373 <        } catch (AccessControlException ok) {
374 <            return;
375 <        }
376 <
380 <        // Check if program still has too many permissions to run test
381 <        try {
382 <            checkCCL();
383 <            // too many privileges to test; so return
384 <            Policy.setPolicy(savedPolicy);
385 <            return;
386 <        } catch (AccessControlException ok) {
387 <        }
368 >        Runnable r = new CheckedRunnable() {
369 >            public void realRun() throws Exception {
370 >                if (System.getSecurityManager() == null)
371 >                    return;
372 >                try {
373 >                    Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
374 >                    shouldThrow();
375 >                } catch (AccessControlException success) {}
376 >            }};
377  
378 <        try {
390 <            Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
391 <            shouldThrow();
392 <        } catch (AccessControlException success) {
393 <        } finally {
394 <            Policy.setPolicy(savedPolicy);
395 <        }
378 >        runWithoutPermissions(r);
379      }
380  
381      /**
# Line 400 | Line 383 | public class ExecutorsTest extends JSR16
383       * privilegedCallableUsingCurrentClassLoader does not throw ACE
384       */
385      public void testprivilegedCallableUsingCCLWithPrivs() throws Exception {
386 <        Policy savedPolicy = null;
387 <        try {
388 <            savedPolicy = Policy.getPolicy();
389 <            AdjustablePolicy policy = new AdjustablePolicy();
390 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
391 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
392 <            Policy.setPolicy(policy);
393 <        } catch (AccessControlException ok) {
394 <            return;
395 <        }
413 <
414 <        try {
415 <            Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
416 <            task.call();
417 <        }
418 <        finally {
419 <            Policy.setPolicy(savedPolicy);
420 <        }
386 >        Runnable r = new CheckedRunnable() {
387 >            public void realRun() throws Exception {
388 >                Executors.privilegedCallableUsingCurrentClassLoader
389 >                    (new NoOpCallable())
390 >                    .call();
391 >            }};
392 >
393 >        runWithPermissions(r,
394 >                           new RuntimePermission("getClassLoader"),
395 >                           new RuntimePermission("setContextClassLoader"));
396      }
397  
398      /**
399       * Without permissions, calling privilegedCallable throws ACE
400       */
401      public void testprivilegedCallableWithNoPrivs() throws Exception {
402 <        Callable task;
403 <        Policy savedPolicy = null;
404 <        AdjustablePolicy policy = null;
405 <        AccessControlContext noprivAcc = null;
406 <        try {
407 <            savedPolicy = Policy.getPolicy();
408 <            policy = new AdjustablePolicy();
409 <            Policy.setPolicy(policy);
410 <            noprivAcc = AccessController.getContext();
411 <            task = Executors.privilegedCallable(new CheckCCL());
437 <            Policy.setPolicy(savedPolicy);
438 <        } catch (AccessControlException ok) {
439 <            return; // program has too few permissions to set up test
440 <        }
402 >        Runnable r = new CheckedRunnable() {
403 >            public void realRun() throws Exception {
404 >                if (System.getSecurityManager() == null)
405 >                    return;
406 >                Callable task = Executors.privilegedCallable(new CheckCCL());
407 >                try {
408 >                    task.call();
409 >                    shouldThrow();
410 >                } catch (AccessControlException success) {}
411 >            }};
412  
413 <        // Make sure that program doesn't have too many permissions
443 <        try {
444 <            AccessController.doPrivileged(new PrivilegedAction() {
445 <                    public Object run() {
446 <                        checkCCL();
447 <                        return null;
448 <                    }}, noprivAcc);
449 <            // too many permssions; skip test
450 <            return;
451 <        } catch (AccessControlException ok) {
452 <        }
413 >        runWithoutPermissions(r);
414  
415 <        try {
416 <            task.call();
417 <            shouldThrow();
418 <        } catch (AccessControlException success) {}
415 >        // It seems rather difficult to test that the
416 >        // AccessControlContext of the privilegedCallable is used
417 >        // instead of its caller.  Below is a failed attempt to do
418 >        // that, which does not work because the AccessController
419 >        // cannot capture the internal state of the current Policy.
420 >        // It would be much more work to differentiate based on,
421 >        // e.g. CodeSource.
422 >
423 > //         final AccessControlContext[] noprivAcc = new AccessControlContext[1];
424 > //         final Callable[] task = new Callable[1];
425 >
426 > //         runWithPermissions
427 > //             (new CheckedRunnable() {
428 > //                 public void realRun() {
429 > //                     if (System.getSecurityManager() == null)
430 > //                         return;
431 > //                     noprivAcc[0] = AccessController.getContext();
432 > //                     task[0] = Executors.privilegedCallable(new CheckCCL());
433 > //                     try {
434 > //                         AccessController.doPrivileged(new PrivilegedAction<Void>() {
435 > //                                                           public Void run() {
436 > //                                                               checkCCL();
437 > //                                                               return null;
438 > //                                                           }}, noprivAcc[0]);
439 > //                         shouldThrow();
440 > //                     } catch (AccessControlException success) {}
441 > //                 }});
442 >
443 > //         runWithPermissions
444 > //             (new CheckedRunnable() {
445 > //                 public void realRun() throws Exception {
446 > //                     if (System.getSecurityManager() == null)
447 > //                         return;
448 > //                     // Verify that we have an underprivileged ACC
449 > //                     try {
450 > //                         AccessController.doPrivileged(new PrivilegedAction<Void>() {
451 > //                                                           public Void run() {
452 > //                                                               checkCCL();
453 > //                                                               return null;
454 > //                                                           }}, noprivAcc[0]);
455 > //                         shouldThrow();
456 > //                     } catch (AccessControlException success) {}
457 >
458 > //                     try {
459 > //                         task[0].call();
460 > //                         shouldThrow();
461 > //                     } catch (AccessControlException success) {}
462 > //                 }},
463 > //              new RuntimePermission("getClassLoader"),
464 > //              new RuntimePermission("setContextClassLoader"));
465      }
466  
467      /**
468       * With permissions, calling privilegedCallable succeeds
469       */
470      public void testprivilegedCallableWithPrivs() throws Exception {
471 <        Policy savedPolicy = null;
472 <        try {
473 <            savedPolicy = Policy.getPolicy();
474 <            AdjustablePolicy policy = new AdjustablePolicy();
475 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
476 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
477 <            Policy.setPolicy(policy);
478 <        } catch (AccessControlException ok) {
472 <            return;
473 <        }
474 <
475 <        Callable task = Executors.privilegedCallable(new CheckCCL());
476 <        try {
477 <            task.call();
478 <        } finally {
479 <            Policy.setPolicy(savedPolicy);
480 <        }
471 >        Runnable r = new CheckedRunnable() {
472 >            public void realRun() throws Exception {
473 >                Executors.privilegedCallable(new CheckCCL()).call();
474 >            }};
475 >
476 >         runWithPermissions(r,
477 >                           new RuntimePermission("getClassLoader"),
478 >                           new RuntimePermission("setContextClassLoader"));
479      }
480  
481      /**

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines