[cvs] / jsr166 / src / test / tck / AbstractExecutorServiceTest.java Repository:
ViewVC logotype

Diff of /jsr166/src/test/tck/AbstractExecutorServiceTest.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.6, Mon Dec 22 00:48:55 2003 UTC revision 1.15, Tue Jan 20 20:20:56 2004 UTC
# Line 1  Line 1 
1  /*  /*
2   * Written by members of JCP JSR-166 Expert Group and released to the   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * public domain. Use, modify, and redistribute this code in any way   * Expert Group and released to the public domain, as explained at
4   * without acknowledgement. Other contributors include Andrew Wright,   * http://creativecommons.org/licenses/publicdomain
5   * Jeffrey Hayes, Pat Fischer, Mike Judd.   * Other contributors include Andrew Wright, Jeffrey Hayes,
6     * Pat Fisher, Mike Judd.
7   */   */
8    
9    
# Line 35  Line 36 
36      }      }
37    
38      /**      /**
39       * execute of runnable runs it to completion       * execute(runnable) runs it to completion
40       */       */
41      public void testExecuteRunnable() {      public void testExecuteRunnable() {
42          try {          try {
# Line 56  Line 57 
57    
58    
59      /**      /**
60       * completed submit of callable returns result       * Completed submit(callable) returns result
61       */       */
62      public void testSubmitCallable() {      public void testSubmitCallable() {
63          try {          try {
# Line 74  Line 75 
75      }      }
76    
77      /**      /**
78       * completed submit of runnable returns successfully       * Completed submit(runnable) returns successfully
79       */       */
80      public void testSubmitRunnable() {      public void testSubmitRunnable() {
81          try {          try {
# Line 92  Line 93 
93      }      }
94    
95      /**      /**
96       * completed submit of (runnable, result) returns result       * Completed submit(runnable, result) returns result
97       */       */
98      public void testSubmitRunnable2() {      public void testSubmitRunnable2() {
99          try {          try {
# Line 111  Line 112 
112    
113    
114      /**      /**
115       * submit of a privileged action runs it to completion       * A submitted privileged action to completion
116       */       */
117      public void testSubmitPrivilegedAction() {      public void testSubmitPrivilegedAction() {
118          Policy savedPolicy = Policy.getPolicy();          Policy savedPolicy = null;
119            try {
120                savedPolicy = Policy.getPolicy();
121          AdjustablePolicy policy = new AdjustablePolicy();          AdjustablePolicy policy = new AdjustablePolicy();
122          policy.addPermission(new RuntimePermission("getContextClassLoader"));          policy.addPermission(new RuntimePermission("getContextClassLoader"));
123          policy.addPermission(new RuntimePermission("setContextClassLoader"));          policy.addPermission(new RuntimePermission("setContextClassLoader"));
124          Policy.setPolicy(policy);          Policy.setPolicy(policy);
125            } catch(AccessControlException ok) {
126                return;
127            }
128          try {          try {
129              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
130              Future future = e.submit(Executors.callable(new PrivilegedAction() {              Future future = e.submit(Executors.callable(new PrivilegedAction() {
# Line 136  Line 142 
142              unexpectedException();              unexpectedException();
143          }          }
144          finally {          finally {
145                try {
146              Policy.setPolicy(savedPolicy);              Policy.setPolicy(savedPolicy);
147                } catch(AccessControlException ok) {
148                    return;
149                }
150          }          }
151      }      }
152    
153      /**      /**
154       * submit of a privileged exception action runs it to completion       * A submitted a privileged exception action runs to completion
155       */       */
156      public void testSubmitPrivilegedExceptionAction() {      public void testSubmitPrivilegedExceptionAction() {
157          Policy savedPolicy = Policy.getPolicy();          Policy savedPolicy = null;
158            try {
159                savedPolicy = Policy.getPolicy();
160          AdjustablePolicy policy = new AdjustablePolicy();          AdjustablePolicy policy = new AdjustablePolicy();
161          policy.addPermission(new RuntimePermission("getContextClassLoader"));          policy.addPermission(new RuntimePermission("getContextClassLoader"));
162          policy.addPermission(new RuntimePermission("setContextClassLoader"));          policy.addPermission(new RuntimePermission("setContextClassLoader"));
163          Policy.setPolicy(policy);          Policy.setPolicy(policy);
164            } catch(AccessControlException ok) {
165                return;
166            }
167    
168          try {          try {
169              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
170              Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {              Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
# Line 171  Line 187 
187      }      }
188    
189      /**      /**
190       * submit of a failed privileged exception action reports exception       * A submitted failed privileged exception action reports exception
191       */       */
192      public void testSubmitFailedPrivilegedExceptionAction() {      public void testSubmitFailedPrivilegedExceptionAction() {
193          Policy savedPolicy = Policy.getPolicy();          Policy savedPolicy = null;
194            try {
195                savedPolicy = Policy.getPolicy();
196          AdjustablePolicy policy = new AdjustablePolicy();          AdjustablePolicy policy = new AdjustablePolicy();
197          policy.addPermission(new RuntimePermission("getContextClassLoader"));          policy.addPermission(new RuntimePermission("getContextClassLoader"));
198          policy.addPermission(new RuntimePermission("setContextClassLoader"));          policy.addPermission(new RuntimePermission("setContextClassLoader"));
199          Policy.setPolicy(policy);          Policy.setPolicy(policy);
200            } catch(AccessControlException ok) {
201                return;
202            }
203    
204    
205          try {          try {
206              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
207              Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {              Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
# Line 200  Line 223 
223      }      }
224    
225      /**      /**
226       * execute with a null runnable throws NPE       * execute(null runnable) throws NPE
227       */       */
228      public void testExecuteNullRunnable() {      public void testExecuteNullRunnable() {
229          try {          try {
# Line 218  Line 241 
241    
242    
243      /**      /**
244       * submit of a null callable throws NPE       * submit(null callable) throws NPE
245       */       */
246      public void testSubmitNullCallable() {      public void testSubmitNullCallable() {
247          try {          try {
# Line 235  Line 258 
258      }      }
259    
260      /**      /**
261       * submit of Runnable throws RejectedExecutionException if       * submit(runnable) throws RejectedExecutionException if
262       * saturated.       * executor is saturated.
263       */       */
264      public void testExecute1() {      public void testExecute1() {
265          ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));          ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1));
266          try {          try {
267    
268              for(int i = 0; i < 5; ++i){              for(int i = 0; i < 5; ++i){
# Line 251  Line 274 
274      }      }
275    
276      /**      /**
277       * Completed submit of Callable throws RejectedExecutionException       * submit(callable) throws RejectedExecutionException
278       *  if saturated.       * if executor is saturated.
279       */       */
280      public void testExecute2() {      public void testExecute2() {
281           ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));           ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1));
282          try {          try {
283              for(int i = 0; i < 5; ++i) {              for(int i = 0; i < 5; ++i) {
284                  p.submit(new SmallCallable());                  p.submit(new SmallCallable());
# Line 267  Line 290 
290    
291    
292      /**      /**
293       *  blocking on submit of Callable throws InterruptedException if       *  Blocking on submit(callable) throws InterruptedException if
294       *  caller interrupted.       *  caller interrupted.
295       */       */
296      public void testInterruptedSubmit() {      public void testInterruptedSubmit() {
297          final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));          final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
298          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new Runnable() {
299                  public void run() {                  public void run() {
300                      try {                      try {
# Line 303  Line 326 
326      }      }
327    
328      /**      /**
329       *  get of submit of Callable throws Exception if callable       *  get of submitted callable throws Exception if callable
330       *  interrupted       *  interrupted
331       */       */
332      public void testSubmitIE() {      public void testSubmitIE() {
333          final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));          final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
334    
335          final Callable c = new Callable() {          final Callable c = new Callable() {
336                  public Object call() {                  public Object call() {
# Line 343  Line 366 
366      }      }
367    
368      /**      /**
369       *  completed submit of Callable throws ExecutionException if       *  get of submit(callable) throws ExecutionException if callable
370       *  callable throws exception       *  throws exception
371       */       */
372      public void testSubmitEE() {      public void testSubmitEE() {
373          ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));          ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
374    
375          try {          try {
376              Callable c = new Callable() {              Callable c = new Callable() {
# Line 412  Line 435 
435              e.invokeAny(l);              e.invokeAny(l);
436          } catch (NullPointerException success) {          } catch (NullPointerException success) {
437          } catch(Exception ex) {          } catch(Exception ex) {
438                ex.printStackTrace();
439              unexpectedException();              unexpectedException();
440          } finally {          } finally {
441              joinPool(e);              joinPool(e);
# Line 419  Line 443 
443      }      }
444    
445      /**      /**
446       * invokeAny(c) throws ExecutionException if no task completes       * invokeAny(c) throws ExecutionException if no task in c completes
447       */       */
448      public void testInvokeAny4() {      public void testInvokeAny4() {
449          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
450          try {          try {
451              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
452              l.add(new NPETask());              l.add(new NPETask());
453              List<Future<String>> result = e.invokeAll(l);              e.invokeAny(l);
             assertEquals(1, result.size());  
             for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)  
                 it.next().get();  
454          } catch(ExecutionException success) {          } catch(ExecutionException success) {
455          } catch(Exception ex) {          } catch(Exception ex) {
456              unexpectedException();              unexpectedException();
# Line 439  Line 460 
460      }      }
461    
462      /**      /**
463       * invokeAny(c) returns result of some task       * invokeAny(c) returns result of some task in c if at least one completes
464       */       */
465      public void testInvokeAny5() {      public void testInvokeAny5() {
466          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
# Line 506  Line 527 
527      }      }
528    
529      /**      /**
530       * get of element of invokeAll(c) throws exception on failed task       * get of returned element of invokeAll(c) throws exception on failed task
531       */       */
532      public void testInvokeAll4() {      public void testInvokeAll4() {
533          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
# Line 526  Line 547 
547      }      }
548    
549      /**      /**
550       * invokeAll(c) returns results of all completed tasks       * invokeAll(c) returns results of all completed tasks in c
551       */       */
552      public void testInvokeAll5() {      public void testInvokeAll5() {
553          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
# Line 546  Line 567 
567          }          }
568      }      }
569    
570    
571        /**
572         * timed invokeAny(null) throws NPE
573         */
574        public void testTimedInvokeAny1() {
575            ExecutorService e = new DirectExecutorService();
576            try {
577                e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
578            } catch (NullPointerException success) {
579            } catch(Exception ex) {
580                unexpectedException();
581            } finally {
582                joinPool(e);
583            }
584        }
585    
586        /**
587         * timed invokeAny(null time unit) throws NPE
588         */
589        public void testTimedInvokeAnyNullTimeUnit() {
590            ExecutorService e = new DirectExecutorService();
591            try {
592                ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
593                l.add(new StringTask());
594                e.invokeAny(l, MEDIUM_DELAY_MS, null);
595            } catch (NullPointerException success) {
596            } catch(Exception ex) {
597                unexpectedException();
598            } finally {
599                joinPool(e);
600            }
601        }
602    
603        /**
604         * timed invokeAny(empty collection) throws IAE
605         */
606        public void testTimedInvokeAny2() {
607            ExecutorService e = new DirectExecutorService();
608            try {
609                e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
610            } catch (IllegalArgumentException success) {
611            } catch(Exception ex) {
612                unexpectedException();
613            } finally {
614                joinPool(e);
615            }
616        }
617    
618        /**
619         * timed invokeAny(c) throws NPE if c has null elements
620         */
621        public void testTimedInvokeAny3() {
622            ExecutorService e = new DirectExecutorService();
623            try {
624                ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
625                l.add(new StringTask());
626                l.add(null);
627                e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
628            } catch (NullPointerException success) {
629            } catch(Exception ex) {
630                ex.printStackTrace();
631                unexpectedException();
632            } finally {
633                joinPool(e);
634            }
635        }
636    
637        /**
638         * timed invokeAny(c) throws ExecutionException if no task completes
639         */
640        public void testTimedInvokeAny4() {
641            ExecutorService e = new DirectExecutorService();
642            try {
643                ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
644                l.add(new NPETask());
645                e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
646            } catch(ExecutionException success) {
647            } catch(Exception ex) {
648                unexpectedException();
649            } finally {
650                joinPool(e);
651            }
652        }
653    
654        /**
655         * timed invokeAny(c) returns result of some task in c
656         */
657        public void testTimedInvokeAny5() {
658            ExecutorService e = new DirectExecutorService();
659            try {
660                ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
661                l.add(new StringTask());
662                l.add(new StringTask());
663                String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
664                assertSame(TEST_STRING, result);
665            } catch (ExecutionException success) {
666            } catch(Exception ex) {
667                unexpectedException();
668            } finally {
669                joinPool(e);
670            }
671        }
672    
673        /**
674         * timed invokeAll(null) throws NPE
675         */
676        public void testTimedInvokeAll1() {
677            ExecutorService e = new DirectExecutorService();
678            try {
679                e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
680            } catch (NullPointerException success) {
681            } catch(Exception ex) {
682                unexpectedException();
683            } finally {
684                joinPool(e);
685            }
686        }
687    
688        /**
689         * timed invokeAll(null time unit) throws NPE
690         */
691        public void testTimedInvokeAllNullTimeUnit() {
692            ExecutorService e = new DirectExecutorService();
693            try {
694                ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
695                l.add(new StringTask());
696                e.invokeAll(l, MEDIUM_DELAY_MS, null);
697            } catch (NullPointerException success) {
698            } catch(Exception ex) {
699                unexpectedException();
700            } finally {
701                joinPool(e);
702            }
703        }
704    
705        /**
706         * timed invokeAll(empty collection) returns empty collection
707         */
708        public void testTimedInvokeAll2() {
709            ExecutorService e = new DirectExecutorService();
710            try {
711                List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
712                assertTrue(r.isEmpty());
713            } catch(Exception ex) {
714                unexpectedException();
715            } finally {
716                joinPool(e);
717            }
718        }
719    
720        /**
721         * timed invokeAll(c) throws NPE if c has null elements
722         */
723        public void testTimedInvokeAll3() {
724            ExecutorService e = new DirectExecutorService();
725            try {
726                ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
727                l.add(new StringTask());
728                l.add(null);
729                e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
730            } catch (NullPointerException success) {
731            } catch(Exception ex) {
732                unexpectedException();
733            } finally {
734                joinPool(e);
735            }
736        }
737    
738        /**
739         * get of returned element of invokeAll(c) throws exception on failed task
740         */
741        public void testTimedInvokeAll4() {
742            ExecutorService e = new DirectExecutorService();
743            try {
744                ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
745                l.add(new NPETask());
746                List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
747                assertEquals(1, result.size());
748                for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
749                    it.next().get();
750            } catch(ExecutionException success) {
751            } catch(Exception ex) {
752                unexpectedException();
753            } finally {
754                joinPool(e);
755            }
756        }
757    
758        /**
759         * timed invokeAll(c) returns results of all completed tasks in c
760         */
761        public void testTimedInvokeAll5() {
762            ExecutorService e = new DirectExecutorService();
763            try {
764                ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
765                l.add(new StringTask());
766                l.add(new StringTask());
767                List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
768                assertEquals(2, result.size());
769                for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
770                    assertSame(TEST_STRING, it.next().get());
771            } catch (ExecutionException success) {
772            } catch(Exception ex) {
773                unexpectedException();
774            } finally {
775                joinPool(e);
776            }
777        }
778    
779        /**
780         * timed invokeAll cancels tasks not completed by timeout
781         */
782        public void testTimedInvokeAll6() {
783            ExecutorService e = new DirectExecutorService();
784            try {
785                ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
786                l.add(new StringTask());
787                l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
788                l.add(new StringTask());
789                List<Future<String>> result = e.invokeAll(l, SMALL_DELAY_MS, TimeUnit.MILLISECONDS);
790                assertEquals(3, result.size());
791                Iterator<Future<String>> it = result.iterator();
792                Future<String> f1 = it.next();
793                Future<String> f2 = it.next();
794                Future<String> f3 = it.next();
795                assertTrue(f1.isDone());
796                assertFalse(f1.isCancelled());
797                assertTrue(f2.isDone());
798                assertTrue(f3.isDone());
799                assertTrue(f3.isCancelled());
800            } catch(Exception ex) {
801                unexpectedException();
802            } finally {
803                joinPool(e);
804            }
805        }
806    
807  }  }

Legend:
Removed from v.1.6  
changed lines
  Added in v.1.15

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8