[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.30, Tue Mar 15 19:47:06 2011 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/publicdomain/zero/1.0/
5   * Jeffrey Hayes, Pat Fischer, Mike Judd.   * Other contributors include Andrew Wright, Jeffrey Hayes,
6     * Pat Fisher, Mike Judd.
7   */   */
8    
9    
10  import junit.framework.*;  import junit.framework.*;
11  import java.util.*;  import java.util.*;
12  import java.util.concurrent.*;  import java.util.concurrent.*;
13    import static java.util.concurrent.TimeUnit.MILLISECONDS;
14  import java.math.BigInteger;  import java.math.BigInteger;
15  import java.security.*;  import java.security.*;
16    
# Line 27  Line 29 
29      static class DirectExecutorService extends AbstractExecutorService {      static class DirectExecutorService extends AbstractExecutorService {
30          public void execute(Runnable r) { r.run(); }          public void execute(Runnable r) { r.run(); }
31          public void shutdown() { shutdown = true; }          public void shutdown() { shutdown = true; }
32          public List<Runnable> shutdownNow() { shutdown = true; return Collections.EMPTY_LIST; }          public List<Runnable> shutdownNow() {
33                shutdown = true;
34                return Collections.EMPTY_LIST;
35            }
36          public boolean isShutdown() { return shutdown; }          public boolean isShutdown() { return shutdown; }
37          public boolean isTerminated() { return isShutdown(); }          public boolean isTerminated() { return isShutdown(); }
38          public boolean awaitTermination(long timeout, TimeUnit unit) { return isShutdown(); }          public boolean awaitTermination(long timeout, TimeUnit unit) {
39                return isShutdown();
40            }
41          private volatile boolean shutdown = false;          private volatile boolean shutdown = false;
42      }      }
43    
44      /**      /**
45       * execute of runnable runs it to completion       * execute(runnable) runs it to completion
46       */       */
47      public void testExecuteRunnable() {      public void testExecuteRunnable() throws Exception {
         try {  
48              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
49              TrackedShortRunnable task = new TrackedShortRunnable();              TrackedShortRunnable task = new TrackedShortRunnable();
50              assertFalse(task.done);              assertFalse(task.done);
# Line 46  Line 52 
52              future.get();              future.get();
53              assertTrue(task.done);              assertTrue(task.done);
54          }          }
         catch (ExecutionException ex) {  
             unexpectedException();  
         }  
         catch (InterruptedException ex) {  
             unexpectedException();  
         }  
     }  
55    
56    
57      /**      /**
58       * completed submit of callable returns result       * Completed submit(callable) returns result
59       */       */
60      public void testSubmitCallable() {      public void testSubmitCallable() throws Exception {
         try {  
61              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
62              Future<String> future = e.submit(new StringTask());              Future<String> future = e.submit(new StringTask());
63              String result = future.get();              String result = future.get();
64              assertSame(TEST_STRING, result);              assertSame(TEST_STRING, result);
65          }          }
         catch (ExecutionException ex) {  
             unexpectedException();  
         }  
         catch (InterruptedException ex) {  
             unexpectedException();  
         }  
     }  
66    
67      /**      /**
68       * completed submit of runnable returns successfully       * Completed submit(runnable) returns successfully
69       */       */
70      public void testSubmitRunnable() {      public void testSubmitRunnable() throws Exception {
         try {  
71              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
72              Future<?> future = e.submit(new NoOpRunnable());              Future<?> future = e.submit(new NoOpRunnable());
73              future.get();              future.get();
74              assertTrue(future.isDone());              assertTrue(future.isDone());
75          }          }
         catch (ExecutionException ex) {  
             unexpectedException();  
         }  
         catch (InterruptedException ex) {  
             unexpectedException();  
         }  
     }  
76    
77      /**      /**
78       * completed submit of (runnable, result) returns result       * Completed submit(runnable, result) returns result
79       */       */
80      public void testSubmitRunnable2() {      public void testSubmitRunnable2() throws Exception {
         try {  
81              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
82              Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);              Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
83              String result = future.get();              String result = future.get();
84              assertSame(TEST_STRING, result);              assertSame(TEST_STRING, result);
85          }          }
         catch (ExecutionException ex) {  
             unexpectedException();  
         }  
         catch (InterruptedException ex) {  
             unexpectedException();  
         }  
     }  
