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.12 by dl, Sat Dec 27 19:26:43 2003 UTC vs.
Revision 1.19 by jsr166, Tue Aug 4 16:06:12 2009 UTC

# Line 69 | Line 69 | public class ExecutorsTest extends JSR16
69          e.execute(new NoOpRunnable());
70          e.execute(new NoOpRunnable());
71          e.execute(new NoOpRunnable());
72 <        e.shutdown();
72 >        joinPool(e);
73      }
74  
75      /**
# Line 80 | Line 80 | public class ExecutorsTest extends JSR16
80          e.execute(new NoOpRunnable());
81          e.execute(new NoOpRunnable());
82          e.execute(new NoOpRunnable());
83 <        e.shutdown();
83 >        joinPool(e);
84      }
85  
86      /**
# Line 104 | Line 104 | public class ExecutorsTest extends JSR16
104          e.execute(new NoOpRunnable());
105          e.execute(new NoOpRunnable());
106          e.execute(new NoOpRunnable());
107 <        e.shutdown();
107 >        joinPool(e);
108      }
109  
110      /**
# Line 115 | Line 115 | public class ExecutorsTest extends JSR16
115          e.execute(new NoOpRunnable());
116          e.execute(new NoOpRunnable());
117          e.execute(new NoOpRunnable());
118 <        e.shutdown();
118 >        joinPool(e);
119      }
120  
121      /**
# Line 152 | Line 152 | public class ExecutorsTest extends JSR16
152          e.execute(new NoOpRunnable());
153          e.execute(new NoOpRunnable());
154          e.execute(new NoOpRunnable());
155 <        e.shutdown();
155 >        joinPool(e);
156      }
157  
158      /**
# Line 163 | Line 163 | public class ExecutorsTest extends JSR16
163          e.execute(new NoOpRunnable());
164          e.execute(new NoOpRunnable());
165          e.execute(new NoOpRunnable());
166 <        e.shutdown();
166 >        joinPool(e);
167      }
168  
169      /**
# Line 199 | Line 199 | public class ExecutorsTest extends JSR16
199          e.execute(new NoOpRunnable());
200          e.execute(new NoOpRunnable());
201          e.execute(new NoOpRunnable());
202 <        e.shutdown();
202 >        joinPool(e);
203      }
204  
205      /**
# Line 237 | Line 237 | public class ExecutorsTest extends JSR16
237              Thread.sleep(MEDIUM_DELAY_MS);
238              assertTrue(callable.done);
239              assertEquals(Boolean.TRUE, f.get());
240 –            p1.shutdown();
240              joinPool(p1);
241          } catch(RejectedExecutionException e){}
242          catch(Exception e){
# Line 258 | Line 257 | public class ExecutorsTest extends JSR16
257              Thread.sleep(MEDIUM_DELAY_MS);
258              assertTrue(callable.done);
259              assertEquals(Boolean.TRUE, f.get());
261 –            p1.shutdown();
260              joinPool(p1);
261          } catch(RejectedExecutionException e){}
262          catch(Exception e){
# Line 279 | Line 277 | public class ExecutorsTest extends JSR16
277              Thread.sleep(MEDIUM_DELAY_MS);
278              assertTrue(callable.done);
279              assertEquals(Boolean.TRUE, f.get());
282 –            p1.shutdown();
280              joinPool(p1);
281          } catch(RejectedExecutionException e){}
282          catch(Exception e){
# Line 337 | Line 334 | public class ExecutorsTest extends JSR16
334          final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
335          Runnable r = new Runnable() {
336                  public void run() {
337 <                    Thread current = Thread.currentThread();
338 <                    threadAssertTrue(!current.isDaemon());
339 <                    threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
340 <                    ThreadGroup g = current.getThreadGroup();
341 <                    SecurityManager s = System.getSecurityManager();
342 <                    if (s != null)
343 <                        threadAssertTrue(g == s.getThreadGroup());
344 <                    else
345 <                        threadAssertTrue(g == egroup);
346 <                    String name = current.getName();
347 <                    threadAssertTrue(name.endsWith("thread-1"));
337 >                    try {
338 >                        Thread current = Thread.currentThread();
339 >                        threadAssertTrue(!current.isDaemon());
340 >                        threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
341 >                        ThreadGroup g = current.getThreadGroup();
342 >                        SecurityManager s = System.getSecurityManager();
343 >                        if (s != null)
344 >                            threadAssertTrue(g == s.getThreadGroup());
345 >                        else
346 >                            threadAssertTrue(g == egroup);
347 >                        String name = current.getName();
348 >                        threadAssertTrue(name.endsWith("thread-1"));
349 >                    } catch (SecurityException ok) {
350 >                        // Also pass if not allowed to change setting
351 >                    }
352                  }
353              };
354          ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
355          
356          e.execute(r);
357 <        e.shutdown();
357 >        try {
358 >            e.shutdown();
359 >        } catch(SecurityException ok) {
360 >        }
361 >        
362          try {
363              Thread.sleep(SHORT_DELAY_MS);
364          } catch (Exception eX) {
# Line 369 | Line 374 | public class ExecutorsTest extends JSR16
374       * access control context and context class loader
375       */
376      public void testPrivilegedThreadFactory() {
377 <        Policy savedPolicy = Policy.getPolicy();
378 <        AdjustablePolicy policy = new AdjustablePolicy();
379 <        policy.addPermission(new RuntimePermission("getContextClassLoader"));
380 <        policy.addPermission(new RuntimePermission("setContextClassLoader"));
381 <        Policy.setPolicy(policy);
377 >        Policy savedPolicy = null;
378 >        try {
379 >            savedPolicy = Policy.getPolicy();
380 >            AdjustablePolicy policy = new AdjustablePolicy();
381 >            policy.addPermission(new RuntimePermission("getContextClassLoader"));
382 >            policy.addPermission(new RuntimePermission("setContextClassLoader"));
383 >            Policy.setPolicy(policy);
384 >        } catch (AccessControlException ok) {
385 >            return;
386 >        }
387          final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
388          final ClassLoader thisccl = Thread.currentThread().getContextClassLoader();
389          final AccessControlContext thisacc = AccessController.getContext();
390          Runnable r = new Runnable() {
391                  public void run() {
392 <                    Thread current = Thread.currentThread();
393 <                    threadAssertTrue(!current.isDaemon());
394 <                    threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
395 <                    ThreadGroup g = current.getThreadGroup();
396 <                    SecurityManager s = System.getSecurityManager();
397 <                    if (s != null)
398 <                        threadAssertTrue(g == s.getThreadGroup());
399 <                    else
400 <                        threadAssertTrue(g == egroup);
401 <                    String name = current.getName();
402 <                    threadAssertTrue(name.endsWith("thread-1"));
403 <                    threadAssertTrue(thisccl == current.getContextClassLoader());
404 <                    threadAssertTrue(thisacc.equals(AccessController.getContext()));
392 >                    try {
393 >                        Thread current = Thread.currentThread();
394 >                        threadAssertTrue(!current.isDaemon());
395 >                        threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
396 >                        ThreadGroup g = current.getThreadGroup();
397 >                        SecurityManager s = System.getSecurityManager();
398 >                        if (s != null)
399 >                            threadAssertTrue(g == s.getThreadGroup());
400 >                        else
401 >                            threadAssertTrue(g == egroup);
402 >                        String name = current.getName();
403 >                        threadAssertTrue(name.endsWith("thread-1"));
404 >                        threadAssertTrue(thisccl == current.getContextClassLoader());
405 >                        threadAssertTrue(thisacc.equals(AccessController.getContext()));
406 >                    } catch(SecurityException ok) {
407 >                        // Also pass if not allowed to change settings
408 >                    }
409                  }
410              };
411          ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
412          
413          Policy.setPolicy(savedPolicy);
414          e.execute(r);
415 <        e.shutdown();
415 >        try {
416 >            e.shutdown();
417 >        } catch(SecurityException ok) {
418 >        }
419          try {
420              Thread.sleep(SHORT_DELAY_MS);
421          } catch (Exception ex) {
# Line 409 | Line 426 | public class ExecutorsTest extends JSR16
426  
427      }
428  
429 <    static class CheckCCL implements Callable<Object> {
429 >    void checkCCL() {
430 >        SecurityManager sm = System.getSecurityManager();
431 >        if (sm != null) {
432 >            sm.checkPermission(new RuntimePermission("setContextClassLoader"));
433 >            sm.checkPermission(new RuntimePermission("getClassLoader"));
434 >        }
435 >    }
436 >
437 >    class CheckCCL implements Callable<Object> {
438          public Object call() {
439 <            AccessControlContext acc = AccessController.getContext();
415 <            acc.checkPermission(new RuntimePermission("getContextClassLoader"));
439 >            checkCCL();
440              return null;
441          }
442      }
# Line 423 | Line 447 | public class ExecutorsTest extends JSR16
447       * privilegedCallableUsingCurrentClassLoader throws ACE
448       */
449      public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() {
450 <        Policy savedPolicy = Policy.getPolicy();
451 <        AdjustablePolicy policy = new AdjustablePolicy();
452 <        Policy.setPolicy(policy);
450 >        Policy savedPolicy = null;
451 >        try {
452 >            savedPolicy = Policy.getPolicy();
453 >            AdjustablePolicy policy = new AdjustablePolicy();
454 >            Policy.setPolicy(policy);
455 >        } catch (AccessControlException ok) {
456 >            return;
457 >        }
458 >
459 >        // Check if program still has too many permissions to run test
460 >        try {
461 >            checkCCL();
462 >            // too many privileges to test; so return
463 >            Policy.setPolicy(savedPolicy);
464 >            return;
465 >        } catch(AccessControlException ok) {
466 >        }
467 >
468          try {
469              Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
470              shouldThrow();
# Line 439 | Line 478 | public class ExecutorsTest extends JSR16
478      }
479  
480      /**
481 <     * Without class loader permissions, calling
482 <     * privilegedCallableUsingCurrentClassLoader throws ACE
481 >     * With class loader permissions, calling
482 >     * privilegedCallableUsingCurrentClassLoader does not throw ACE
483       */
484      public void testprivilegedCallableUsingCCLWithPrivs() {
485 <        Policy savedPolicy = Policy.getPolicy();
486 <        AdjustablePolicy policy = new AdjustablePolicy();
487 <        policy.addPermission(new RuntimePermission("getContextClassLoader"));
488 <        policy.addPermission(new RuntimePermission("setContextClassLoader"));
489 <        Policy.setPolicy(policy);
485 >        Policy savedPolicy = null;
486 >        try {
487 >            savedPolicy = Policy.getPolicy();
488 >            AdjustablePolicy policy = new AdjustablePolicy();
489 >            policy.addPermission(new RuntimePermission("getContextClassLoader"));
490 >            policy.addPermission(new RuntimePermission("setContextClassLoader"));
491 >            Policy.setPolicy(policy);
492 >        } catch (AccessControlException ok) {
493 >            return;
494 >        }
495 >            
496          try {
497              Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
498              task.call();
# Line 463 | Line 508 | public class ExecutorsTest extends JSR16
508       * Without permissions, calling privilegedCallable throws ACE
509       */
510      public void testprivilegedCallableWithNoPrivs() {
511 <        Policy savedPolicy = Policy.getPolicy();
512 <        AdjustablePolicy policy = new AdjustablePolicy();
513 <        Policy.setPolicy(policy);
514 <        Callable task = Executors.privilegedCallable(new CheckCCL());
515 <        Policy.setPolicy(savedPolicy);
511 >        Callable task;
512 >        Policy savedPolicy = null;
513 >        AdjustablePolicy policy = null;
514 >        AccessControlContext noprivAcc = null;
515 >        try {
516 >            savedPolicy = Policy.getPolicy();
517 >            policy = new AdjustablePolicy();
518 >            Policy.setPolicy(policy);
519 >            noprivAcc = AccessController.getContext();
520 >            task = Executors.privilegedCallable(new CheckCCL());
521 >            Policy.setPolicy(savedPolicy);
522 >        } catch (AccessControlException ok) {
523 >            return; // program has too few permissions to set up test
524 >        }
525 >
526 >        // Make sure that program doesn't have too many permissions
527 >        try {
528 >            AccessController.doPrivileged(new PrivilegedAction() {
529 >                    public Object run() {
530 >                        checkCCL();
531 >                        return null;
532 >                    }}, noprivAcc);
533 >            // too many permssions; skip test
534 >            return;
535 >        } catch(AccessControlException ok) {
536 >        }
537 >
538          try {
539              task.call();
540              shouldThrow();
541          } catch(AccessControlException success) {
542          } catch(Exception ex) {
543              unexpectedException();
544 <        } finally {
478 <        }
544 >        }
545      }
546  
547      /**
548       * With permissions, calling privilegedCallable succeeds
549       */
550      public void testprivilegedCallableWithPrivs() {
551 <        Policy savedPolicy = Policy.getPolicy();
552 <        AdjustablePolicy policy = new AdjustablePolicy();
553 <        policy.addPermission(new RuntimePermission("getContextClassLoader"));
554 <        policy.addPermission(new RuntimePermission("setContextClassLoader"));
555 <        Policy.setPolicy(policy);
551 >        Policy savedPolicy = null;
552 >        try {
553 >            savedPolicy = Policy.getPolicy();
554 >            AdjustablePolicy policy = new AdjustablePolicy();
555 >            policy.addPermission(new RuntimePermission("getContextClassLoader"));
556 >            policy.addPermission(new RuntimePermission("setContextClassLoader"));
557 >            Policy.setPolicy(policy);
558 >        } catch (AccessControlException ok) {
559 >            return;
560 >        }
561 >            
562          Callable task = Executors.privilegedCallable(new CheckCCL());
563          try {
564              task.call();

Diff Legend

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