[cvs] / jsr166 / src / test / tck / AbstractExecutorServiceTest.java Repository:
ViewVC logotype

Annotation of /jsr166/src/test/tck/AbstractExecutorServiceTest.java

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.14 - (view) (download)

1 : tim 1.1 /*
2 : dl 1.10 * Written by Doug Lea with assistance from members of JCP JSR-166
3 :     * Expert Group and released to the public domain, as explained at
4 :     * http://creativecommons.org/licenses/publicdomain
5 :     * Other contributors include Andrew Wright, Jeffrey Hayes,
6 :     * Pat Fisher, Mike Judd.
7 : tim 1.1 */
8 :    
9 :    
10 :     import junit.framework.*;
11 :     import java.util.*;
12 :     import java.util.concurrent.*;
13 :     import java.math.BigInteger;
14 :     import java.security.*;
15 :    
16 :     public class AbstractExecutorServiceTest extends JSR166TestCase{
17 :     public static void main(String[] args) {
18 :     junit.textui.TestRunner.run (suite());
19 :     }
20 :     public static Test suite() {
21 : dl 1.6 return new TestSuite(AbstractExecutorServiceTest.class);
22 : tim 1.1 }
23 :    
24 :     /**
25 :     * A no-frills implementation of AbstractExecutorService, designed
26 : dl 1.6 * to test the submit methods only.
27 : tim 1.1 */
28 :     static class DirectExecutorService extends AbstractExecutorService {
29 :     public void execute(Runnable r) { r.run(); }
30 :     public void shutdown() { shutdown = true; }
31 : tim 1.2 public List<Runnable> shutdownNow() { shutdown = true; return Collections.EMPTY_LIST; }
32 : tim 1.1 public boolean isShutdown() { return shutdown; }
33 :     public boolean isTerminated() { return isShutdown(); }
34 :     public boolean awaitTermination(long timeout, TimeUnit unit) { return isShutdown(); }
35 :     private volatile boolean shutdown = false;
36 :     }
37 :    
38 :     /**
39 : dl 1.12 * execute(runnable) runs it to completion
40 : tim 1.1 */
41 :     public void testExecuteRunnable() {
42 :     try {
43 :     ExecutorService e = new DirectExecutorService();
44 :     TrackedShortRunnable task = new TrackedShortRunnable();
45 :     assertFalse(task.done);
46 : dl 1.4 Future<?> future = e.submit(task);
47 : tim 1.1 future.get();
48 :     assertTrue(task.done);
49 :     }
50 :     catch (ExecutionException ex) {
51 :     unexpectedException();
52 :     }
53 :     catch (InterruptedException ex) {
54 :     unexpectedException();
55 :     }
56 :     }
57 :    
58 :    
59 :     /**
60 : dl 1.12 * Completed submit(callable) returns result
61 : tim 1.1 */
62 : dl 1.6 public void testSubmitCallable() {
63 : tim 1.1 try {
64 :     ExecutorService e = new DirectExecutorService();
65 :     Future<String> future = e.submit(new StringTask());
66 :     String result = future.get();
67 :     assertSame(TEST_STRING, result);
68 :     }
69 :     catch (ExecutionException ex) {
70 :     unexpectedException();
71 :     }
72 :     catch (InterruptedException ex) {
73 :     unexpectedException();
74 :     }
75 :     }
76 :    
77 : dl 1.6 /**
78 : dl 1.12 * Completed submit(runnable) returns successfully
79 : dl 1.6 */
80 :     public void testSubmitRunnable() {
81 :     try {
82 :     ExecutorService e = new DirectExecutorService();
83 :     Future<?> future = e.submit(new NoOpRunnable());
84 :     future.get();
85 :     assertTrue(future.isDone());
86 :     }
87 :     catch (ExecutionException ex) {
88 :     unexpectedException();
89 :     }
90 :     catch (InterruptedException ex) {
91 :     unexpectedException();
92 :     }
93 :     }
94 :    
95 :     /**
96 : dl 1.12 * Completed submit(runnable, result) returns result
97 : dl 1.6 */
98 :     public void testSubmitRunnable2() {
99 :     try {
100 :     ExecutorService e = new DirectExecutorService();
101 :     Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
102 :     String result = future.get();
103 :     assertSame(TEST_STRING, result);
104 :     }
105 :     catch (ExecutionException ex) {
106 :     unexpectedException();
107 :     }
108 :     catch (InterruptedException ex) {
109 :     unexpectedException();
110 :     }
111 :     }
112 :    
113 : tim 1.1
114 :     /**
115 : dl 1.12 * A submitted privileged action to completion
116 : tim 1.1 */
117 : dl 1.6 public void testSubmitPrivilegedAction() {
118 : tim 1.1 Policy savedPolicy = Policy.getPolicy();
119 :     AdjustablePolicy policy = new AdjustablePolicy();
120 :     policy.addPermission(new RuntimePermission("getContextClassLoader"));
121 :     policy.addPermission(new RuntimePermission("setContextClassLoader"));
122 :     Policy.setPolicy(policy);
123 :     try {
124 :     ExecutorService e = new DirectExecutorService();
125 : dl 1.5 Future future = e.submit(Executors.callable(new PrivilegedAction() {
126 : tim 1.1 public Object run() {
127 :     return TEST_STRING;
128 : dl 1.5 }}));
129 : tim 1.1
130 :     Object result = future.get();
131 :     assertSame(TEST_STRING, result);
132 :     }
133 :     catch (ExecutionException ex) {
134 :     unexpectedException();
135 :     }
136 :     catch (InterruptedException ex) {
137 :     unexpectedException();
138 :     }
139 :     finally {
140 :     Policy.setPolicy(savedPolicy);
141 :     }
142 :     }
143 :    
144 :     /**
145 : dl 1.12 * A submitted a privileged exception action runs to completion
146 : tim 1.1 */
147 : dl 1.6 public void testSubmitPrivilegedExceptionAction() {
148 : tim 1.1 Policy savedPolicy = Policy.getPolicy();
149 :     AdjustablePolicy policy = new AdjustablePolicy();
150 :     policy.addPermission(new RuntimePermission("getContextClassLoader"));
151 :     policy.addPermission(new RuntimePermission("setContextClassLoader"));
152 :     Policy.setPolicy(policy);
153 :     try {
154 :     ExecutorService e = new DirectExecutorService();
155 : dl 1.5 Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
156 : tim 1.1 public Object run() {
157 :     return TEST_STRING;
158 : dl 1.5 }}));
159 : tim 1.1
160 :     Object result = future.get();
161 :     assertSame(TEST_STRING, result);
162 :     }
163 :     catch (ExecutionException ex) {
164 :     unexpectedException();
165 :     }
166 :     catch (InterruptedException ex) {
167 :     unexpectedException();
168 :     }
169 :     finally {
170 :     Policy.setPolicy(savedPolicy);
171 :     }
172 :     }
173 :    
174 :     /**
175 : dl 1.12 * A submitted failed privileged exception action reports exception
176 : tim 1.1 */
177 : dl 1.6 public void testSubmitFailedPrivilegedExceptionAction() {
178 : tim 1.1 Policy savedPolicy = Policy.getPolicy();
179 :     AdjustablePolicy policy = new AdjustablePolicy();
180 :     policy.addPermission(new RuntimePermission("getContextClassLoader"));
181 :     policy.addPermission(new RuntimePermission("setContextClassLoader"));
182 :     Policy.setPolicy(policy);
183 :     try {
184 :     ExecutorService e = new DirectExecutorService();
185 : dl 1.5 Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
186 : tim 1.1 public Object run() throws Exception {
187 :     throw new IndexOutOfBoundsException();
188 : dl 1.5 }}));
189 : tim 1.1
190 :     Object result = future.get();
191 :     shouldThrow();
192 :     }
193 :     catch (ExecutionException success) {
194 :     }
195 :     catch (InterruptedException ex) {
196 :     unexpectedException();
197 :     }
198 :     finally {
199 :     Policy.setPolicy(savedPolicy);
200 :     }
201 :     }
202 :    
203 :     /**
204 : dl 1.12 * execute(null runnable) throws NPE
205 : tim 1.1 */
206 :     public void testExecuteNullRunnable() {
207 :     try {
208 :     ExecutorService e = new DirectExecutorService();
209 :     TrackedShortRunnable task = null;
210 : dl 1.4 Future<?> future = e.submit(task);
211 : tim 1.1 shouldThrow();
212 :     }
213 :     catch (NullPointerException success) {
214 :     }
215 :     catch (Exception ex) {
216 :     unexpectedException();
217 :     }
218 :     }
219 :    
220 :    
221 :     /**
222 : dl 1.12 * submit(null callable) throws NPE
223 : tim 1.1 */
224 : dl 1.6 public void testSubmitNullCallable() {
225 : tim 1.1 try {
226 :     ExecutorService e = new DirectExecutorService();
227 :     StringTask t = null;
228 :     Future<String> future = e.submit(t);
229 :     shouldThrow();
230 :     }
231 :     catch (NullPointerException success) {
232 :     }
233 :     catch (Exception ex) {
234 :     unexpectedException();
235 :     }
236 :     }
237 :    
238 :     /**
239 : dl 1.12 * submit(runnable) throws RejectedExecutionException if
240 :     * executor is saturated.
241 : tim 1.1 */
242 :     public void testExecute1() {
243 : dl 1.13 ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1));
244 : tim 1.1 try {
245 :    
246 :     for(int i = 0; i < 5; ++i){
247 : dl 1.4 p.submit(new MediumRunnable());
248 : tim 1.1 }
249 :     shouldThrow();
250 :     } catch(RejectedExecutionException success){}
251 :     joinPool(p);
252 :     }
253 :    
254 :     /**
255 : dl 1.12 * submit(callable) throws RejectedExecutionException
256 :     * if executor is saturated.
257 : tim 1.1 */
258 :     public void testExecute2() {
259 : dl 1.13 ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1));
260 : tim 1.1 try {
261 :     for(int i = 0; i < 5; ++i) {
262 :     p.submit(new SmallCallable());
263 :     }
264 :     shouldThrow();
265 :     } catch(RejectedExecutionException e){}
266 :     joinPool(p);
267 :     }
268 :    
269 :    
270 :     /**
271 : dl 1.12 * Blocking on submit(callable) throws InterruptedException if
272 : tim 1.1 * caller interrupted.
273 :     */
274 : dl 1.6 public void testInterruptedSubmit() {
275 : dl 1.13 final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
276 : tim 1.1 Thread t = new Thread(new Runnable() {
277 :     public void run() {
278 :     try {
279 : dl 1.6 p.submit(new Callable<Object>() {
280 : dl 1.4 public Object call() {
281 : tim 1.1 try {
282 :     Thread.sleep(MEDIUM_DELAY_MS);
283 :     shouldThrow();
284 :     } catch(InterruptedException e){
285 :     }
286 : dl 1.4 return null;
287 : tim 1.1 }
288 : dl 1.6 }).get();
289 : tim 1.1 } catch(InterruptedException success){
290 :     } catch(Exception e) {
291 :     unexpectedException();
292 :     }
293 :    
294 :     }
295 :     });
296 :     try {
297 :     t.start();
298 :     Thread.sleep(SHORT_DELAY_MS);
299 :     t.interrupt();
300 :     } catch(Exception e){
301 :     unexpectedException();
302 :     }
303 :     joinPool(p);
304 :     }
305 :    
306 :     /**
307 : dl 1.12 * get of submitted callable throws Exception if callable
308 : dl 1.6 * interrupted
309 : tim 1.1 */
310 : dl 1.6 public void testSubmitIE() {
311 : dl 1.13 final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
312 : tim 1.1
313 :     final Callable c = new Callable() {
314 :     public Object call() {
315 :     try {
316 : dl 1.6 p.submit(new SmallCallable()).get();
317 : tim 1.1 shouldThrow();
318 :     } catch(InterruptedException e){}
319 :     catch(RejectedExecutionException e2){}
320 :     catch(ExecutionException e3){}
321 :     return Boolean.TRUE;
322 :     }
323 :     };
324 :    
325 :    
326 :    
327 :     Thread t = new Thread(new Runnable() {
328 :     public void run() {
329 :     try {
330 :     c.call();
331 :     } catch(Exception e){}
332 :     }
333 :     });
334 :     try {
335 :     t.start();
336 :     Thread.sleep(SHORT_DELAY_MS);
337 :     t.interrupt();
338 :     t.join();
339 :     } catch(InterruptedException e){
340 :     unexpectedException();
341 :     }
342 :    
343 :     joinPool(p);
344 :     }
345 :    
346 :     /**
347 : dl 1.12 * get of submit(callable) throws ExecutionException if callable
348 :     * throws exception
349 : tim 1.1 */
350 : dl 1.6 public void testSubmitEE() {
351 : dl 1.13 ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
352 : tim 1.1
353 :     try {
354 :     Callable c = new Callable() {
355 :     public Object call() {
356 :     int i = 5/0;
357 :     return Boolean.TRUE;
358 :     }
359 :     };
360 :    
361 :     for(int i =0; i < 5; i++){
362 : dl 1.6 p.submit(c).get();
363 : tim 1.1 }
364 :    
365 :     shouldThrow();
366 :     }
367 :     catch(ExecutionException success){
368 :     } catch(Exception e) {
369 :     unexpectedException();
370 :     }
371 :     joinPool(p);
372 : dl 1.6 }
373 :    
374 :     /**
375 :     * invokeAny(null) throws NPE
376 :     */
377 :     public void testInvokeAny1() {
378 :     ExecutorService e = new DirectExecutorService();
379 :     try {
380 :     e.invokeAny(null);
381 :     } catch (NullPointerException success) {
382 :     } catch(Exception ex) {
383 :     unexpectedException();
384 :     } finally {
385 :     joinPool(e);
386 :     }
387 :     }
388 :    
389 :     /**
390 :     * invokeAny(empty collection) throws IAE
391 :     */
392 :     public void testInvokeAny2() {
393 :     ExecutorService e = new DirectExecutorService();
394 :     try {
395 :     e.invokeAny(new ArrayList<Callable<String>>());
396 :     } catch (IllegalArgumentException success) {
397 :     } catch(Exception ex) {
398 :     unexpectedException();
399 :     } finally {
400 :     joinPool(e);
401 :     }
402 :     }
403 :    
404 :     /**
405 :     * invokeAny(c) throws NPE if c has null elements
406 :     */
407 :     public void testInvokeAny3() {
408 :     ExecutorService e = new DirectExecutorService();
409 :     try {
410 :     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
411 :     l.add(new StringTask());
412 :     l.add(null);
413 :     e.invokeAny(l);
414 :     } catch (NullPointerException success) {
415 :     } catch(Exception ex) {
416 : dl 1.7 ex.printStackTrace();
417 : dl 1.6 unexpectedException();
418 :     } finally {
419 :     joinPool(e);
420 :     }
421 :     }
422 :    
423 :     /**
424 : dl 1.12 * invokeAny(c) throws ExecutionException if no task in c completes
425 : dl 1.6 */
426 :     public void testInvokeAny4() {
427 :     ExecutorService e = new DirectExecutorService();
428 :     try {
429 :     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
430 :     l.add(new NPETask());
431 : dl 1.8 e.invokeAny(l);
432 : dl 1.6 } catch(ExecutionException success) {
433 :     } catch(Exception ex) {
434 :     unexpectedException();
435 :     } finally {
436 :     joinPool(e);
437 :     }
438 :     }
439 :    
440 :     /**
441 : dl 1.12 * invokeAny(c) returns result of some task in c if at least one completes
442 : dl 1.6 */
443 :     public void testInvokeAny5() {
444 :     ExecutorService e = new DirectExecutorService();
445 :     try {
446 :     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
447 :     l.add(new StringTask());
448 :     l.add(new StringTask());
449 :     String result = e.invokeAny(l);
450 :     assertSame(TEST_STRING, result);
451 :     } catch (ExecutionException success) {
452 :     } catch(Exception ex) {
453 :     unexpectedException();
454 :     } finally {
455 :     joinPool(e);
456 :     }
457 :     }
458 :    
459 :     /**
460 :     * invokeAll(null) throws NPE
461 :     */
462 :     public void testInvokeAll1() {
463 :     ExecutorService e = new DirectExecutorService();
464 :     try {
465 :     e.invokeAll(null);
466 :     } catch (NullPointerException success) {
467 :     } catch(Exception ex) {
468 :     unexpectedException();
469 :     } finally {
470 :     joinPool(e);
471 :     }
472 :     }
473 :    
474 :     /**
475 :     * invokeAll(empty collection) returns empty collection
476 :     */
477 :     public void testInvokeAll2() {
478 :     ExecutorService e = new DirectExecutorService();
479 :     try {
480 :     List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
481 :     assertTrue(r.isEmpty());
482 :     } catch(Exception ex) {
483 :     unexpectedException();
484 :     } finally {
485 :     joinPool(e);
486 :     }
487 :     }
488 :    
489 :     /**
490 :     * invokeAll(c) throws NPE if c has null elements
491 :     */
492 :     public void testInvokeAll3() {
493 :     ExecutorService e = new DirectExecutorService();
494 :     try {
495 :     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
496 :     l.add(new StringTask());
497 :     l.add(null);
498 :     e.invokeAll(l);
499 :     } catch (NullPointerException success) {
500 :     } catch(Exception ex) {
501 :     unexpectedException();
502 :     } finally {
503 :     joinPool(e);
504 :     }
505 :     }
506 :    
507 :     /**
508 : dl 1.12 * get of returned element of invokeAll(c) throws exception on failed task
509 : dl 1.6 */
510 :     public void testInvokeAll4() {
511 :     ExecutorService e = new DirectExecutorService();
512 :     try {
513 :     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
514 :     l.add(new NPETask());
515 :     List<Future<String>> result = e.invokeAll(l);
516 :     assertEquals(1, result.size());
517 :     for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
518 :     it.next().get();
519 :     } catch(ExecutionException success) {
520 :     } catch(Exception ex) {
521 :     unexpectedException();
522 :     } finally {
523 :     joinPool(e);
524 :     }
525 :     }
526 :    
527 :     /**
528 : dl 1.12 * invokeAll(c) returns results of all completed tasks in c
529 : dl 1.6 */
530 :     public void testInvokeAll5() {
531 :     ExecutorService e = new DirectExecutorService();
532 :     try {
533 :     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
534 :     l.add(new StringTask());
535 :     l.add(new StringTask());
536 :     List<Future<String>> result = e.invokeAll(l);
537 :     assertEquals(2, result.size());
538 :     for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
539 :     assertSame(TEST_STRING, it.next().get());
540 :     } catch (ExecutionException success) {
541 : dl 1.8 } catch(Exception ex) {
542 :     unexpectedException();
543 :     } finally {
544 :     joinPool(e);
545 :     }
546 :     }
547 :    
548 :    
549 :     /**
550 :     * timed invokeAny(null) throws NPE
551 :     */
552 :     public void testTimedInvokeAny1() {
553 :     ExecutorService e = new DirectExecutorService();
554 :     try {
555 :     e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
556 :     } catch (NullPointerException success) {
557 :     } catch(Exception ex) {
558 :     unexpectedException();
559 :     } finally {
560 :     joinPool(e);
561 :     }
562 :     }
563 :    
564 :     /**
565 : dl 1.12 * timed invokeAny(null time unit) throws NPE
566 : dl 1.8 */
567 :     public void testTimedInvokeAnyNullTimeUnit() {
568 :     ExecutorService e = new DirectExecutorService();
569 :     try {
570 :     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
571 :     l.add(new StringTask());
572 :     e.invokeAny(l, MEDIUM_DELAY_MS, null);
573 :     } catch (NullPointerException success) {
574 :     } catch(Exception ex) {
575 :     unexpectedException();
576 :     } finally {
577 :     joinPool(e);
578 :     }
579 :     }
580 :    
581 :     /**
582 :     * timed invokeAny(empty collection) throws IAE
583 :     */
584 :     public void testTimedInvokeAny2() {
585 :     ExecutorService e = new DirectExecutorService();
586 :     try {
587 :     e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
588 :     } catch (IllegalArgumentException success) {
589 :     } catch(Exception ex) {
590 :     unexpectedException();
591 :     } finally {
592 :     joinPool(e);
593 :     }
594 :     }
595 :    
596 :     /**
597 :     * timed invokeAny(c) throws NPE if c has null elements
598 :     */
599 :     public void testTimedInvokeAny3() {
600 :     ExecutorService e = new DirectExecutorService();
601 :     try {
602 :     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
603 :     l.add(new StringTask());
604 :     l.add(null);
605 :     e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
606 :     } catch (NullPointerException success) {
607 :     } catch(Exception ex) {
608 :     ex.printStackTrace();
609 :     unexpectedException();
610 :     } finally {
611 :     joinPool(e);
612 :     }
613 :     }
614 :    
615 :     /**
616 :     * timed invokeAny(c) throws ExecutionException if no task completes
617 :     */
618 :     public void testTimedInvokeAny4() {
619 :     ExecutorService e = new DirectExecutorService();
620 :     try {
621 :     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
622 :     l.add(new NPETask());
623 :     e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
624 :     } catch(ExecutionException success) {
625 :     } catch(Exception ex) {
626 :     unexpectedException();
627 :     } finally {
628 :     joinPool(e);
629 :     }
630 :     }
631 :    
632 :     /**
633 : dl 1.12 * timed invokeAny(c) returns result of some task in c
634 : dl 1.8 */
635 :     public void testTimedInvokeAny5() {
636 :     ExecutorService e = new DirectExecutorService();
637 :     try {
638 :     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
639 :     l.add(new StringTask());
640 :     l.add(new StringTask());
641 :     String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
642 :     assertSame(TEST_STRING, result);
643 :     } catch (ExecutionException success) {
644 :     } catch(Exception ex) {
645 :     unexpectedException();
646 :     } finally {
647 :     joinPool(e);
648 :     }
649 :     }
650 :    
651 :     /**
652 :     * timed invokeAll(null) throws NPE
653 :     */
654 :     public void testTimedInvokeAll1() {
655 :     ExecutorService e = new DirectExecutorService();
656 :     try {
657 :     e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
658 :     } catch (NullPointerException success) {
659 :     } catch(Exception ex) {
660 :     unexpectedException();
661 :     } finally {
662 :     joinPool(e);
663 :     }
664 :     }
665 :    
666 :     /**
667 : dl 1.12 * timed invokeAll(null time unit) throws NPE
668 : dl 1.8 */
669 :     public void testTimedInvokeAllNullTimeUnit() {
670 :     ExecutorService e = new DirectExecutorService();
671 :     try {
672 :     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
673 :     l.add(new StringTask());
674 :     e.invokeAll(l, MEDIUM_DELAY_MS, null);
675 :     } catch (NullPointerException success) {
676 :     } catch(Exception ex) {
677 :     unexpectedException();
678 :     } finally {
679 :     joinPool(e);
680 :     }
681 :     }
682 :    
683 :     /**
684 :     * timed invokeAll(empty collection) returns empty collection
685 :     */
686 :     public void testTimedInvokeAll2() {
687 :     ExecutorService e = new DirectExecutorService();
688 :     try {
689 :     List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
690 :     assertTrue(r.isEmpty());
691 :     } catch(Exception ex) {
692 :     unexpectedException();
693 :     } finally {
694 :     joinPool(e);
695 :     }
696 :     }
697 :    
698 :     /**
699 :     * timed invokeAll(c) throws NPE if c has null elements
700 :     */
701 :     public void testTimedInvokeAll3() {
702 :     ExecutorService e = new DirectExecutorService();
703 :     try {
704 :     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
705 :     l.add(new StringTask());
706 :     l.add(null);
707 :     e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
708 :     } catch (NullPointerException success) {
709 :     } catch(Exception ex) {
710 :     unexpectedException();
711 :     } finally {
712 :     joinPool(e);
713 :     }
714 :     }
715 :    
716 :     /**
717 : dl 1.12 * get of returned element of invokeAll(c) throws exception on failed task
718 : dl 1.8 */
719 :     public void testTimedInvokeAll4() {
720 :     ExecutorService e = new DirectExecutorService();
721 :     try {
722 :     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
723 :     l.add(new NPETask());
724 :     List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
725 :     assertEquals(1, result.size());
726 :     for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
727 :     it.next().get();
728 :     } catch(ExecutionException success) {
729 :     } catch(Exception ex) {
730 :     unexpectedException();
731 :     } finally {
732 :     joinPool(e);
733 :     }
734 :     }
735 :    
736 :     /**
737 : dl 1.12 * timed invokeAll(c) returns results of all completed tasks in c
738 : dl 1.8 */
739 :     public void testTimedInvokeAll5() {
740 :     ExecutorService e = new DirectExecutorService();
741 :     try {
742 :     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
743 :     l.add(new StringTask());
744 :     l.add(new StringTask());
745 :     List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
746 :     assertEquals(2, result.size());
747 :     for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
748 :     assertSame(TEST_STRING, it.next().get());
749 :     } catch (ExecutionException success) {
750 :     } catch(Exception ex) {
751 :     unexpectedException();
752 :     } finally {
753 :     joinPool(e);
754 :     }
755 :     }
756 :    
757 :     /**
758 : dl 1.12 * timed invokeAll cancels tasks not completed by timeout
759 : dl 1.8 */
760 :     public void testTimedInvokeAll6() {
761 : dl 1.9 ExecutorService e = new DirectExecutorService();
762 : dl 1.8 try {
763 :     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
764 :     l.add(new StringTask());
765 : dl 1.11 l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
766 :     l.add(new StringTask());
767 : dl 1.14 List<Future<String>> result = e.invokeAll(l, SMALL_DELAY_MS, TimeUnit.MILLISECONDS);
768 : dl 1.11 assertEquals(3, result.size());
769 : dl 1.8 Iterator<Future<String>> it = result.iterator();
770 :     Future<String> f1 = it.next();
771 :     Future<String> f2 = it.next();
772 : dl 1.11 Future<String> f3 = it.next();
773 : dl 1.8 assertTrue(f1.isDone());
774 :     assertFalse(f1.isCancelled());
775 :     assertTrue(f2.isDone());
776 : dl 1.11 assertTrue(f3.isDone());
777 :     assertTrue(f3.isCancelled());
778 : dl 1.6 } catch(Exception ex) {
779 :     unexpectedException();
780 :     } finally {
781 :     joinPool(e);
782 :     }
783 : tim 1.1 }
784 :    
785 : dl 1.3 }

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8