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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8