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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8