[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.18, Mon Nov 16 05:30:07 2009 UTC revision 1.19, Fri Nov 20 05:25:10 2009 UTC
# Line 38  Line 38 
38      /**      /**
39       * execute(runnable) runs it to completion       * execute(runnable) runs it to completion
40       */       */
41      public void testExecuteRunnable() {      public void testExecuteRunnable() throws Exception {
         try {  
42              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
43              TrackedShortRunnable task = new TrackedShortRunnable();              TrackedShortRunnable task = new TrackedShortRunnable();
44              assertFalse(task.done);              assertFalse(task.done);
# Line 47  Line 46 
46              future.get();              future.get();
47              assertTrue(task.done);              assertTrue(task.done);
48          }          }
         catch (ExecutionException ex) {  
             unexpectedException();  
         }  
         catch (InterruptedException ex) {  
             unexpectedException();  
         }  
     }  
49    
50    
51      /**      /**
52       * Completed submit(callable) returns result       * Completed submit(callable) returns result
53       */       */
54      public void testSubmitCallable() {      public void testSubmitCallable() throws Exception {
         try {  
55              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
56              Future<String> future = e.submit(new StringTask());              Future<String> future = e.submit(new StringTask());
57              String result = future.get();              String result = future.get();
58              assertSame(TEST_STRING, result);              assertSame(TEST_STRING, result);
59          }          }
         catch (ExecutionException ex) {  
             unexpectedException();  
         }  
         catch (InterruptedException ex) {  
             unexpectedException();  
         }  
     }  
60    
61      /**      /**
62       * Completed submit(runnable) returns successfully       * Completed submit(runnable) returns successfully
63       */       */
64      public void testSubmitRunnable() {      public void testSubmitRunnable() throws Exception {
         try {  
65              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
66              Future<?> future = e.submit(new NoOpRunnable());              Future<?> future = e.submit(new NoOpRunnable());
67              future.get();              future.get();
68              assertTrue(future.isDone());              assertTrue(future.isDone());
69          }          }
         catch (ExecutionException ex) {  
             unexpectedException();  
         }  
         catch (InterruptedException ex) {  
             unexpectedException();  
         }  
     }  
70    
71      /**      /**
72       * Completed submit(runnable, result) returns result       * Completed submit(runnable, result) returns result
73       */       */
74      public void testSubmitRunnable2() {      public void testSubmitRunnable2() throws Exception {
         try {  
75              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
76              Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);              Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
77              String result = future.get();              String result = future.get();
78              assertSame(TEST_STRING, result);              assertSame(TEST_STRING, result);
79          }          }
         catch (ExecutionException ex) {  
             unexpectedException();  
         }  
         catch (InterruptedException ex) {  
             unexpectedException();  
         }  
     }  