86    
87    
88      /**      /**
89       * submit of a privileged action runs it to completion       * A submitted privileged action runs to completion
90       */       */
91      public void testSubmitPrivilegedAction() {      public void testSubmitPrivilegedAction() throws Exception {
92          Policy savedPolicy = Policy.getPolicy();          Runnable r = new CheckedRunnable() {
93          AdjustablePolicy policy = new AdjustablePolicy();              public void realRun() throws Exception {
         policy.addPermission(new RuntimePermission("getContextClassLoader"));  
         policy.addPermission(new RuntimePermission("setContextClassLoader"));  
         Policy.setPolicy(policy);  
         try {  
94              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
95              Future future = e.submit(Executors.callable(new PrivilegedAction() {              Future future = e.submit(Executors.callable(new PrivilegedAction() {
96                      public Object run() {                      public Object run() {
97                          return TEST_STRING;                          return TEST_STRING;
98                      }}));                      }}));
99    
100              Object result = future.get();                  assertSame(TEST_STRING, future.get());
101              assertSame(TEST_STRING, result);              }};
102          }  
103          catch (ExecutionException ex) {          runWithPermissions(r,
104              unexpectedException();                             new RuntimePermission("getClassLoader"),
105          }                             new RuntimePermission("setContextClassLoader"),
106          catch (InterruptedException ex) {                             new RuntimePermission("modifyThread"));
             unexpectedException();  
         }  
         finally {  
             Policy.setPolicy(savedPolicy);  
         }  
107      }      }
108    
109      /**      /**
110       * submit of a privileged exception action runs it to completion       * A submitted privileged exception action runs to completion
111       */       */
112      public void testSubmitPrivilegedExceptionAction() {      public void testSubmitPrivilegedExceptionAction() throws Exception {
113          Policy savedPolicy = Policy.getPolicy();          Runnable r = new CheckedRunnable() {
114          AdjustablePolicy policy = new AdjustablePolicy();              public void realRun() throws Exception {
         policy.addPermission(new RuntimePermission("getContextClassLoader"));  
         policy.addPermission(new RuntimePermission("setContextClassLoader"));  
         Policy.setPolicy(policy);  
         try {  
115              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
116              Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {              Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
117                      public Object run() {                      public Object run() {
118                          return TEST_STRING;                          return TEST_STRING;
119                      }}));                      }}));
120    
121              Object result = future.get();                  assertSame(TEST_STRING, future.get());
122              assertSame(TEST_STRING, result);              }};
123          }  
124          catch (ExecutionException ex) {          runWithPermissions(r);
             unexpectedException();  
         }  
         catch (InterruptedException ex) {  
             unexpectedException();  
         }  
         finally {  
             Policy.setPolicy(savedPolicy);  
         }  
125      }      }
126    
127      /**      /**
128       * submit of a failed privileged exception action reports exception       * A submitted failed privileged exception action reports exception
129       */       */
130      public void testSubmitFailedPrivilegedExceptionAction() {      public void testSubmitFailedPrivilegedExceptionAction() throws Exception {
131          Policy savedPolicy = Policy.getPolicy();          Runnable r = new CheckedRunnable() {
132          AdjustablePolicy policy = new AdjustablePolicy();              public void realRun() throws Exception {
         policy.addPermission(new RuntimePermission("getContextClassLoader"));  
         policy.addPermission(new RuntimePermission("setContextClassLoader"));  
         Policy.setPolicy(policy);  
         try {  
133              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
134              Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {              Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
135                      public Object run() throws Exception {                      public Object run() throws Exception {
136                          throw new IndexOutOfBoundsException();                          throw new IndexOutOfBoundsException();
137                      }}));                      }}));
138    
139              Object result = future.get();                  try {
140                        future.get();
141              shouldThrow();              shouldThrow();
142          }                  } catch (ExecutionException success) {
143          catch (ExecutionException success) {                      assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
144          }                  }}};
145          catch (InterruptedException ex) {  
146              unexpectedException();          runWithPermissions(r);
         }  
         finally {  
             Policy.setPolicy(savedPolicy);  
         }  
