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.15 by dl, Thu Jan 22 14:07:50 2004 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 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 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 430 | Line 440 | public class ExecutorsTest extends JSR16
440       * privilegedCallableUsingCurrentClassLoader throws ACE
441       */
442      public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() {
443 <        Policy savedPolicy = Policy.getPolicy();
444 <        AdjustablePolicy policy = new AdjustablePolicy();
445 <        Policy.setPolicy(policy);
443 >        Policy savedPolicy = null;
444 >        try {
445 >            savedPolicy = Policy.getPolicy();
446 >            AdjustablePolicy policy = new AdjustablePolicy();
447 >            Policy.setPolicy(policy);
448 >        } catch (AccessControlException ok) {
449 >            return;
450 >        }
451 >
452          try {
453              Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
454              shouldThrow();
# Line 450 | Line 466 | public class ExecutorsTest extends JSR16
466       * privilegedCallableUsingCurrentClassLoader throws ACE
467       */
468      public void testprivilegedCallableUsingCCLWithPrivs() {
469 <        Policy savedPolicy = Policy.getPolicy();
470 <        AdjustablePolicy policy = new AdjustablePolicy();
471 <        policy.addPermission(new RuntimePermission("getContextClassLoader"));
472 <        policy.addPermission(new RuntimePermission("setContextClassLoader"));
473 <        Policy.setPolicy(policy);
469 >        Policy savedPolicy = null;
470 >        try {
471 >            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              Callable task = Executors.privilegedCallableUsingCurrentClassLoader(new NoOpCallable());
482              task.call();
# Line 466 | Line 488 | public class ExecutorsTest extends JSR16
488          }
489      }
490  
491 +    class CallCCL implements Runnable {
492 +        final Callable task;
493 +        CallCCL(Callable t) { task = t; }
494 +        public void run() {
495 +            try {
496 +                task.call();
497 +                threadShouldThrow();
498 +            } catch(AccessControlException success) {
499 +            } catch(Exception ex) {
500 +                threadUnexpectedException();
501 +            }
502 +        }
503 +    }
504 +
505      /**
506       * Without permissions, calling privilegedCallable throws ACE
507       */
508      public void testprivilegedCallableWithNoPrivs() {
509 <        Policy savedPolicy = Policy.getPolicy();
474 <        AdjustablePolicy policy = new AdjustablePolicy();
475 <        Policy.setPolicy(policy);
476 <        Callable task = Executors.privilegedCallable(new CheckCCL());
477 <        Policy.setPolicy(savedPolicy);
509 >        Thread t1;
510          try {
511 <            task.call();
512 <            shouldThrow();
513 <        } catch(AccessControlException success) {
511 >            Policy savedPolicy = Policy.getPolicy();
512 >            AdjustablePolicy policy = new AdjustablePolicy();
513 >            Policy.setPolicy(policy);
514 >            Callable task = Executors.privilegedCallable(new CheckCCL());
515 >            t1 = new Thread(new CallCCL(task));
516 >            Policy.setPolicy(savedPolicy);
517 >        } catch (AccessControlException ok) {
518 >            return;
519 >        }
520 >
521 >        try {
522 >            t1.start();
523 >            t1.join();
524          } catch(Exception ex) {
525              unexpectedException();
526 <        } finally {
485 <        }
526 >        }
527      }
528  
529      /**
530       * With permissions, calling privilegedCallable succeeds
531       */
532      public void testprivilegedCallableWithPrivs() {
533 <        Policy savedPolicy = Policy.getPolicy();
534 <        AdjustablePolicy policy = new AdjustablePolicy();
535 <        policy.addPermission(new RuntimePermission("getContextClassLoader"));
536 <        policy.addPermission(new RuntimePermission("setContextClassLoader"));
537 <        Policy.setPolicy(policy);
533 >        Policy savedPolicy = null;
534 >        try {
535 >            savedPolicy = Policy.getPolicy();
536 >            AdjustablePolicy policy = new AdjustablePolicy();
537 >            policy.addPermission(new RuntimePermission("getContextClassLoader"));
538 >            policy.addPermission(new RuntimePermission("setContextClassLoader"));
539 >            Policy.setPolicy(policy);
540 >        } catch (AccessControlException ok) {
541 >            return;
542 >        }
543 >            
544          Callable task = Executors.privilegedCallable(new CheckCCL());
545          try {
546              task.call();

Diff Legend

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