80    
81    
82      /**      /**
83       * A submitted privileged action to completion       * A submitted privileged action to completion
84       */       */
85      public void testSubmitPrivilegedAction() {      public void testSubmitPrivilegedAction() throws Exception {
86          Policy savedPolicy = null;          Policy savedPolicy = null;
87          try {          try {
88              savedPolicy = Policy.getPolicy();              savedPolicy = Policy.getPolicy();
# Line 135  Line 103 
103              Object result = future.get();              Object result = future.get();
104              assertSame(TEST_STRING, result);              assertSame(TEST_STRING, result);
105          }          }
         catch (ExecutionException ex) {  
             unexpectedException();  
         }  
         catch (InterruptedException ex) {  
             unexpectedException();  
         }  
106          finally {          finally {
107              try {              try {
108                  Policy.setPolicy(savedPolicy);                  Policy.setPolicy(savedPolicy);
# Line 153  Line 115 
115      /**      /**
116       * A submitted a privileged exception action runs to completion       * A submitted a privileged exception action runs to completion
117       */       */
118      public void testSubmitPrivilegedExceptionAction() {      public void testSubmitPrivilegedExceptionAction() throws Exception {
119          Policy savedPolicy = null;          Policy savedPolicy = null;
120          try {          try {
121              savedPolicy = Policy.getPolicy();              savedPolicy = Policy.getPolicy();
# Line 175  Line 137 
137              Object result = future.get();              Object result = future.get();
138              assertSame(TEST_STRING, result);              assertSame(TEST_STRING, result);
139          }          }
         catch (ExecutionException ex) {  
             unexpectedException();  
         }  
         catch (InterruptedException ex) {  
             unexpectedException();  
         }  
140          finally {          finally {
141              Policy.setPolicy(savedPolicy);              Policy.setPolicy(savedPolicy);
142          }          }
# Line 189  Line 145 
145      /**      /**
146       * A submitted 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 = null;          Policy savedPolicy = null;
150          try {          try {
151              savedPolicy = Policy.getPolicy();              savedPolicy = Policy.getPolicy();
# Line 201  Line 157 
157              return;              return;
158          }          }
159    
   
160          try {          try {
161              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
162              Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {              Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
# Line 209  Line 164 
164                          throw new IndexOutOfBoundsException();                          throw new IndexOutOfBoundsException();
165                      }}));                      }}));
166    
167              Object result = future.get();              future.get();
168              shouldThrow();              shouldThrow();
169          }          } catch (ExecutionException success) {
170          catch (ExecutionException success) {              assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
         }  
         catch (InterruptedException ex) {  
             unexpectedException();  
171          }          }
172          finally {          finally {
173              Policy.setPolicy(savedPolicy);              Policy.setPolicy(savedPolicy);
# Line 228  Line 180 
180      public void testExecuteNullRunnable() {      public void testExecuteNullRunnable() {
181          try {          try {
182              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
183              TrackedShortRunnable task = null;              e.submit((Runnable) null);
             Future<?> future = e.submit(task);  
184              shouldThrow();              shouldThrow();
185          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {  
         }  
         catch (Exception ex) {  
             unexpectedException();  
         }  
186      }      }
187    
188    
# Line 246  Line 192 
192      public void testSubmitNullCallable() {      public void testSubmitNullCallable() {
193          try {          try {
194              ExecutorService e = new DirectExecutorService();              ExecutorService e = new DirectExecutorService();
195              StringTask t = null;              e.submit((Callable) null);
             Future<String> future = e.submit(t);  
196              shouldThrow();              shouldThrow();
197          }          } catch (NullPointerException success) {}
         catch (NullPointerException success) {  
         }  
         catch (Exception ex) {  
             unexpectedException();  
         }  
198      }      }
199    
200      /**      /**
# Line 262  Line 202 
202       * executor is saturated.       * executor is saturated.
203       */       */
204      public void testExecute1() {      public void testExecute1() {
205          ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1));          ThreadPoolExecutor p =
206                new ThreadPoolExecutor(1, 1,
207                                       60, TimeUnit.SECONDS,
208                                       new ArrayBlockingQueue<Runnable>(1));
209            try {
210                for (int i = 0; i < 2; ++i)
211                    p.submit(new MediumRunnable());
212                for (int i = 0; i < 2; ++i) {
213          try {          try {
   
             for (int i = 0; i < 5; ++i) {  
214                  p.submit(new MediumRunnable());                  p.submit(new MediumRunnable());
             }  
215              shouldThrow();              shouldThrow();
216          } catch (RejectedExecutionException success) {}          } catch (RejectedExecutionException success) {}
217                }
218            } finally {
219          joinPool(p);          joinPool(p);
220      }      }
221        }
222    
223      /**      /**
224       * submit(callable) throws RejectedExecutionException       * submit(callable) throws RejectedExecutionException
225       * if executor is saturated.       * if executor is saturated.
226       */       */
227      public void testExecute2() {      public void testExecute2() {
228           ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1));          ThreadPoolExecutor p =
229                new ThreadPoolExecutor(1, 1,
230                                       60, TimeUnit.SECONDS,
231                                       new ArrayBlockingQueue<Runnable>(1));
232            try {
233                for (int i = 0; i < 2; ++i)
234                    p.submit(new MediumRunnable());
235                for (int i = 0; i < 2; ++i) {
236          try {          try {
             for (int i = 0; i < 5; ++i) {  
237                  p.submit(new SmallCallable());                  p.submit(new SmallCallable());
             }  
238              shouldThrow();              shouldThrow();
239          } catch (RejectedExecutionException e) {}                  } catch (RejectedExecutionException success) {}
240                }
241            } finally {
242          joinPool(p);          joinPool(p);
243      }      }
244        }
245    
246    
247      /**      /**
248       *  Blocking on submit(callable) throws InterruptedException if       *  Blocking on submit(callable) throws InterruptedException if
249       *  caller interrupted.       *  caller interrupted.
250       */       */
251      public void testInterruptedSubmit() {      public void testInterruptedSubmit() throws InterruptedException {
252          final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));          final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
253          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedInterruptedRunnable() {
254                  public void run() {              public void realRun() throws Exception {
255                      try {                  p.submit(new CheckedCallable<Object>() {
256                          p.submit(new Callable<Object>() {                               public Object realCall()
257                                  public Object call() {                                   throws InterruptedException {
258                                      try {                                   Thread.sleep(SMALL_DELAY_MS);
                                         Thread.sleep(MEDIUM_DELAY_MS);  
                                         shouldThrow();  
                                     } catch (InterruptedException e) {  
                                     }  
259                                      return null;                                      return null;
260                                  }                               }}).get();
261                              }).get();              }});
                     } catch (InterruptedException success) {  
                     } catch (Exception e) {  
                         unexpectedException();  
                     }  
262    
                 }  
             });  
         try {  
263              t.start();              t.start();
264              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
265              t.interrupt();              t.interrupt();
         } catch (Exception e) {  
             unexpectedException();  
         }  
266          joinPool(p);          joinPool(p);
267      }      }
268    
269      /**      /**
270       *  get of submitted callable throws Exception if callable       *  get of submitted callable throws InterruptedException if callable
271       *  interrupted       *  interrupted
272       */       */
273      public void testSubmitIE() {      public void testSubmitIE() throws InterruptedException {
274          final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));          final ThreadPoolExecutor p =
275                new ThreadPoolExecutor(1, 1,
276                                       60, TimeUnit.SECONDS,
277                                       new ArrayBlockingQueue<Runnable>(10));
278    
279          final Callable c = new Callable() {          Thread t = new Thread(new CheckedInterruptedRunnable() {
280                  public Object call() {              public void realRun() throws Exception {
                     try {  
281                          p.submit(new SmallCallable()).get();                          p.submit(new SmallCallable()).get();
282                          shouldThrow();              }});
                     } catch (InterruptedException e) {}  
                     catch (RejectedExecutionException e2) {}  
                     catch (ExecutionException e3) {}  
                     return Boolean.TRUE;  
                 }  
             };  
