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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8