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.13 by dl, Mon Jan 19 15:49:02 2004 UTC vs.
Revision 1.17 by dl, Mon Apr 3 15:00:59 2006 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 340 | Line 337 | public class ExecutorsTest extends JSR16
337                      try {
338                          Thread current = Thread.currentThread();
339                          threadAssertTrue(!current.isDaemon());
340 <                        threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
340 >                        threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
341                          ThreadGroup g = current.getThreadGroup();
342                          SecurityManager s = System.getSecurityManager();
343                          if (s != null)
# Line 357 | Line 354 | public class ExecutorsTest extends JSR16
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 373 | 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();
# Line 386 | Line 392 | public class ExecutorsTest extends JSR16
392                      try {
393                          Thread current = Thread.currentThread();
394                          threadAssertTrue(!current.isDaemon());
395 <                        threadAssertTrue(current.getPriority() == Thread.NORM_PRIORITY);
395 >                        threadAssertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
396                          ThreadGroup g = current.getThreadGroup();
397                          SecurityManager s = System.getSecurityManager();
398                          if (s != null)
# Line 400 | Line 406 | public class ExecutorsTest extends JSR16
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 416 | Line 426 | public class ExecutorsTest extends JSR16
426  
427      }
428  
429 <    static class CheckCCL implements Callable<Object> {
429 >    void checkCCL() {
430 >            AccessController.getContext().checkPermission(new RuntimePermission("getContextClassLoader"));
431 >    }
432 >
433 >    class CheckCCL implements Callable<Object> {
434          public Object call() {
435 <            AccessControlContext acc = AccessController.getContext();
422 <            acc.checkPermission(new RuntimePermission("getContextClassLoader"));
435 >            checkCCL();
436              return null;
437          }
438      }
# Line 430 | Line 443 | public class ExecutorsTest extends JSR16
443       * privilegedCallableUsingCurrentClassLoader throws ACE
444       */
445      public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() {
446 <        Policy savedPolicy = Policy.getPolicy();
447 <        AdjustablePolicy policy = new AdjustablePolicy();
448 <        Policy.setPolicy(policy);
446 >        Policy savedPolicy = null;
447 >        try {
448 >            savedPolicy = Policy.getPolicy();
449 >            AdjustablePolicy policy = new AdjustablePolicy();
450 >            Policy.setPolicy(policy);
451 >        } catch (AccessControlException ok) {
452 >            return;
453 >        }
454 >
455 >        // Check if program still has too many permissions to run test
456 >        try {
457 >            checkCCL();
458 >            // too many privileges to test; so return
459 >            Policy.setPolicy(savedPolicy);
460 >            return;
461 >        } catch(AccessControlException ok) {
462 >        }
463 >
464          try {
465              Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
466              shouldThrow();
# Line 446 | Line 474 | public class ExecutorsTest extends JSR16
474      }
475  
476      /**
477 <     * Without class loader permissions, calling
478 <     * privilegedCallableUsingCurrentClassLoader throws ACE
477 >     * With class loader permissions, calling
478 >     * privilegedCallableUsingCurrentClassLoader does not throw ACE
479       */
480      public void testprivilegedCallableUsingCCLWithPrivs() {
481 <        Policy savedPolicy = Policy.getPolicy();
482 <        AdjustablePolicy policy = new AdjustablePolicy();
483 <        policy.addPermission(new RuntimePermission("getContextClassLoader"));
484 <        policy.addPermission(new RuntimePermission("setContextClassLoader"));
485 <        Policy.setPolicy(policy);
481 >        Policy savedPolicy = null;
482 >        try {
483 >            savedPolicy = Policy.getPolicy();
484 >            AdjustablePolicy policy = new AdjustablePolicy();
485 >            policy.addPermission(new RuntimePermission("getContextClassLoader"));
486 >            policy.addPermission(new RuntimePermission("setContextClassLoader"));
487 >            Policy.setPolicy(policy);
488 >        } catch (AccessControlException ok) {
489 >            return;
490 >        }
491 >            
492          try {
493              Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
494              task.call();
# Line 470 | Line 504 | public class ExecutorsTest extends JSR16
504       * Without permissions, calling privilegedCallable throws ACE
505       */
506      public void testprivilegedCallableWithNoPrivs() {
507 <        Policy savedPolicy = Policy.getPolicy();
508 <        AdjustablePolicy policy = new AdjustablePolicy();
509 <        Policy.setPolicy(policy);
510 <        Callable task = Executors.privilegedCallable(new CheckCCL());
511 <        Policy.setPolicy(savedPolicy);
507 >        Callable task;
508 >        Policy savedPolicy = null;
509 >        AdjustablePolicy policy = null;
510 >        AccessControlContext noprivAcc = null;
511 >        try {
512 >            savedPolicy = Policy.getPolicy();
513 >            policy = new AdjustablePolicy();
514 >            Policy.setPolicy(policy);
515 >            noprivAcc = AccessController.getContext();
516 >            task = Executors.privilegedCallable(new CheckCCL());
517 >            Policy.setPolicy(savedPolicy);
518 >        } catch (AccessControlException ok) {
519 >            return; // program has too few permissions to set up test
520 >        }
521 >
522 >        // Make sure that program doesn't have too many permissions
523 >        try {
524 >            AccessController.doPrivileged(new PrivilegedAction() {
525 >                    public Object run() {
526 >                        checkCCL();
527 >                        return null;
528 >                    }}, noprivAcc);
529 >            // too many permssions; skip test
530 >            return;
531 >        } catch(AccessControlException ok) {
532 >        }
533 >
534          try {
535              task.call();
536              shouldThrow();
537          } catch(AccessControlException success) {
538          } catch(Exception ex) {
539              unexpectedException();
540 <        } finally {
485 <        }
540 >        }
541      }
542  
543      /**
544       * With permissions, calling privilegedCallable succeeds
545       */
546      public void testprivilegedCallableWithPrivs() {
547 <        Policy savedPolicy = Policy.getPolicy();
548 <        AdjustablePolicy policy = new AdjustablePolicy();
549 <        policy.addPermission(new RuntimePermission("getContextClassLoader"));
550 <        policy.addPermission(new RuntimePermission("setContextClassLoader"));
551 <        Policy.setPolicy(policy);
547 >        Policy savedPolicy = null;
548 >        try {
549 >            savedPolicy = Policy.getPolicy();
550 >            AdjustablePolicy policy = new AdjustablePolicy();
551 >            policy.addPermission(new RuntimePermission("getContextClassLoader"));
552 >            policy.addPermission(new RuntimePermission("setContextClassLoader"));
553 >            Policy.setPolicy(policy);
554 >        } catch (AccessControlException ok) {
555 >            return;
556 >        }
557 >            
558          Callable task = Executors.privilegedCallable(new CheckCCL());
559          try {
560              task.call();

Diff Legend

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