147      }      }
148    
149      /**      /**
150       * execute with a null runnable throws NPE       * execute(null runnable) throws NPE
151       */       */
152      public void testExecuteNullRunnable() {      public void testExecuteNullRunnable() {
153          try {          try {
154              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
155              TrackedShortRunnable task = null;              e.submit((Runnable) null);
             Future<?> future = e.submit(task);  
156              shouldThrow();              shouldThrow();
157          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {  
         }  
         catch (Exception ex) {  
             unexpectedException();  
         }  
158      }      }
159    
160    
161      /**      /**
162       * submit of a null callable throws NPE       * submit(null callable) throws NPE
163       */       */
164      public void testSubmitNullCallable() {      public void testSubmitNullCallable() {
165          try {          try {
166              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
167              StringTask t = null;              e.submit((Callable) null);
             Future<String> future = e.submit(t);  
168              shouldThrow();              shouldThrow();
169            } catch (NullPointerException success) {}
170          }          }
171          catch (NullPointerException success) {  
172          }      /**
173          catch (Exception ex) {       * submit(callable).get() throws InterruptedException if interrupted
174              unexpectedException();       */
175        public void testInterruptedSubmit() throws InterruptedException {
176            final CountDownLatch submitted    = new CountDownLatch(1);
177            final CountDownLatch quittingTime = new CountDownLatch(1);
178            final ExecutorService p
179                = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS,
180                                         new ArrayBlockingQueue<Runnable>(10));
181            final Callable<Void> awaiter = new CheckedCallable<Void>() {
182                public Void realCall() throws InterruptedException {
183                    quittingTime.await();
184                    return null;
185                }};
186            try {
187                Thread t = new Thread(new CheckedInterruptedRunnable() {
188                    public void realRun() throws Exception {
189                        Future<Void> future = p.submit(awaiter);
190                        submitted.countDown();
191                        future.get();
192                    }});
193                t.start();
194                submitted.await();
195                t.interrupt();
196                t.join();
197            } finally {
198                quittingTime.countDown();
199                joinPool(p);
200          }          }
201      }      }
202    
203      /**      /**
204       * submit of Runnable throws RejectedExecutionException if       * get of submit(callable) throws ExecutionException if callable
205       * saturated.       * throws exception
206       */       */
207      public void testExecute1() {      public void testSubmitEE() throws InterruptedException {
208          ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));          ThreadPoolExecutor p =
209          try {              new ThreadPoolExecutor(1, 1,
210                                       60, TimeUnit.SECONDS,
211                                       new ArrayBlockingQueue<Runnable>(10));
212    
213              for(int i = 0; i < 5; ++i){          Callable c = new Callable() {
214                  p.submit(new MediumRunnable());              public Object call() { return 5/0; }};
215              }  
216            try {
217                p.submit(c).get();
218              shouldThrow();              shouldThrow();
219          } catch(RejectedExecutionException success){}          } catch (ExecutionException success) {
220                assertTrue(success.getCause() instanceof ArithmeticException);
221            }
222          joinPool(p);          joinPool(p);
223      }      }
224    
225      /**      /**
226       * Completed submit of Callable throws RejectedExecutionException       * invokeAny(null) throws NPE
      *  if saturated.  
227       */       */
228      public void testExecute2() {      public void testInvokeAny1() throws Exception {
229           ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));          ExecutorService e = new DirectExecutorService();
230          try {          try {
231              for(int i = 0; i < 5; ++i) {              e.invokeAny(null);
                 p.submit(new SmallCallable());  
             }  
232              shouldThrow();              shouldThrow();
233          } catch(RejectedExecutionException e){}          } catch (NullPointerException success) {
234          joinPool(p);          } finally {
235                joinPool(e);
236            }
237      }      }
   
