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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8