[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.6 - (view) (download)

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8