238    
239      /**      /**
240       *  blocking on submit of Callable throws InterruptedException if       * invokeAny(empty collection) throws IAE
      *  caller interrupted.  
241       */       */
242      public void testInterruptedSubmit() {      public void testInvokeAny2() throws Exception {
243          final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));          ExecutorService e = new DirectExecutorService();
         Thread t = new Thread(new Runnable() {  
                 public void run() {  
                     try {  
                         p.submit(new Callable<Object>() {  
                                 public Object call() {  
244                                      try {                                      try {
245                                          Thread.sleep(MEDIUM_DELAY_MS);              e.invokeAny(new ArrayList<Callable<String>>());
246                                          shouldThrow();                                          shouldThrow();
247                                      } catch(InterruptedException e){          } catch (IllegalArgumentException success) {
248                                      }          } finally {
249                                      return null;              joinPool(e);
250                                  }                                  }
                             }).get();  
                     } catch(InterruptedException success){  
                     } catch(Exception e) {  
                         unexpectedException();  
251                      }                      }
252    
253                  }      /**
254              });       * invokeAny(c) throws NPE if c has null elements
255         */
256        public void testInvokeAny3() throws Exception {
257            ExecutorService e = new DirectExecutorService();
258            List<Callable<Integer>> l = new ArrayList<Callable<Integer>>();
259            l.add(new Callable<Integer>() {
260                      public Integer call() { return 5/0; }});
261            l.add(null);
262          try {          try {
263              t.start();              e.invokeAny(l);
264              Thread.sleep(SHORT_DELAY_MS);              shouldThrow();
265              t.interrupt();          } catch (NullPointerException success) {
266          } catch(Exception e){          } finally {
267              unexpectedException();              joinPool(e);
268          }          }
         joinPool(p);  
269      }      }
270    
271      /**      /**
272       *  get of submit of Callable throws Exception if callable       * invokeAny(c) throws ExecutionException if no task in c completes
      *  interrupted  
273       */       */
274      public void testSubmitIE() {      public void testInvokeAny4() throws InterruptedException {
275          final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));          ExecutorService e = new DirectExecutorService();
276            List<Callable<String>> l = new ArrayList<Callable<String>>();
277          final Callable c = new Callable() {          l.add(new NPETask());
                 public Object call() {  
278                      try {                      try {
279                          p.submit(new SmallCallable()).get();              e.invokeAny(l);
280                          shouldThrow();                          shouldThrow();
281                      } catch(InterruptedException e){}          } catch (ExecutionException success) {
282                      catch(RejectedExecutionException e2){}              assertTrue(success.getCause() instanceof NullPointerException);
283                      catch(ExecutionException e3){}          } finally {
284                      return Boolean.TRUE;              joinPool(e);
285            }
286                  }                  }
             };  
   
   