283    
   
   
         Thread t = new Thread(new Runnable() {  
                 public void run() {  
                     try {  
                         c.call();  
                     } catch (Exception e) {}  
                 }  
           });  
         try {  
284              t.start();              t.start();
285              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
286              t.interrupt();              t.interrupt();
287              t.join();              t.join();
         } catch (InterruptedException e) {  
             unexpectedException();  
         }  
   
288          joinPool(p);          joinPool(p);
289      }      }
290    
# Line 369  Line 292 
292       *  get of submit(callable) throws ExecutionException if callable       *  get of submit(callable) throws ExecutionException if callable
293       *  throws exception       *  throws exception
294       */       */
295      public void testSubmitEE() {      public void testSubmitEE() throws InterruptedException {
296          ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));          ThreadPoolExecutor p =
297                new ThreadPoolExecutor(1, 1,
298                                       60, TimeUnit.SECONDS,
299                                       new ArrayBlockingQueue<Runnable>(10));
300    
         try {  
301              Callable c = new Callable() {              Callable c = new Callable() {
302                      public Object call() {              public Object call() { return 5/0; }};
                         int i = 5/0;  
                         return Boolean.TRUE;  
                     }  
                 };  
303    
304              for (int i =0; i < 5; i++) {          try {
305                  p.submit(c).get();                  p.submit(c).get();
             }  
   
306              shouldThrow();              shouldThrow();
307          }          } catch (ExecutionException success) {
308          catch (ExecutionException success) {              assertTrue(success.getCause() instanceof ArithmeticException);
         } catch (Exception e) {  
             unexpectedException();  
309          }          }
310          joinPool(p);          joinPool(p);
311      }      }
# Line 396  Line 313 
313      /**      /**
314       * invokeAny(null) throws NPE       * invokeAny(null) throws NPE
315       */       */
316      public void testInvokeAny1() {      public void testInvokeAny1()
317            throws InterruptedException, ExecutionException {
318          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
319          try {          try {
320              e.invokeAny(null);              e.invokeAny(null);
321                shouldThrow();
322          } catch (NullPointerException success) {          } catch (NullPointerException success) {
         } catch (Exception ex) {  
             unexpectedException();  
323          } finally {          } finally {
324              joinPool(e);              joinPool(e);
325          }          }
# Line 411  Line 328 
328      /**      /**
329       * invokeAny(empty collection) throws IAE       * invokeAny(empty collection) throws IAE
330       */       */
331      public void testInvokeAny2() {      public void testInvokeAny2()
332            throws InterruptedException, ExecutionException {
333          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
334          try {          try {
335              e.invokeAny(new ArrayList<Callable<String>>());              e.invokeAny(new ArrayList<Callable<String>>());
336                shouldThrow();
337          } catch (IllegalArgumentException success) {          } catch (IllegalArgumentException success) {
         } catch (Exception ex) {  
             unexpectedException();  
338          } finally {          } finally {
339              joinPool(e);              joinPool(e);
340          }          }
# Line 426  Line 343 
343      /**      /**
344       * invokeAny(c) throws NPE if c has null elements       * invokeAny(c) throws NPE if c has null elements
345       */       */
346      public void testInvokeAny3() {      public void testInvokeAny3() throws Exception {
347            final CountDownLatch latch = new CountDownLatch(1);
348          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
349          try {          try {
350              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();              ArrayList<Callable<Integer>> l
351              l.add(new StringTask());                  = new ArrayList<Callable<Integer>>();
352                l.add(new Callable<Integer>() {
353                          public Integer call() { return 5/0; }});
354              l.add(null);              l.add(null);
355              e.invokeAny(l);              e.invokeAny(l);
356                shouldThrow();
357          } catch (NullPointerException success) {          } catch (NullPointerException success) {
         } catch (Exception ex) {  
             ex.printStackTrace();  
             unexpectedException();  
358          } finally {          } finally {
359                latch.countDown();
360              joinPool(e);              joinPool(e);
361          }          }
362      }      }
# Line 445  Line 364 
364      /**      /**
365       * invokeAny(c) throws ExecutionException if no task in c completes       * invokeAny(c) throws ExecutionException if no task in c completes
366       */       */
367      public void testInvokeAny4() {      public void testInvokeAny4() throws InterruptedException {
368          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
369          try {          try {
370              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
371              l.add(new NPETask());              l.add(new NPETask());
372              e.invokeAny(l);              e.invokeAny(l);
373                shouldThrow();
374          } catch (ExecutionException success) {          } catch (ExecutionException success) {
375          } catch (Exception ex) {              assertTrue(success.getCause() instanceof NullPointerException);
             unexpectedException();  
376          } finally {          } finally {
377              joinPool(e);              joinPool(e);
378          }          }
# Line 462  Line 381 
381      /**      /**
382       * invokeAny(c) returns result of some task in c if at least one completes       * invokeAny(c) returns result of some task in c if at least one completes
383       */       */
384      public void testInvokeAny5() {      public void testInvokeAny5() throws Exception {
385          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
386          try {          try {
387              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
# Line 470  Line 389 
389              l.add(new StringTask());              l.add(new StringTask());
390              String result = e.invokeAny(l);              String result = e.invokeAny(l);
391              assertSame(TEST_STRING, result);              assertSame(TEST_STRING, result);
         } catch (ExecutionException success) {  
         } catch (Exception ex) {  
             unexpectedException();  
392          } finally {          } finally {
393              joinPool(e);              joinPool(e);
394          }          }
# Line 481  Line 397 
397      /**      /**
398       * invokeAll(null) throws NPE       * invokeAll(null) throws NPE
399       */       */
400      public void testInvokeAll1() {      public void testInvokeAll1() throws InterruptedException {
401          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
402          try {          try {
403              e.invokeAll(null);              e.invokeAll(null);
404                shouldThrow();
405          } catch (NullPointerException success) {          } catch (NullPointerException success) {
         } catch (Exception ex) {  
             unexpectedException();  
406          } finally {          } finally {
407              joinPool(e);              joinPool(e);
408          }          }
# Line 496  Line 411 
411      /**      /**
412       * invokeAll(empty collection) returns empty collection       * invokeAll(empty collection) returns empty collection
413       */       */
414      public void testInvokeAll2() {      public void testInvokeAll2() throws InterruptedException {
415          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
416          try {          try {
417              List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());              List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
418              assertTrue(r.isEmpty());              assertTrue(r.isEmpty());
         } catch (Exception ex) {  
             unexpectedException();  
419          } finally {          } finally {
420              joinPool(e);              joinPool(e);
421          }          }
# Line 511  Line 424 
424      /**      /**
425       * invokeAll(c) throws NPE if c has null elements       * invokeAll(c) throws NPE if c has null elements
426       */       */
427      public void testInvokeAll3() {      public void testInvokeAll3() throws InterruptedException {
428          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
429          try {          try {
430              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
431              l.add(new StringTask());              l.add(new StringTask());
432              l.add(null);              l.add(null);
433              e.invokeAll(l);              e.invokeAll(l);
434                shouldThrow();
435          } catch (NullPointerException success) {          } catch (NullPointerException success) {
         } catch (Exception ex) {  
             unexpectedException();  
436          } finally {          } finally {
437              joinPool(e);              joinPool(e);
438          }          }
# Line 529  Line 441 
441      /**      /**
442       * get of returned element of invokeAll(c) throws exception on failed task       * get of returned element of invokeAll(c) throws exception on failed task
443       */       */
444      public void testInvokeAll4() {      public void testInvokeAll4() throws Exception {
445          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
446          try {          try {
447              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
448              l.add(new NPETask());              l.add(new NPETask());
449              List<Future<String>> result = e.invokeAll(l);              List<Future<String>> result = e.invokeAll(l);
450              assertEquals(1, result.size());              assertEquals(1, result.size());
451              for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)              for (Future<String> future : result) {
452                  it.next().get();                  try {
453                        future.get();
454                        shouldThrow();
455          } catch (ExecutionException success) {          } catch (ExecutionException success) {
456          } catch (Exception ex) {                      Throwable cause = success.getCause();
457              unexpectedException();                      assertTrue(cause instanceof NullPointerException);
458                    }
459                }
460          } finally {          } finally {
461              joinPool(e);              joinPool(e);
462          }          }
# Line 549  Line 465 
465      /**      /**
466       * invokeAll(c) returns results of all completed tasks in c       * invokeAll(c) returns results of all completed tasks in c
467       */       */
468      public void testInvokeAll5() {      public void testInvokeAll5() throws Exception {
469          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
470          try {          try {
471              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
# Line 557  Line 473 
473              l.add(new StringTask());              l.add(new StringTask());
474              List<Future<String>> result = e.invokeAll(l);              List<Future<String>> result = e.invokeAll(l);
475              assertEquals(2, result.size());              assertEquals(2, result.size());
476              for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)              for (Future<String> future : result)
477                  assertSame(TEST_STRING, it.next().get());                  assertSame(TEST_STRING, future.get());
         } catch (ExecutionException success) {  
         } catch (Exception ex) {  
             unexpectedException();  
478          } finally {          } finally {
479              joinPool(e);              joinPool(e);
480          }          }
# Line 571  Line 484 
484      /**      /**
485       * timed invokeAny(null) throws NPE       * timed invokeAny(null) throws NPE
486       */       */
487      public void testTimedInvokeAny1() {      public void testTimedInvokeAny1() throws Exception {
488          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
489          try {          try {
490              e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);              e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
491                shouldThrow();
492          } catch (NullPointerException success) {          } catch (NullPointerException success) {
         } catch (Exception ex) {  
             unexpectedException();  
493          } finally {          } finally {
494              joinPool(e);              joinPool(e);
495          }          }
# Line 586  Line 498 
498      /**      /**
499       * timed invokeAny(null time unit) throws NPE       * timed invokeAny(null time unit) throws NPE
500       */       */
501      public void testTimedInvokeAnyNullTimeUnit() {      public void testTimedInvokeAnyNullTimeUnit() throws Exception {
502          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
503          try {          try {
504              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
505              l.add(new StringTask());              l.add(new StringTask());
506              e.invokeAny(l, MEDIUM_DELAY_MS, null);              e.invokeAny(l, MEDIUM_DELAY_MS, null);
507                shouldThrow();
508          } catch (NullPointerException success) {          } catch (NullPointerException success) {
         } catch (Exception ex) {  
             unexpectedException();  
509          } finally {          } finally {
510              joinPool(e);              joinPool(e);
511          }          }
# Line 603  Line 514 
514      /**      /**
515       * timed invokeAny(empty collection) throws IAE       * timed invokeAny(empty collection) throws IAE
516       */       */
517      public void testTimedInvokeAny2() {      public void testTimedInvokeAny2() throws Exception {
518          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
519          try {          try {
520              e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);              e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
521                shouldThrow();
522          } catch (IllegalArgumentException success) {          } catch (IllegalArgumentException success) {
         } catch (Exception ex) {  
             unexpectedException();  
523          } finally {          } finally {
524              joinPool(e);              joinPool(e);
525          }          }
# Line 618  Line 528 
528      /**      /**
529       * timed invokeAny(c) throws NPE if c has null elements       * timed invokeAny(c) throws NPE if c has null elements
530       */       */
531      public void testTimedInvokeAny3() {      public void testTimedInvokeAny3() throws Exception {
532            final CountDownLatch latch = new CountDownLatch(1);
533          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
534          try {          try {
535              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();              ArrayList<Callable<Integer>> l
536              l.add(new StringTask());                  = new ArrayList<Callable<Integer>>();
537                l.add(new Callable<Integer>() {
538                          public Integer call() { return 5/0; }});
539              l.add(null);              l.add(null);
540              e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);              e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
541                shouldThrow();
542          } catch (NullPointerException success) {          } catch (NullPointerException success) {
         } catch (Exception ex) {  
             ex.printStackTrace();  
             unexpectedException();  
543          } finally {          } finally {
544                latch.countDown();
545              joinPool(e);              joinPool(e);
546          }          }
547      }      }
# Line 637  Line 549 
549      /**      /**
550       * timed invokeAny(c) throws ExecutionException if no task completes       * timed invokeAny(c) throws ExecutionException if no task completes
551       */       */
552      public void testTimedInvokeAny4() {      public void testTimedInvokeAny4() throws Exception {
553          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
554          try {          try {
555              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
556              l.add(new NPETask());              l.add(new NPETask());
557              e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);              e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
558                shouldThrow();
559          } catch (ExecutionException success) {          } catch (ExecutionException success) {
560          } catch (Exception ex) {              assertTrue(success.getCause() instanceof NullPointerException);
             unexpectedException();  
561          } finally {          } finally {
562              joinPool(e);              joinPool(e);
563          }          }
# Line 654  Line 566 
566      /**      /**
567       * timed invokeAny(c) returns result of some task in c       * timed invokeAny(c) returns result of some task in c
568       */       */
569      public void testTimedInvokeAny5() {      public void testTimedInvokeAny5() throws Exception {
570          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
571          try {          try {
572              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
# Line 662  Line 574 
574              l.add(new StringTask());              l.add(new StringTask());
575              String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);              String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
576              assertSame(TEST_STRING, result);              assertSame(TEST_STRING, result);
         } catch (ExecutionException success) {  
         } catch (Exception ex) {  
             unexpectedException();  
577          } finally {          } finally {
578              joinPool(e);              joinPool(e);
579          }          }
# Line 673  Line 582 
582      /**      /**
583       * timed invokeAll(null) throws NPE       * timed invokeAll(null) throws NPE
584       */       */
585      public void testTimedInvokeAll1() {      public void testTimedInvokeAll1() throws InterruptedException {
586          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
587          try {          try {
588              e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);              e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
589                shouldThrow();
590          } catch (NullPointerException success) {          } catch (NullPointerException success) {
         } catch (Exception ex) {  
             unexpectedException();  
591          } finally {          } finally {
592              joinPool(e);              joinPool(e);
593          }          }
# Line 688  Line 596 
596      /**      /**
597       * timed invokeAll(null time unit) throws NPE       * timed invokeAll(null time unit) throws NPE
598       */       */
599      public void testTimedInvokeAllNullTimeUnit() {      public void testTimedInvokeAllNullTimeUnit() throws InterruptedException {
600          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
601          try {          try {
602              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
603              l.add(new StringTask());              l.add(new StringTask());
604              e.invokeAll(l, MEDIUM_DELAY_MS, null);              e.invokeAll(l, MEDIUM_DELAY_MS, null);
605                shouldThrow();
606          } catch (NullPointerException success) {          } catch (NullPointerException success) {
         } catch (Exception ex) {  
             unexpectedException();  
607          } finally {          } finally {
608              joinPool(e);              joinPool(e);
609          }          }
# Line 705  Line 612 
612      /**      /**
613       * timed invokeAll(empty collection) returns empty collection       * timed invokeAll(empty collection) returns empty collection
614       */       */
615      public void testTimedInvokeAll2() {      public void testTimedInvokeAll2() throws InterruptedException {
616          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
617          try {          try {
618              List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);              List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
619              assertTrue(r.isEmpty());              assertTrue(r.isEmpty());
         } catch (Exception ex) {  
             unexpectedException();  
620          } finally {          } finally {
621              joinPool(e);              joinPool(e);
622          }          }
# Line 720  Line 625 
625      /**      /**
626       * timed invokeAll(c) throws NPE if c has null elements       * timed invokeAll(c) throws NPE if c has null elements
627       */       */
628      public void testTimedInvokeAll3() {      public void testTimedInvokeAll3() throws InterruptedException {
629          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
630          try {          try {
631              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
632              l.add(new StringTask());              l.add(new StringTask());
633              l.add(null);              l.add(null);
634              e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);              e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
635                shouldThrow();
636          } catch (NullPointerException success) {          } catch (NullPointerException success) {
         } catch (Exception ex) {  
             unexpectedException();  
637          } finally {          } finally {
638              joinPool(e);              joinPool(e);
639          }          }
# Line 738  Line 642 
642      /**      /**
643       * get of returned element of invokeAll(c) throws exception on failed task       * get of returned element of invokeAll(c) throws exception on failed task
644       */       */
645      public void testTimedInvokeAll4() {      public void testTimedInvokeAll4() throws Exception {
646          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
647          try {          try {
648              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
649              l.add(new NPETask());              l.add(new NPETask());
650              List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);              List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
651              assertEquals(1, result.size());              assertEquals(1, result.size());
652              for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)              for (Future<String> future : result) {
653                  it.next().get();                  try {
654                        future.get();
655          } catch (ExecutionException success) {          } catch (ExecutionException success) {
656          } catch (Exception ex) {                      assertTrue(success.getCause() instanceof NullPointerException);
657              unexpectedException();                  }
658                }
659          } finally {          } finally {
660              joinPool(e);              joinPool(e);
661          }          }
# Line 758  Line 664 
664      /**      /**
665       * timed invokeAll(c) returns results of all completed tasks in c       * timed invokeAll(c) returns results of all completed tasks in c
666       */       */
667      public void testTimedInvokeAll5() {      public void testTimedInvokeAll5() throws Exception {
668          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
669          try {          try {
670              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
# Line 766  Line 672 
672              l.add(new StringTask());              l.add(new StringTask());
673              List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);              List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
674              assertEquals(2, result.size());              assertEquals(2, result.size());
675              for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)              for (Future<String> future : result)
676                  assertSame(TEST_STRING, it.next().get());                  assertSame(TEST_STRING, future.get());
         } catch (ExecutionException success) {  
         } catch (Exception ex) {  
             unexpectedException();  
677          } finally {          } finally {
678              joinPool(e);              joinPool(e);
679          }          }
# Line 779  Line 682 
682      /**      /**
683       * timed invokeAll cancels tasks not completed by timeout       * timed invokeAll cancels tasks not completed by timeout
684       */       */
685      public void testTimedInvokeAll6() {      public void testTimedInvokeAll6() throws InterruptedException {
686          ExecutorService e = new DirectExecutorService();          ExecutorService e = new DirectExecutorService();
687          try {          try {
688              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();              ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
# Line 797  Line 700 
700              assertTrue(f2.isDone());              assertTrue(f2.isDone());
701              assertTrue(f3.isDone());              assertTrue(f3.isDone());
702              assertTrue(f3.isCancelled());              assertTrue(f3.isCancelled());
         } catch (Exception ex) {  
             unexpectedException();  
703          } finally {          } finally {
704              joinPool(e);              joinPool(e);
705          }          }

Legend:
Removed from v.1.18  
changed lines
  Added in v.1.19

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8