287    
288          Thread t = new Thread(new Runnable() {      /**
289                  public void run() {       * invokeAny(c) returns result of some task in c if at least one completes
290         */
291        public void testInvokeAny5() throws Exception {
292            ExecutorService e = new DirectExecutorService();
293                      try {                      try {
294                          c.call();              List<Callable<String>> l = new ArrayList<Callable<String>>();
295                      } catch(Exception e){}              l.add(new StringTask());
296                l.add(new StringTask());
297                String result = e.invokeAny(l);
298                assertSame(TEST_STRING, result);
299            } finally {
300                joinPool(e);
301            }
302                  }                  }
303            });  
304        /**
305         * invokeAll(null) throws NPE
306         */
307        public void testInvokeAll1() throws InterruptedException {
308            ExecutorService e = new DirectExecutorService();
309          try {          try {
310              t.start();              e.invokeAll(null);
311              Thread.sleep(SHORT_DELAY_MS);              shouldThrow();
312              t.interrupt();          } catch (NullPointerException success) {
313              t.join();          } finally {
314          } catch(InterruptedException e){              joinPool(e);
315              unexpectedException();          }
316          }          }
317    
318          joinPool(p);      /**
319         * invokeAll(empty collection) returns empty collection
320         */
321        public void testInvokeAll2() throws InterruptedException {
322            ExecutorService e = new DirectExecutorService();
323            try {
324                List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
325                assertTrue(r.isEmpty());
326            } finally {
327                joinPool(e);
328            }
329      }      }
330    
331      /**      /**
332       *  completed submit of Callable throws ExecutionException if       * invokeAll(c) throws NPE if c has null elements
      *  callable throws exception  
333       */       */
334      public void testSubmitEE() {      public void testInvokeAll3() throws InterruptedException {
335          ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));          ExecutorService e = new DirectExecutorService();
336            List<Callable<String>> l = new ArrayList<Callable<String>>();
337            l.add(new StringTask());
338            l.add(null);
339            try {
340                e.invokeAll(l);
341                shouldThrow();
342            } catch (NullPointerException success) {
343            } finally {
344                joinPool(e);
345            }
346        }
347    
348        /**
349         * get of returned element of invokeAll(c) throws exception on failed task
350         */
351        public void testInvokeAll4() throws Exception {
352            ExecutorService e = new DirectExecutorService();
353          try {          try {
354              Callable c = new Callable() {              List<Callable<String>> l = new ArrayList<Callable<String>>();
355                      public Object call() {              l.add(new NPETask());
356                          int i = 5/0;              List<Future<String>> futures = e.invokeAll(l);
357                          return Boolean.TRUE;              assertEquals(1, futures.size());
358                try {
359                    futures.get(0).get();
360                    shouldThrow();
361                } catch (ExecutionException success) {
362                    assertTrue(success.getCause() instanceof NullPointerException);
363                }
364            } finally {
365                joinPool(e);
366            }
367                      }                      }
                 };  
368    
369              for(int i =0; i < 5; i++){      /**
370                  p.submit(c).get();       * invokeAll(c) returns results of all completed tasks in c
371         */
372        public void testInvokeAll5() throws Exception {
373            ExecutorService e = new DirectExecutorService();
374            try {
375                List<Callable<String>> l = new ArrayList<Callable<String>>();
376                l.add(new StringTask());
377                l.add(new StringTask());
378                List<Future<String>> futures = e.invokeAll(l);
379                assertEquals(2, futures.size());
380                for (Future<String> future : futures)
381                    assertSame(TEST_STRING, future.get());
382            } finally {
383                joinPool(e);
384            }
385              }              }
386    
387    
388        /**
389         * timed invokeAny(null) throws NPE
390         */
391        public void testTimedInvokeAny1() throws Exception {
392            ExecutorService e = new DirectExecutorService();
393            try {
394                e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
395              shouldThrow();              shouldThrow();
396            } catch (NullPointerException success) {
397            } finally {
398                joinPool(e);
399          }          }
         catch(ExecutionException success){  
         } catch(Exception e) {  
             unexpectedException();  
         }  
         joinPool(p);  
400      }      }
401    
402      /**      /**
403       * invokeAny(null) throws NPE       * timed invokeAny(null time unit) throws NPE
404       */       */
405      public void testInvokeAny1() {      public void testTimedInvokeAnyNullTimeUnit() throws Exception {
406          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
407            List<Callable<String>> l = new ArrayList<Callable<String>>();
408            l.add(new StringTask());
409          try {          try {
410              e.invokeAny(null);              e.invokeAny(l, MEDIUM_DELAY_MS, null);
411                shouldThrow();
412          } catch (NullPointerException success) {          } catch (NullPointerException success) {
         } catch(Exception ex) {  
             unexpectedException();  
413          } finally {          } finally {
414              joinPool(e);              joinPool(e);
415          }          }
416      }      }
417    
418      /**      /**
419       * invokeAny(empty collection) throws IAE       * timed invokeAny(empty collection) throws IAE
420       */       */
421      public void testInvokeAny2() {      public void testTimedInvokeAny2() throws Exception {
422          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
423          try {          try {
424              e.invokeAny(new ArrayList<Callable<String>>());              e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
425                shouldThrow();
426          } catch (IllegalArgumentException success) {          } catch (IllegalArgumentException success) {
         } catch(Exception ex) {  
             unexpectedException();  
427          } finally {          } finally {
428              joinPool(e);              joinPool(e);
429          }          }
430      }      }
431    
432      /**      /**
433       * invokeAny(c) throws NPE if c has null elements       * timed invokeAny(c) throws NPE if c has null elements
434       */       */
435      public void testInvokeAny3() {      public void testTimedInvokeAny3() throws Exception {
436          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
437          try {          List<Callable<Integer>> l = new ArrayList<Callable<Integer>>();
438              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();          l.add(new Callable<Integer>() {
439              l.add(new StringTask());                    public Integer call() { return 5/0; }});
440              l.add(null);              l.add(null);
441              e.invokeAny(l);          try {
442                e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
443                shouldThrow();
444          } catch (NullPointerException success) {          } catch (NullPointerException success) {
         } catch(Exception ex) {  
             unexpectedException();  
445          } finally {          } finally {
446              joinPool(e);              joinPool(e);
447          }          }
448      }      }
449    
450      /**      /**
451       * invokeAny(c) throws ExecutionException if no task completes       * timed invokeAny(c) throws ExecutionException if no task completes
452       */       */
453      public void testInvokeAny4() {      public void testTimedInvokeAny4() throws Exception {
454          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
455          try {          List<Callable<String>> l = new ArrayList<Callable<String>>();
             ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();  
456              l.add(new NPETask());              l.add(new NPETask());
457              List<Future<String>> result = e.invokeAll(l);          try {
458              assertEquals(1, result.size());              e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
459              for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)              shouldThrow();
                 it.next().get();  
460          } catch(ExecutionException success) {          } catch(ExecutionException success) {
461          } catch(Exception ex) {              assertTrue(success.getCause() instanceof NullPointerException);
             unexpectedException();  
462          } finally {          } finally {
463              joinPool(e);              joinPool(e);
464          }          }
465      }      }
466    
467      /**      /**
468       * invokeAny(c) returns result of some task       * timed invokeAny(c) returns result of some task in c
469       */       */
470      public void testInvokeAny5() {      public void testTimedInvokeAny5() throws Exception {
471          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
472          try {          try {
473              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();              List<Callable<String>> l = new ArrayList<Callable<String>>();
474              l.add(new StringTask());              l.add(new StringTask());
475              l.add(new StringTask());              l.add(new StringTask());
476              String result = e.invokeAny(l);              String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
477              assertSame(TEST_STRING, result);              assertSame(TEST_STRING, result);
         } catch (ExecutionException success) {  
         } catch(Exception ex) {  
             unexpectedException();  
478          } finally {          } finally {
479              joinPool(e);              joinPool(e);
480          }          }
481      }      }
482    
483      /**      /**
484       * invokeAll(null) throws NPE       * timed invokeAll(null) throws NPE
485       */       */
486      public void testInvokeAll1() {      public void testTimedInvokeAll1() throws InterruptedException {
487          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
488          try {          try {
489              e.invokeAll(null);              e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
490                shouldThrow();
491          } catch (NullPointerException success) {          } catch (NullPointerException success) {
         } catch(Exception ex) {  
             unexpectedException();  
492          } finally {          } finally {
493              joinPool(e);              joinPool(e);
494          }          }
495      }      }
496    
497      /**      /**
498       * invokeAll(empty collection) returns empty collection       * timed invokeAll(null time unit) throws NPE
499       */       */
500      public void testInvokeAll2() {      public void testTimedInvokeAllNullTimeUnit() throws InterruptedException {
501          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
502            List<Callable<String>> l = new ArrayList<Callable<String>>();
503            l.add(new StringTask());
504          try {          try {
505              List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());              e.invokeAll(l, MEDIUM_DELAY_MS, null);
506              assertTrue(r.isEmpty());              shouldThrow();
507          } catch(Exception ex) {          } catch (NullPointerException success) {
             unexpectedException();  
508          } finally {          } finally {
509              joinPool(e);              joinPool(e);
510          }          }
511      }      }
512    
513      /**      /**
514       * invokeAll(c) throws NPE if c has null elements       * timed invokeAll(empty collection) returns empty collection
515       */       */
516      public void testInvokeAll3() {      public void testTimedInvokeAll2() throws InterruptedException {
517          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
518          try {          try {
519              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();              List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
520                assertTrue(r.isEmpty());
521            } finally {
522                joinPool(e);
523            }
524        }
525    
526        /**
527         * timed invokeAll(c) throws NPE if c has null elements
528         */
529        public void testTimedInvokeAll3() throws InterruptedException {
530            ExecutorService e = new DirectExecutorService();
531            List<Callable<String>> l = new ArrayList<Callable<String>>();
532              l.add(new StringTask());              l.add(new StringTask());
533              l.add(null);              l.add(null);
534              e.invokeAll(l);          try {
535                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
536                shouldThrow();
537          } catch (NullPointerException success) {          } catch (NullPointerException success) {
         } catch(Exception ex) {  
             unexpectedException();  
538          } finally {          } finally {
539              joinPool(e);              joinPool(e);
540          }          }
541      }      }
542    
543      /**      /**
544       * get of element of invokeAll(c) throws exception on failed task       * get of returned element of invokeAll(c) throws exception on failed task
545       */       */
546      public void testInvokeAll4() {      public void testTimedInvokeAll4() throws Exception {
547          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
548          try {          try {
549              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();              List<Callable<String>> l = new ArrayList<Callable<String>>();
550              l.add(new NPETask());              l.add(new NPETask());
551              List<Future<String>> result = e.invokeAll(l);              List<Future<String>> futures =
552              assertEquals(1, result.size());                  e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
553              for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)              assertEquals(1, futures.size());
554                  it.next().get();              try {
555                    futures.get(0).get();
556                    shouldThrow();
557          } catch(ExecutionException success) {          } catch(ExecutionException success) {
558          } catch(Exception ex) {                  assertTrue(success.getCause() instanceof NullPointerException);
559              unexpectedException();              }
560          } finally {          } finally {
561              joinPool(e);              joinPool(e);
562          }          }
563      }      }
564    
565      /**      /**
566       * invokeAll(c) returns results of all completed tasks       * timed invokeAll(c) returns results of all completed tasks in c
567       */       */
568      public void testInvokeAll5() {      public void testTimedInvokeAll5() throws Exception {
569          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
570          try {          try {
571              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();              List<Callable<String>> l = new ArrayList<Callable<String>>();
572              l.add(new StringTask());              l.add(new StringTask());
573              l.add(new StringTask());              l.add(new StringTask());
574              List<Future<String>> result = e.invokeAll(l);              List<Future<String>> futures =
575              assertEquals(2, result.size());                  e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
576              for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)              assertEquals(2, futures.size());
577                  assertSame(TEST_STRING, it.next().get());              for (Future<String> future : futures)
578          } catch (ExecutionException success) {                  assertSame(TEST_STRING, future.get());
579          } catch(Exception ex) {          } finally {
580              unexpectedException();              joinPool(e);
581            }
582        }
583    
584        /**
585         * timed invokeAll cancels tasks not completed by timeout
586         */
587        public void testTimedInvokeAll6() throws InterruptedException {
588            ExecutorService e = new DirectExecutorService();
589            try {
590                List<Callable<String>> l = new ArrayList<Callable<String>>();
591                l.add(new StringTask());
592                l.add(Executors.callable(possiblyInterruptedRunnable(2 * SHORT_DELAY_MS), TEST_STRING));
593                l.add(new StringTask());
594                List<Future<String>> futures =
595                    e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
596                assertEquals(3, futures.size());
597                Iterator<Future<String>> it = futures.iterator();
598                Future<String> f1 = it.next();
599                Future<String> f2 = it.next();
600                Future<String> f3 = it.next();
601                assertTrue(f1.isDone());
602                assertFalse(f1.isCancelled());
603                assertTrue(f2.isDone());
604                assertFalse(f2.isCancelled());
605                assertTrue(f3.isDone());
606                assertTrue(f3.isCancelled());
607          } finally {          } finally {
608              joinPool(e);              joinPool(e);
609          }          }

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8