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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.99 - (view) (download)

1 : dl 1.1 /*
2 :     * 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 : jsr166 1.25 * http://creativecommons.org/publicdomain/zero/1.0/
5 : jsr166 1.2 * Other contributors include Andrew Wright, Jeffrey Hayes,
6 :     * Pat Fisher, Mike Judd.
7 : dl 1.1 */
8 :    
9 : jsr166 1.9 import static java.util.concurrent.TimeUnit.MILLISECONDS;
10 : jsr166 1.36 import static java.util.concurrent.TimeUnit.SECONDS;
11 : jsr166 1.33
12 :     import java.util.ArrayList;
13 : jsr166 1.99 import java.util.Collection;
14 :     import java.util.Collections;
15 : jsr166 1.33 import java.util.List;
16 :     import java.util.concurrent.ArrayBlockingQueue;
17 :     import java.util.concurrent.BlockingQueue;
18 :     import java.util.concurrent.Callable;
19 : jsr166 1.39 import java.util.concurrent.CancellationException;
20 : jsr166 1.33 import java.util.concurrent.CountDownLatch;
21 :     import java.util.concurrent.ExecutionException;
22 :     import java.util.concurrent.ExecutorService;
23 :     import java.util.concurrent.Future;
24 :     import java.util.concurrent.FutureTask;
25 :     import java.util.concurrent.LinkedBlockingQueue;
26 :     import java.util.concurrent.RejectedExecutionException;
27 :     import java.util.concurrent.RejectedExecutionHandler;
28 :     import java.util.concurrent.RunnableFuture;
29 :     import java.util.concurrent.SynchronousQueue;
30 :     import java.util.concurrent.ThreadFactory;
31 :     import java.util.concurrent.ThreadPoolExecutor;
32 :     import java.util.concurrent.TimeoutException;
33 :     import java.util.concurrent.TimeUnit;
34 : jsr166 1.41 import java.util.concurrent.atomic.AtomicInteger;
35 : jsr166 1.31 import java.util.concurrent.locks.Condition;
36 :     import java.util.concurrent.locks.ReentrantLock;
37 : jsr166 1.33
38 :     import junit.framework.Test;
39 :     import junit.framework.TestSuite;
40 : dl 1.1
41 :     public class ThreadPoolExecutorSubclassTest extends JSR166TestCase {
42 :     public static void main(String[] args) {
43 : jsr166 1.35 main(suite(), args);
44 : dl 1.1 }
45 :     public static Test suite() {
46 : jsr166 1.6 return new TestSuite(ThreadPoolExecutorSubclassTest.class);
47 : dl 1.1 }
48 :    
49 :     static class CustomTask<V> implements RunnableFuture<V> {
50 :     final Callable<V> callable;
51 :     final ReentrantLock lock = new ReentrantLock();
52 :     final Condition cond = lock.newCondition();
53 :     boolean done;
54 :     boolean cancelled;
55 :     V result;
56 :     Thread thread;
57 :     Exception exception;
58 : jsr166 1.6 CustomTask(Callable<V> c) {
59 :     if (c == null) throw new NullPointerException();
60 :     callable = c;
61 :     }
62 :     CustomTask(final Runnable r, final V res) {
63 :     if (r == null) throw new NullPointerException();
64 :     callable = new Callable<V>() {
65 : jsr166 1.34 public V call() throws Exception { r.run(); return res; }};
66 : dl 1.1 }
67 :     public boolean isDone() {
68 :     lock.lock(); try { return done; } finally { lock.unlock() ; }
69 :     }
70 :     public boolean isCancelled() {
71 :     lock.lock(); try { return cancelled; } finally { lock.unlock() ; }
72 :     }
73 :     public boolean cancel(boolean mayInterrupt) {
74 :     lock.lock();
75 :     try {
76 :     if (!done) {
77 :     cancelled = true;
78 :     done = true;
79 : jsr166 1.2 if (mayInterrupt && thread != null)
80 : dl 1.1 thread.interrupt();
81 :     return true;
82 :     }
83 :     return false;
84 :     }
85 :     finally { lock.unlock() ; }
86 :     }
87 :     public void run() {
88 :     lock.lock();
89 :     try {
90 : jsr166 1.22 if (done)
91 :     return;
92 :     thread = Thread.currentThread();
93 : dl 1.1 }
94 :     finally { lock.unlock() ; }
95 :     V v = null;
96 :     Exception e = null;
97 :     try {
98 :     v = callable.call();
99 :     }
100 : jsr166 1.3 catch (Exception ex) {
101 : dl 1.1 e = ex;
102 :     }
103 :     lock.lock();
104 :     try {
105 : jsr166 1.44 if (!done) {
106 :     result = v;
107 :     exception = e;
108 :     done = true;
109 :     thread = null;
110 :     cond.signalAll();
111 :     }
112 : dl 1.1 }
113 :     finally { lock.unlock(); }
114 :     }
115 :     public V get() throws InterruptedException, ExecutionException {
116 :     lock.lock();
117 :     try {
118 : jsr166 1.2 while (!done)
119 : dl 1.1 cond.await();
120 : jsr166 1.44 if (cancelled)
121 :     throw new CancellationException();
122 : dl 1.1 if (exception != null)
123 :     throw new ExecutionException(exception);
124 :     return result;
125 :     }
126 :     finally { lock.unlock(); }
127 :     }
128 :     public V get(long timeout, TimeUnit unit)
129 : jsr166 1.4 throws InterruptedException, ExecutionException, TimeoutException {
130 : dl 1.1 long nanos = unit.toNanos(timeout);
131 :     lock.lock();
132 :     try {
133 : jsr166 1.44 while (!done) {
134 : jsr166 1.47 if (nanos <= 0L)
135 : dl 1.1 throw new TimeoutException();
136 :     nanos = cond.awaitNanos(nanos);
137 :     }
138 : jsr166 1.44 if (cancelled)
139 :     throw new CancellationException();
140 : dl 1.1 if (exception != null)
141 :     throw new ExecutionException(exception);
142 :     return result;
143 :     }
144 :     finally { lock.unlock(); }
145 :     }
146 : jsr166 1.2 }
147 :    
148 : dl 1.1 static class CustomTPE extends ThreadPoolExecutor {
149 :     protected <V> RunnableFuture<V> newTaskFor(Callable<V> c) {
150 :     return new CustomTask<V>(c);
151 :     }
152 :     protected <V> RunnableFuture<V> newTaskFor(Runnable r, V v) {
153 :     return new CustomTask<V>(r, v);
154 : jsr166 1.2 }
155 :    
156 : dl 1.1 CustomTPE(int corePoolSize,
157 :     int maximumPoolSize,
158 :     long keepAliveTime,
159 :     TimeUnit unit,
160 :     BlockingQueue<Runnable> workQueue) {
161 : jsr166 1.2 super(corePoolSize, maximumPoolSize, keepAliveTime, unit,
162 : dl 1.1 workQueue);
163 :     }
164 :     CustomTPE(int corePoolSize,
165 :     int maximumPoolSize,
166 :     long keepAliveTime,
167 :     TimeUnit unit,
168 :     BlockingQueue<Runnable> workQueue,
169 :     ThreadFactory threadFactory) {
170 :     super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
171 :     threadFactory);
172 :     }
173 :    
174 :     CustomTPE(int corePoolSize,
175 :     int maximumPoolSize,
176 :     long keepAliveTime,
177 :     TimeUnit unit,
178 :     BlockingQueue<Runnable> workQueue,
179 :     RejectedExecutionHandler handler) {
180 :     super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
181 :     handler);
182 :     }
183 :     CustomTPE(int corePoolSize,
184 :     int maximumPoolSize,
185 :     long keepAliveTime,
186 :     TimeUnit unit,
187 :     BlockingQueue<Runnable> workQueue,
188 :     ThreadFactory threadFactory,
189 :     RejectedExecutionHandler handler) {
190 : jsr166 1.2 super(corePoolSize, maximumPoolSize, keepAliveTime, unit,
191 : dl 1.1 workQueue, threadFactory, handler);
192 :     }
193 :    
194 : jsr166 1.30 final CountDownLatch beforeCalled = new CountDownLatch(1);
195 :     final CountDownLatch afterCalled = new CountDownLatch(1);
196 :     final CountDownLatch terminatedCalled = new CountDownLatch(1);
197 :    
198 : dl 1.1 public CustomTPE() {
199 : jsr166 1.9 super(1, 1, LONG_DELAY_MS, MILLISECONDS, new SynchronousQueue<Runnable>());
200 : dl 1.1 }
201 :     protected void beforeExecute(Thread t, Runnable r) {
202 : jsr166 1.30 beforeCalled.countDown();
203 : dl 1.1 }
204 :     protected void afterExecute(Runnable r, Throwable t) {
205 : jsr166 1.30 afterCalled.countDown();
206 : dl 1.1 }
207 :     protected void terminated() {
208 : jsr166 1.30 terminatedCalled.countDown();
209 : dl 1.1 }
210 : jsr166 1.2
211 : jsr166 1.30 public boolean beforeCalled() {
212 :     return beforeCalled.getCount() == 0;
213 :     }
214 :     public boolean afterCalled() {
215 :     return afterCalled.getCount() == 0;
216 :     }
217 :     public boolean terminatedCalled() {
218 :     return terminatedCalled.getCount() == 0;
219 :     }
220 : dl 1.1 }
221 :    
222 : jsr166 1.4 static class FailingThreadFactory implements ThreadFactory {
223 : dl 1.1 int calls = 0;
224 : jsr166 1.4 public Thread newThread(Runnable r) {
225 : dl 1.1 if (++calls > 1) return null;
226 :     return new Thread(r);
227 : jsr166 1.2 }
228 : dl 1.1 }
229 : jsr166 1.2
230 : dl 1.1 /**
231 : jsr166 1.19 * execute successfully executes a runnable
232 : dl 1.1 */
233 : jsr166 1.5 public void testExecute() throws InterruptedException {
234 : jsr166 1.50 final ThreadPoolExecutor p =
235 :     new CustomTPE(1, 1,
236 :     2 * LONG_DELAY_MS, MILLISECONDS,
237 :     new ArrayBlockingQueue<Runnable>(10));
238 : jsr166 1.51 try (PoolCleaner cleaner = cleaner(p)) {
239 : jsr166 1.48 final CountDownLatch done = new CountDownLatch(1);
240 :     final Runnable task = new CheckedRunnable() {
241 : jsr166 1.50 public void realRun() { done.countDown(); }};
242 : jsr166 1.21 p.execute(task);
243 : jsr166 1.98 await(done);
244 : jsr166 1.2 }
245 : dl 1.1 }
246 :    
247 :     /**
248 : jsr166 1.19 * getActiveCount increases but doesn't overestimate, when a
249 :     * thread becomes active
250 : dl 1.1 */
251 : jsr166 1.5 public void testGetActiveCount() throws InterruptedException {
252 : jsr166 1.92 final CountDownLatch done = new CountDownLatch(1);
253 : jsr166 1.21 final ThreadPoolExecutor p =
254 :     new CustomTPE(2, 2,
255 :     LONG_DELAY_MS, MILLISECONDS,
256 :     new ArrayBlockingQueue<Runnable>(10));
257 : jsr166 1.92 try (PoolCleaner cleaner = cleaner(p, done)) {
258 : jsr166 1.66 final CountDownLatch threadStarted = new CountDownLatch(1);
259 : jsr166 1.21 assertEquals(0, p.getActiveCount());
260 :     p.execute(new CheckedRunnable() {
261 :     public void realRun() throws InterruptedException {
262 :     threadStarted.countDown();
263 :     assertEquals(1, p.getActiveCount());
264 : jsr166 1.89 await(done);
265 : jsr166 1.21 }});
266 : jsr166 1.91 await(threadStarted);
267 : jsr166 1.21 assertEquals(1, p.getActiveCount());
268 :     }
269 : dl 1.1 }
270 :    
271 :     /**
272 : jsr166 1.19 * prestartCoreThread starts a thread if under corePoolSize, else doesn't
273 : dl 1.1 */
274 :     public void testPrestartCoreThread() {
275 : jsr166 1.80 final ThreadPoolExecutor p =
276 : jsr166 1.52 new CustomTPE(2, 6,
277 :     LONG_DELAY_MS, MILLISECONDS,
278 :     new ArrayBlockingQueue<Runnable>(10));
279 :     try (PoolCleaner cleaner = cleaner(p)) {
280 :     assertEquals(0, p.getPoolSize());
281 :     assertTrue(p.prestartCoreThread());
282 :     assertEquals(1, p.getPoolSize());
283 :     assertTrue(p.prestartCoreThread());
284 :     assertEquals(2, p.getPoolSize());
285 :     assertFalse(p.prestartCoreThread());
286 :     assertEquals(2, p.getPoolSize());
287 :     p.setCorePoolSize(4);
288 :     assertTrue(p.prestartCoreThread());
289 :     assertEquals(3, p.getPoolSize());
290 :     assertTrue(p.prestartCoreThread());
291 :     assertEquals(4, p.getPoolSize());
292 :     assertFalse(p.prestartCoreThread());
293 :     assertEquals(4, p.getPoolSize());
294 :     }
295 : dl 1.1 }
296 :    
297 :     /**
298 : jsr166 1.19 * prestartAllCoreThreads starts all corePoolSize threads
299 : dl 1.1 */
300 :     public void testPrestartAllCoreThreads() {
301 : jsr166 1.80 final ThreadPoolExecutor p =
302 : jsr166 1.53 new CustomTPE(2, 6,
303 :     LONG_DELAY_MS, MILLISECONDS,
304 :     new ArrayBlockingQueue<Runnable>(10));
305 :     try (PoolCleaner cleaner = cleaner(p)) {
306 :     assertEquals(0, p.getPoolSize());
307 :     p.prestartAllCoreThreads();
308 :     assertEquals(2, p.getPoolSize());
309 :     p.prestartAllCoreThreads();
310 :     assertEquals(2, p.getPoolSize());
311 :     p.setCorePoolSize(4);
312 :     p.prestartAllCoreThreads();
313 :     assertEquals(4, p.getPoolSize());
314 :     p.prestartAllCoreThreads();
315 :     assertEquals(4, p.getPoolSize());
316 :     }
317 : dl 1.1 }
318 : jsr166 1.2
319 : dl 1.1 /**
320 : jsr166 1.19 * getCompletedTaskCount increases, but doesn't overestimate,
321 :     * when tasks complete
322 : dl 1.1 */
323 : jsr166 1.5 public void testGetCompletedTaskCount() throws InterruptedException {
324 : jsr166 1.21 final ThreadPoolExecutor p =
325 :     new CustomTPE(2, 2,
326 :     LONG_DELAY_MS, MILLISECONDS,
327 :     new ArrayBlockingQueue<Runnable>(10));
328 : jsr166 1.54 try (PoolCleaner cleaner = cleaner(p)) {
329 :     final CountDownLatch threadStarted = new CountDownLatch(1);
330 :     final CountDownLatch threadProceed = new CountDownLatch(1);
331 :     final CountDownLatch threadDone = new CountDownLatch(1);
332 : jsr166 1.21 assertEquals(0, p.getCompletedTaskCount());
333 :     p.execute(new CheckedRunnable() {
334 :     public void realRun() throws InterruptedException {
335 :     threadStarted.countDown();
336 :     assertEquals(0, p.getCompletedTaskCount());
337 : jsr166 1.98 await(threadProceed);
338 : jsr166 1.21 threadDone.countDown();
339 :     }});
340 : jsr166 1.30 await(threadStarted);
341 : jsr166 1.21 assertEquals(0, p.getCompletedTaskCount());
342 :     threadProceed.countDown();
343 : jsr166 1.98 await(threadDone);
344 : jsr166 1.30 long startTime = System.nanoTime();
345 :     while (p.getCompletedTaskCount() != 1) {
346 :     if (millisElapsedSince(startTime) > LONG_DELAY_MS)
347 :     fail("timed out");
348 :     Thread.yield();
349 :     }
350 : jsr166 1.21 }
351 : dl 1.1 }
352 : jsr166 1.2
353 : dl 1.1 /**
354 : jsr166 1.19 * getCorePoolSize returns size given in constructor if not otherwise set
355 : dl 1.1 */
356 :     public void testGetCorePoolSize() {
357 : jsr166 1.59 final ThreadPoolExecutor p =
358 : jsr166 1.55 new CustomTPE(1, 1,
359 :     LONG_DELAY_MS, MILLISECONDS,
360 :     new ArrayBlockingQueue<Runnable>(10));
361 :     try (PoolCleaner cleaner = cleaner(p)) {
362 :     assertEquals(1, p.getCorePoolSize());
363 :     }
364 : dl 1.1 }
365 : jsr166 1.2
366 : dl 1.1 /**
367 : jsr166 1.19 * getKeepAliveTime returns value given in constructor if not otherwise set
368 : dl 1.1 */
369 :     public void testGetKeepAliveTime() {
370 : jsr166 1.59 final ThreadPoolExecutor p =
371 : jsr166 1.56 new CustomTPE(2, 2,
372 :     1000, MILLISECONDS,
373 :     new ArrayBlockingQueue<Runnable>(10));
374 :     try (PoolCleaner cleaner = cleaner(p)) {
375 :     assertEquals(1, p.getKeepAliveTime(SECONDS));
376 :     }
377 : dl 1.1 }
378 :    
379 : jsr166 1.2 /**
380 : dl 1.1 * getThreadFactory returns factory in constructor if not set
381 :     */
382 :     public void testGetThreadFactory() {
383 : jsr166 1.59 final ThreadFactory threadFactory = new SimpleThreadFactory();
384 :     final ThreadPoolExecutor p =
385 : jsr166 1.57 new CustomTPE(1, 2,
386 :     LONG_DELAY_MS, MILLISECONDS,
387 :     new ArrayBlockingQueue<Runnable>(10),
388 :     threadFactory,
389 :     new NoOpREHandler());
390 :     try (PoolCleaner cleaner = cleaner(p)) {
391 :     assertSame(threadFactory, p.getThreadFactory());
392 :     }
393 : dl 1.1 }
394 :    
395 : jsr166 1.2 /**
396 : dl 1.1 * setThreadFactory sets the thread factory returned by getThreadFactory
397 :     */
398 :     public void testSetThreadFactory() {
399 : jsr166 1.59 final ThreadPoolExecutor p =
400 : jsr166 1.57 new CustomTPE(1, 2,
401 :     LONG_DELAY_MS, MILLISECONDS,
402 :     new ArrayBlockingQueue<Runnable>(10));
403 :     try (PoolCleaner cleaner = cleaner(p)) {
404 :     ThreadFactory threadFactory = new SimpleThreadFactory();
405 :     p.setThreadFactory(threadFactory);
406 :     assertSame(threadFactory, p.getThreadFactory());
407 :     }
408 : dl 1.1 }
409 :    
410 : jsr166 1.2 /**
411 : dl 1.1 * setThreadFactory(null) throws NPE
412 :     */
413 :     public void testSetThreadFactoryNull() {
414 : jsr166 1.59 final ThreadPoolExecutor p =
415 : jsr166 1.58 new CustomTPE(1, 2,
416 :     LONG_DELAY_MS, MILLISECONDS,
417 :     new ArrayBlockingQueue<Runnable>(10));
418 :     try (PoolCleaner cleaner = cleaner(p)) {
419 :     try {
420 :     p.setThreadFactory(null);
421 :     shouldThrow();
422 :     } catch (NullPointerException success) {}
423 : dl 1.1 }
424 :     }
425 :    
426 : jsr166 1.2 /**
427 : dl 1.1 * getRejectedExecutionHandler returns handler in constructor if not set
428 :     */
429 :     public void testGetRejectedExecutionHandler() {
430 : jsr166 1.60 final RejectedExecutionHandler handler = new NoOpREHandler();
431 : jsr166 1.59 final ThreadPoolExecutor p =
432 :     new CustomTPE(1, 2,
433 :     LONG_DELAY_MS, MILLISECONDS,
434 :     new ArrayBlockingQueue<Runnable>(10),
435 : jsr166 1.60 handler);
436 : jsr166 1.59 try (PoolCleaner cleaner = cleaner(p)) {
437 : jsr166 1.60 assertSame(handler, p.getRejectedExecutionHandler());
438 : jsr166 1.59 }
439 : dl 1.1 }
440 :    
441 : jsr166 1.2 /**
442 : dl 1.1 * setRejectedExecutionHandler sets the handler returned by
443 :     * getRejectedExecutionHandler
444 :     */
445 :     public void testSetRejectedExecutionHandler() {
446 : jsr166 1.60 final ThreadPoolExecutor p =
447 :     new CustomTPE(1, 2,
448 :     LONG_DELAY_MS, MILLISECONDS,
449 :     new ArrayBlockingQueue<Runnable>(10));
450 :     try (PoolCleaner cleaner = cleaner(p)) {
451 :     RejectedExecutionHandler handler = new NoOpREHandler();
452 :     p.setRejectedExecutionHandler(handler);
453 :     assertSame(handler, p.getRejectedExecutionHandler());
454 :     }
455 : dl 1.1 }
456 :    
457 : jsr166 1.2 /**
458 : dl 1.1 * setRejectedExecutionHandler(null) throws NPE
459 :     */
460 :     public void testSetRejectedExecutionHandlerNull() {
461 : jsr166 1.61 final ThreadPoolExecutor p =
462 :     new CustomTPE(1, 2,
463 :     LONG_DELAY_MS, MILLISECONDS,
464 :     new ArrayBlockingQueue<Runnable>(10));
465 :     try (PoolCleaner cleaner = cleaner(p)) {
466 :     try {
467 :     p.setRejectedExecutionHandler(null);
468 :     shouldThrow();
469 :     } catch (NullPointerException success) {}
470 : dl 1.1 }
471 :     }
472 :    
473 :     /**
474 : jsr166 1.19 * getLargestPoolSize increases, but doesn't overestimate, when
475 :     * multiple threads active
476 : dl 1.1 */
477 : jsr166 1.5 public void testGetLargestPoolSize() throws InterruptedException {
478 : jsr166 1.21 final int THREADS = 3;
479 : jsr166 1.87 final CountDownLatch done = new CountDownLatch(1);
480 : jsr166 1.21 final ThreadPoolExecutor p =
481 :     new CustomTPE(THREADS, THREADS,
482 :     LONG_DELAY_MS, MILLISECONDS,
483 :     new ArrayBlockingQueue<Runnable>(10));
484 : jsr166 1.87 try (PoolCleaner cleaner = cleaner(p, done)) {
485 :     assertEquals(0, p.getLargestPoolSize());
486 : jsr166 1.62 final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
487 : jsr166 1.21 for (int i = 0; i < THREADS; i++)
488 :     p.execute(new CheckedRunnable() {
489 :     public void realRun() throws InterruptedException {
490 :     threadsStarted.countDown();
491 : jsr166 1.89 await(done);
492 : jsr166 1.21 assertEquals(THREADS, p.getLargestPoolSize());
493 :     }});
494 : jsr166 1.90 await(threadsStarted);
495 : jsr166 1.21 assertEquals(THREADS, p.getLargestPoolSize());
496 :     }
497 : jsr166 1.62 assertEquals(THREADS, p.getLargestPoolSize());
498 : dl 1.1 }
499 : jsr166 1.2
500 : dl 1.1 /**
501 : jsr166 1.19 * getMaximumPoolSize returns value given in constructor if not
502 :     * otherwise set
503 : dl 1.1 */
504 :     public void testGetMaximumPoolSize() {
505 : jsr166 1.63 final ThreadPoolExecutor p =
506 :     new CustomTPE(2, 3,
507 :     LONG_DELAY_MS, MILLISECONDS,
508 :     new ArrayBlockingQueue<Runnable>(10));
509 :     try (PoolCleaner cleaner = cleaner(p)) {
510 :     assertEquals(3, p.getMaximumPoolSize());
511 :     p.setMaximumPoolSize(5);
512 :     assertEquals(5, p.getMaximumPoolSize());
513 :     p.setMaximumPoolSize(4);
514 :     assertEquals(4, p.getMaximumPoolSize());
515 :     }
516 : dl 1.1 }
517 : jsr166 1.2
518 : dl 1.1 /**
519 : jsr166 1.19 * getPoolSize increases, but doesn't overestimate, when threads
520 :     * become active
521 : dl 1.1 */
522 : jsr166 1.21 public void testGetPoolSize() throws InterruptedException {
523 : jsr166 1.87 final CountDownLatch done = new CountDownLatch(1);
524 : jsr166 1.21 final ThreadPoolExecutor p =
525 :     new CustomTPE(1, 1,
526 :     LONG_DELAY_MS, MILLISECONDS,
527 :     new ArrayBlockingQueue<Runnable>(10));
528 : jsr166 1.87 try (PoolCleaner cleaner = cleaner(p, done)) {
529 :     assertEquals(0, p.getPoolSize());
530 : jsr166 1.64 final CountDownLatch threadStarted = new CountDownLatch(1);
531 : jsr166 1.21 p.execute(new CheckedRunnable() {
532 :     public void realRun() throws InterruptedException {
533 :     threadStarted.countDown();
534 :     assertEquals(1, p.getPoolSize());
535 : jsr166 1.89 await(done);
536 : jsr166 1.21 }});
537 : jsr166 1.91 await(threadStarted);
538 : jsr166 1.21 assertEquals(1, p.getPoolSize());
539 :     }
540 : dl 1.1 }
541 : jsr166 1.2
542 : dl 1.1 /**
543 : jsr166 1.19 * getTaskCount increases, but doesn't overestimate, when tasks submitted
544 : dl 1.1 */
545 : jsr166 1.5 public void testGetTaskCount() throws InterruptedException {
546 : jsr166 1.84 final int TASKS = 3;
547 :     final CountDownLatch done = new CountDownLatch(1);
548 : jsr166 1.21 final ThreadPoolExecutor p =
549 :     new CustomTPE(1, 1,
550 :     LONG_DELAY_MS, MILLISECONDS,
551 :     new ArrayBlockingQueue<Runnable>(10));
552 : jsr166 1.84 try (PoolCleaner cleaner = cleaner(p, done)) {
553 : jsr166 1.67 final CountDownLatch threadStarted = new CountDownLatch(1);
554 : jsr166 1.21 assertEquals(0, p.getTaskCount());
555 : jsr166 1.84 assertEquals(0, p.getCompletedTaskCount());
556 : jsr166 1.21 p.execute(new CheckedRunnable() {
557 :     public void realRun() throws InterruptedException {
558 :     threadStarted.countDown();
559 : jsr166 1.89 await(done);
560 : jsr166 1.21 }});
561 : jsr166 1.91 await(threadStarted);
562 : jsr166 1.21 assertEquals(1, p.getTaskCount());
563 : jsr166 1.84 assertEquals(0, p.getCompletedTaskCount());
564 :     for (int i = 0; i < TASKS; i++) {
565 :     assertEquals(1 + i, p.getTaskCount());
566 :     p.execute(new CheckedRunnable() {
567 :     public void realRun() throws InterruptedException {
568 :     threadStarted.countDown();
569 :     assertEquals(1 + TASKS, p.getTaskCount());
570 : jsr166 1.89 await(done);
571 : jsr166 1.84 }});
572 :     }
573 :     assertEquals(1 + TASKS, p.getTaskCount());
574 :     assertEquals(0, p.getCompletedTaskCount());
575 : jsr166 1.21 }
576 : jsr166 1.84 assertEquals(1 + TASKS, p.getTaskCount());
577 :     assertEquals(1 + TASKS, p.getCompletedTaskCount());
578 : dl 1.1 }
579 : jsr166 1.2
580 : dl 1.1 /**
581 : jsr166 1.28 * isShutdown is false before shutdown, true after
582 : dl 1.1 */
583 :     public void testIsShutdown() {
584 : jsr166 1.68 final ThreadPoolExecutor p =
585 :     new CustomTPE(1, 1,
586 :     LONG_DELAY_MS, MILLISECONDS,
587 :     new ArrayBlockingQueue<Runnable>(10));
588 :     try (PoolCleaner cleaner = cleaner(p)) {
589 :     assertFalse(p.isShutdown());
590 :     try { p.shutdown(); } catch (SecurityException ok) { return; }
591 :     assertTrue(p.isShutdown());
592 :     }
593 : dl 1.1 }
594 :    
595 :     /**
596 : jsr166 1.19 * isTerminated is false before termination, true after
597 : dl 1.1 */
598 : jsr166 1.5 public void testIsTerminated() throws InterruptedException {
599 : jsr166 1.21 final ThreadPoolExecutor p =
600 :     new CustomTPE(1, 1,
601 :     LONG_DELAY_MS, MILLISECONDS,
602 :     new ArrayBlockingQueue<Runnable>(10));
603 : jsr166 1.69 try (PoolCleaner cleaner = cleaner(p)) {
604 :     final CountDownLatch threadStarted = new CountDownLatch(1);
605 :     final CountDownLatch done = new CountDownLatch(1);
606 : jsr166 1.21 assertFalse(p.isTerminating());
607 :     p.execute(new CheckedRunnable() {
608 :     public void realRun() throws InterruptedException {
609 : jsr166 1.24 assertFalse(p.isTerminating());
610 : jsr166 1.21 threadStarted.countDown();
611 : jsr166 1.89 await(done);
612 : jsr166 1.21 }});
613 : jsr166 1.91 await(threadStarted);
614 : jsr166 1.21 assertFalse(p.isTerminating());
615 :     done.countDown();
616 :     try { p.shutdown(); } catch (SecurityException ok) { return; }
617 : jsr166 1.69 assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
618 :     assertTrue(p.isTerminated());
619 :     assertFalse(p.isTerminating());
620 : jsr166 1.21 }
621 : dl 1.1 }
622 :    
623 :     /**
624 : jsr166 1.19 * isTerminating is not true when running or when terminated
625 : dl 1.1 */
626 : jsr166 1.5 public void testIsTerminating() throws InterruptedException {
627 : jsr166 1.21 final ThreadPoolExecutor p =
628 :     new CustomTPE(1, 1,
629 :     LONG_DELAY_MS, MILLISECONDS,
630 :     new ArrayBlockingQueue<Runnable>(10));
631 : jsr166 1.70 try (PoolCleaner cleaner = cleaner(p)) {
632 :     final CountDownLatch threadStarted = new CountDownLatch(1);
633 :     final CountDownLatch done = new CountDownLatch(1);
634 : jsr166 1.21 assertFalse(p.isTerminating());
635 :     p.execute(new CheckedRunnable() {
636 :     public void realRun() throws InterruptedException {
637 : jsr166 1.23 assertFalse(p.isTerminating());
638 : jsr166 1.21 threadStarted.countDown();
639 : jsr166 1.89 await(done);
640 : jsr166 1.21 }});
641 : jsr166 1.91 await(threadStarted);
642 : jsr166 1.21 assertFalse(p.isTerminating());
643 :     done.countDown();
644 :     try { p.shutdown(); } catch (SecurityException ok) { return; }
645 : jsr166 1.70 assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
646 :     assertTrue(p.isTerminated());
647 :     assertFalse(p.isTerminating());
648 : jsr166 1.21 }
649 : dl 1.1 }
650 :    
651 :     /**
652 :     * getQueue returns the work queue, which contains queued tasks
653 :     */
654 : jsr166 1.5 public void testGetQueue() throws InterruptedException {
655 : jsr166 1.92 final CountDownLatch done = new CountDownLatch(1);
656 : jsr166 1.97 final BlockingQueue<Runnable> q = new ArrayBlockingQueue<>(10);
657 : jsr166 1.21 final ThreadPoolExecutor p =
658 :     new CustomTPE(1, 1,
659 :     LONG_DELAY_MS, MILLISECONDS,
660 :     q);
661 : jsr166 1.92 try (PoolCleaner cleaner = cleaner(p, done)) {
662 : jsr166 1.71 final CountDownLatch threadStarted = new CountDownLatch(1);
663 : jsr166 1.21 FutureTask[] tasks = new FutureTask[5];
664 :     for (int i = 0; i < tasks.length; i++) {
665 : jsr166 1.97 Callable<Boolean> task = new CheckedCallable<Boolean>() {
666 : jsr166 1.21 public Boolean realCall() throws InterruptedException {
667 :     threadStarted.countDown();
668 :     assertSame(q, p.getQueue());
669 : jsr166 1.89 await(done);
670 : jsr166 1.21 return Boolean.TRUE;
671 :     }};
672 :     tasks[i] = new FutureTask(task);
673 :     p.execute(tasks[i]);
674 :     }
675 : jsr166 1.91 await(threadStarted);
676 : jsr166 1.21 assertSame(q, p.getQueue());
677 :     assertFalse(q.contains(tasks[0]));
678 :     assertTrue(q.contains(tasks[tasks.length - 1]));
679 :     assertEquals(tasks.length - 1, q.size());
680 : dl 1.1 }
681 :     }
682 :    
683 :     /**
684 :     * remove(task) removes queued task, and fails to remove active task
685 :     */
686 : jsr166 1.5 public void testRemove() throws InterruptedException {
687 : jsr166 1.92 final CountDownLatch done = new CountDownLatch(1);
688 : jsr166 1.97 BlockingQueue<Runnable> q = new ArrayBlockingQueue<>(10);
689 : jsr166 1.21 final ThreadPoolExecutor p =
690 :     new CustomTPE(1, 1,
691 :     LONG_DELAY_MS, MILLISECONDS,
692 :     q);
693 : jsr166 1.92 try (PoolCleaner cleaner = cleaner(p, done)) {
694 : jsr166 1.72 Runnable[] tasks = new Runnable[6];
695 :     final CountDownLatch threadStarted = new CountDownLatch(1);
696 : jsr166 1.21 for (int i = 0; i < tasks.length; i++) {
697 :     tasks[i] = new CheckedRunnable() {
698 : jsr166 1.72 public void realRun() throws InterruptedException {
699 :     threadStarted.countDown();
700 : jsr166 1.89 await(done);
701 : jsr166 1.72 }};
702 : jsr166 1.21 p.execute(tasks[i]);
703 :     }
704 : jsr166 1.91 await(threadStarted);
705 : jsr166 1.21 assertFalse(p.remove(tasks[0]));
706 : dl 1.1 assertTrue(q.contains(tasks[4]));
707 :     assertTrue(q.contains(tasks[3]));
708 : jsr166 1.21 assertTrue(p.remove(tasks[4]));
709 :     assertFalse(p.remove(tasks[4]));
710 : dl 1.1 assertFalse(q.contains(tasks[4]));
711 :     assertTrue(q.contains(tasks[3]));
712 : jsr166 1.21 assertTrue(p.remove(tasks[3]));
713 : dl 1.1 assertFalse(q.contains(tasks[3]));
714 :     }
715 :     }
716 :    
717 :     /**
718 : jsr166 1.19 * purge removes cancelled tasks from the queue
719 : dl 1.1 */
720 : jsr166 1.21 public void testPurge() throws InterruptedException {
721 :     final CountDownLatch threadStarted = new CountDownLatch(1);
722 :     final CountDownLatch done = new CountDownLatch(1);
723 : jsr166 1.97 final BlockingQueue<Runnable> q = new ArrayBlockingQueue<>(10);
724 : jsr166 1.21 final ThreadPoolExecutor p =
725 :     new CustomTPE(1, 1,
726 :     LONG_DELAY_MS, MILLISECONDS,
727 :     q);
728 : jsr166 1.85 try (PoolCleaner cleaner = cleaner(p, done)) {
729 : jsr166 1.72 FutureTask[] tasks = new FutureTask[5];
730 : jsr166 1.21 for (int i = 0; i < tasks.length; i++) {
731 : jsr166 1.97 Callable<Boolean> task = new CheckedCallable<Boolean>() {
732 : jsr166 1.21 public Boolean realCall() throws InterruptedException {
733 :     threadStarted.countDown();
734 : jsr166 1.89 await(done);
735 : jsr166 1.21 return Boolean.TRUE;
736 :     }};
737 :     tasks[i] = new FutureTask(task);
738 :     p.execute(tasks[i]);
739 :     }
740 : jsr166 1.91 await(threadStarted);
741 : jsr166 1.21 assertEquals(tasks.length, p.getTaskCount());
742 :     assertEquals(tasks.length - 1, q.size());
743 :     assertEquals(1L, p.getActiveCount());
744 :     assertEquals(0L, p.getCompletedTaskCount());
745 :     tasks[4].cancel(true);
746 :     tasks[3].cancel(false);
747 :     p.purge();
748 :     assertEquals(tasks.length - 3, q.size());
749 :     assertEquals(tasks.length - 2, p.getTaskCount());
750 :     p.purge(); // Nothing to do
751 :     assertEquals(tasks.length - 3, q.size());
752 :     assertEquals(tasks.length - 2, p.getTaskCount());
753 :     }
754 : dl 1.1 }
755 :    
756 :     /**
757 : jsr166 1.40 * shutdownNow returns a list containing tasks that were not run,
758 :     * and those tasks are drained from the queue
759 : dl 1.1 */
760 : jsr166 1.41 public void testShutdownNow() throws InterruptedException {
761 :     final int poolSize = 2;
762 :     final int count = 5;
763 :     final AtomicInteger ran = new AtomicInteger(0);
764 : jsr166 1.80 final ThreadPoolExecutor p =
765 : jsr166 1.81 new CustomTPE(poolSize, poolSize,
766 :     LONG_DELAY_MS, MILLISECONDS,
767 : jsr166 1.41 new ArrayBlockingQueue<Runnable>(10));
768 : jsr166 1.83 final CountDownLatch threadsStarted = new CountDownLatch(poolSize);
769 : jsr166 1.43 Runnable waiter = new CheckedRunnable() { public void realRun() {
770 : jsr166 1.41 threadsStarted.countDown();
771 : dl 1.1 try {
772 : jsr166 1.41 MILLISECONDS.sleep(2 * LONG_DELAY_MS);
773 :     } catch (InterruptedException success) {}
774 :     ran.getAndIncrement();
775 :     }};
776 :     for (int i = 0; i < count; i++)
777 :     p.execute(waiter);
778 : jsr166 1.90 await(threadsStarted);
779 : jsr166 1.42 assertEquals(poolSize, p.getActiveCount());
780 :     assertEquals(0, p.getCompletedTaskCount());
781 : jsr166 1.41 final List<Runnable> queuedTasks;
782 :     try {
783 :     queuedTasks = p.shutdownNow();
784 :     } catch (SecurityException ok) {
785 :     return; // Allowed in case test doesn't have privs
786 : dl 1.1 }
787 : jsr166 1.21 assertTrue(p.isShutdown());
788 : jsr166 1.40 assertTrue(p.getQueue().isEmpty());
789 : jsr166 1.41 assertEquals(count - poolSize, queuedTasks.size());
790 :     assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
791 :     assertTrue(p.isTerminated());
792 :     assertEquals(poolSize, ran.get());
793 : jsr166 1.42 assertEquals(poolSize, p.getCompletedTaskCount());
794 : dl 1.1 }
795 :    
796 :     // Exception Tests
797 :    
798 : jsr166 1.2 /**
799 :     * Constructor throws if corePoolSize argument is less than zero
800 : dl 1.1 */
801 :     public void testConstructor1() {
802 :     try {
803 : jsr166 1.36 new CustomTPE(-1, 1, 1L, SECONDS,
804 :     new ArrayBlockingQueue<Runnable>(10));
805 : dl 1.1 shouldThrow();
806 : jsr166 1.5 } catch (IllegalArgumentException success) {}
807 : dl 1.1 }
808 : jsr166 1.2
809 :     /**
810 :     * Constructor throws if maximumPoolSize is less than zero
811 : dl 1.1 */
812 :     public void testConstructor2() {
813 :     try {
814 : jsr166 1.36 new CustomTPE(1, -1, 1L, SECONDS,
815 :     new ArrayBlockingQueue<Runnable>(10));
816 : dl 1.1 shouldThrow();
817 : jsr166 1.5 } catch (IllegalArgumentException success) {}
818 : dl 1.1 }
819 : jsr166 1.2
820 :     /**
821 :     * Constructor throws if maximumPoolSize is equal to zero
822 : dl 1.1 */
823 :     public void testConstructor3() {
824 :     try {
825 : jsr166 1.36 new CustomTPE(1, 0, 1L, SECONDS,
826 :     new ArrayBlockingQueue<Runnable>(10));
827 : dl 1.1 shouldThrow();
828 : jsr166 1.5 } catch (IllegalArgumentException success) {}
829 : dl 1.1 }
830 :    
831 : jsr166 1.2 /**
832 :     * Constructor throws if keepAliveTime is less than zero
833 : dl 1.1 */
834 :     public void testConstructor4() {
835 :     try {
836 : jsr166 1.36 new CustomTPE(1, 2, -1L, SECONDS,
837 :     new ArrayBlockingQueue<Runnable>(10));
838 : dl 1.1 shouldThrow();
839 : jsr166 1.5 } catch (IllegalArgumentException success) {}
840 : dl 1.1 }
841 :    
842 : jsr166 1.2 /**
843 :     * Constructor throws if corePoolSize is greater than the maximumPoolSize
844 : dl 1.1 */
845 :     public void testConstructor5() {
846 :     try {
847 : jsr166 1.36 new CustomTPE(2, 1, 1L, SECONDS,
848 :     new ArrayBlockingQueue<Runnable>(10));
849 : dl 1.1 shouldThrow();
850 : jsr166 1.5 } catch (IllegalArgumentException success) {}
851 : dl 1.1 }
852 : jsr166 1.2
853 :     /**
854 :     * Constructor throws if workQueue is set to null
855 : dl 1.1 */
856 :     public void testConstructorNullPointerException() {
857 :     try {
858 : jsr166 1.36 new CustomTPE(1, 2, 1L, SECONDS, null);
859 : dl 1.1 shouldThrow();
860 : jsr166 1.5 } catch (NullPointerException success) {}
861 : dl 1.1 }
862 :    
863 : jsr166 1.2 /**
864 :     * Constructor throws if corePoolSize argument is less than zero
865 : dl 1.1 */
866 :     public void testConstructor6() {
867 :     try {
868 : jsr166 1.36 new CustomTPE(-1, 1, 1L, SECONDS,
869 :     new ArrayBlockingQueue<Runnable>(10),
870 :     new SimpleThreadFactory());
871 : dl 1.1 shouldThrow();
872 : jsr166 1.4 } catch (IllegalArgumentException success) {}
873 : dl 1.1 }
874 : jsr166 1.2
875 :     /**
876 :     * Constructor throws if maximumPoolSize is less than zero
877 : dl 1.1 */
878 :     public void testConstructor7() {
879 :     try {
880 : jsr166 1.36 new CustomTPE(1,-1, 1L, SECONDS,
881 :     new ArrayBlockingQueue<Runnable>(10),
882 :     new SimpleThreadFactory());
883 : dl 1.1 shouldThrow();
884 : jsr166 1.5 } catch (IllegalArgumentException success) {}
885 : dl 1.1 }
886 :    
887 : jsr166 1.2 /**
888 :     * Constructor throws if maximumPoolSize is equal to zero
889 : dl 1.1 */
890 :     public void testConstructor8() {
891 :     try {
892 : jsr166 1.36 new CustomTPE(1, 0, 1L, SECONDS,
893 :     new ArrayBlockingQueue<Runnable>(10),
894 :     new SimpleThreadFactory());
895 : dl 1.1 shouldThrow();
896 : jsr166 1.5 } catch (IllegalArgumentException success) {}
897 : dl 1.1 }
898 :    
899 : jsr166 1.2 /**
900 :     * Constructor throws if keepAliveTime is less than zero
901 : dl 1.1 */
902 :     public void testConstructor9() {
903 :     try {
904 : jsr166 1.36 new CustomTPE(1, 2, -1L, SECONDS,
905 :     new ArrayBlockingQueue<Runnable>(10),
906 :     new SimpleThreadFactory());
907 : dl 1.1 shouldThrow();
908 : jsr166 1.5 } catch (IllegalArgumentException success) {}
909 : dl 1.1 }
910 :    
911 : jsr166 1.2 /**
912 :     * Constructor throws if corePoolSize is greater than the maximumPoolSize
913 : dl 1.1 */
914 :     public void testConstructor10() {
915 :     try {
916 : jsr166 1.36 new CustomTPE(2, 1, 1L, SECONDS,
917 :     new ArrayBlockingQueue<Runnable>(10),
918 :     new SimpleThreadFactory());
919 : dl 1.1 shouldThrow();
920 : jsr166 1.5 } catch (IllegalArgumentException success) {}
921 : dl 1.1 }
922 :    
923 : jsr166 1.2 /**
924 :     * Constructor throws if workQueue is set to null
925 : dl 1.1 */
926 :     public void testConstructorNullPointerException2() {
927 :     try {
928 : jsr166 1.36 new CustomTPE(1, 2, 1L, SECONDS, null, new SimpleThreadFactory());
929 : dl 1.1 shouldThrow();
930 : jsr166 1.5 } catch (NullPointerException success) {}
931 : dl 1.1 }
932 :    
933 : jsr166 1.2 /**
934 :     * Constructor throws if threadFactory is set to null
935 : dl 1.1 */
936 :     public void testConstructorNullPointerException3() {
937 :     try {
938 : jsr166 1.36 new CustomTPE(1, 2, 1L, SECONDS,
939 :     new ArrayBlockingQueue<Runnable>(10),
940 :     (ThreadFactory) null);
941 : dl 1.1 shouldThrow();
942 : jsr166 1.5 } catch (NullPointerException success) {}
943 : dl 1.1 }
944 : jsr166 1.2
945 :     /**
946 :     * Constructor throws if corePoolSize argument is less than zero
947 : dl 1.1 */
948 :     public void testConstructor11() {
949 :     try {
950 : jsr166 1.36 new CustomTPE(-1, 1, 1L, SECONDS,
951 :     new ArrayBlockingQueue<Runnable>(10),
952 :     new NoOpREHandler());
953 : dl 1.1 shouldThrow();
954 : jsr166 1.5 } catch (IllegalArgumentException success) {}
955 : dl 1.1 }
956 :    
957 : jsr166 1.2 /**
958 :     * Constructor throws if maximumPoolSize is less than zero
959 : dl 1.1 */
960 :     public void testConstructor12() {
961 :     try {
962 : jsr166 1.36 new CustomTPE(1, -1, 1L, SECONDS,
963 :     new ArrayBlockingQueue<Runnable>(10),
964 :     new NoOpREHandler());
965 : dl 1.1 shouldThrow();
966 : jsr166 1.5 } catch (IllegalArgumentException success) {}
967 : dl 1.1 }
968 :    
969 : jsr166 1.2 /**
970 :     * Constructor throws if maximumPoolSize is equal to zero
971 : dl 1.1 */
972 :     public void testConstructor13() {
973 :     try {
974 : jsr166 1.36 new CustomTPE(1, 0, 1L, SECONDS,
975 :     new ArrayBlockingQueue<Runnable>(10),
976 :     new NoOpREHandler());
977 : dl 1.1 shouldThrow();
978 : jsr166 1.5 } catch (IllegalArgumentException success) {}
979 : dl 1.1 }
980 :    
981 : jsr166 1.2 /**
982 :     * Constructor throws if keepAliveTime is less than zero
983 : dl 1.1 */
984 :     public void testConstructor14() {
985 :     try {
986 : jsr166 1.36 new CustomTPE(1, 2, -1L, SECONDS,
987 :     new ArrayBlockingQueue<Runnable>(10),
988 :     new NoOpREHandler());
989 : dl 1.1 shouldThrow();
990 : jsr166 1.5 } catch (IllegalArgumentException success) {}
991 : dl 1.1 }
992 :    
993 : jsr166 1.2 /**
994 :     * Constructor throws if corePoolSize is greater than the maximumPoolSize
995 : dl 1.1 */
996 :     public void testConstructor15() {
997 :     try {
998 : jsr166 1.36 new CustomTPE(2, 1, 1L, SECONDS,
999 :     new ArrayBlockingQueue<Runnable>(10),
1000 :     new NoOpREHandler());
1001 : dl 1.1 shouldThrow();
1002 : jsr166 1.5 } catch (IllegalArgumentException success) {}
1003 : dl 1.1 }
1004 :    
1005 : jsr166 1.2 /**
1006 :     * Constructor throws if workQueue is set to null
1007 : dl 1.1 */
1008 :     public void testConstructorNullPointerException4() {
1009 :     try {
1010 : jsr166 1.36 new CustomTPE(1, 2, 1L, SECONDS,
1011 :     null,
1012 :     new NoOpREHandler());
1013 : dl 1.1 shouldThrow();
1014 : jsr166 1.5 } catch (NullPointerException success) {}
1015 : dl 1.1 }
1016 :    
1017 : jsr166 1.2 /**
1018 :     * Constructor throws if handler is set to null
1019 : dl 1.1 */
1020 :     public void testConstructorNullPointerException5() {
1021 :     try {
1022 : jsr166 1.36 new CustomTPE(1, 2, 1L, SECONDS,
1023 :     new ArrayBlockingQueue<Runnable>(10),
1024 :     (RejectedExecutionHandler) null);
1025 : dl 1.1 shouldThrow();
1026 : jsr166 1.5 } catch (NullPointerException success) {}
1027 : dl 1.1 }
1028 :    
1029 : jsr166 1.2 /**
1030 :     * Constructor throws if corePoolSize argument is less than zero
1031 : dl 1.1 */
1032 :     public void testConstructor16() {
1033 :     try {
1034 : jsr166 1.36 new CustomTPE(-1, 1, 1L, SECONDS,
1035 :     new ArrayBlockingQueue<Runnable>(10),
1036 :     new SimpleThreadFactory(),
1037 :     new NoOpREHandler());
1038 : dl 1.1 shouldThrow();
1039 : jsr166 1.5 } catch (IllegalArgumentException success) {}
1040 : dl 1.1 }
1041 :    
1042 : jsr166 1.2 /**
1043 :     * Constructor throws if maximumPoolSize is less than zero
1044 : dl 1.1 */
1045 :     public void testConstructor17() {
1046 :     try {
1047 : jsr166 1.36 new CustomTPE(1, -1, 1L, SECONDS,
1048 :     new ArrayBlockingQueue<Runnable>(10),
1049 :     new SimpleThreadFactory(),
1050 :     new NoOpREHandler());
1051 : dl 1.1 shouldThrow();
1052 : jsr166 1.5 } catch (IllegalArgumentException success) {}
1053 : dl 1.1 }
1054 :    
1055 : jsr166 1.2 /**
1056 :     * Constructor throws if maximumPoolSize is equal to zero
1057 : dl 1.1 */
1058 :     public void testConstructor18() {
1059 :     try {
1060 : jsr166 1.36 new CustomTPE(1, 0, 1L, SECONDS,
1061 :     new ArrayBlockingQueue<Runnable>(10),
1062 :     new SimpleThreadFactory(),
1063 :     new NoOpREHandler());
1064 : dl 1.1 shouldThrow();
1065 : jsr166 1.5 } catch (IllegalArgumentException success) {}
1066 : dl 1.1 }
1067 :    
1068 : jsr166 1.2 /**
1069 :     * Constructor throws if keepAliveTime is less than zero
1070 : dl 1.1 */
1071 :     public void testConstructor19() {
1072 :     try {
1073 : jsr166 1.36 new CustomTPE(1, 2, -1L, SECONDS,
1074 :     new ArrayBlockingQueue<Runnable>(10),
1075 :     new SimpleThreadFactory(),
1076 :     new NoOpREHandler());
1077 : dl 1.1 shouldThrow();
1078 : jsr166 1.5 } catch (IllegalArgumentException success) {}
1079 : dl 1.1 }
1080 :    
1081 : jsr166 1.2 /**
1082 :     * Constructor throws if corePoolSize is greater than the maximumPoolSize
1083 : dl 1.1 */
1084 :     public void testConstructor20() {
1085 :     try {
1086 : jsr166 1.36 new CustomTPE(2, 1, 1L, SECONDS,
1087 :     new ArrayBlockingQueue<Runnable>(10),
1088 :     new SimpleThreadFactory(),
1089 :     new NoOpREHandler());
1090 : dl 1.1 shouldThrow();
1091 : jsr166 1.5 } catch (IllegalArgumentException success) {}
1092 : dl 1.1 }
1093 :    
1094 : jsr166 1.2 /**
1095 : jsr166 1.20 * Constructor throws if workQueue is null
1096 : dl 1.1 */
1097 :     public void testConstructorNullPointerException6() {
1098 :     try {
1099 : jsr166 1.36 new CustomTPE(1, 2, 1L, SECONDS,
1100 :     null,
1101 :     new SimpleThreadFactory(),
1102 :     new NoOpREHandler());
1103 : dl 1.1 shouldThrow();
1104 : jsr166 1.5 } catch (NullPointerException success) {}
1105 : dl 1.1 }
1106 :    
1107 : jsr166 1.2 /**
1108 : jsr166 1.20 * Constructor throws if handler is null
1109 : dl 1.1 */
1110 :     public void testConstructorNullPointerException7() {
1111 :     try {
1112 : jsr166 1.36 new CustomTPE(1, 2, 1L, SECONDS,
1113 :     new ArrayBlockingQueue<Runnable>(10),
1114 :     new SimpleThreadFactory(),
1115 :     (RejectedExecutionHandler) null);
1116 : dl 1.1 shouldThrow();
1117 : jsr166 1.5 } catch (NullPointerException success) {}
1118 : dl 1.1 }
1119 :    
1120 : jsr166 1.2 /**
1121 : jsr166 1.20 * Constructor throws if ThreadFactory is null
1122 : dl 1.1 */
1123 :     public void testConstructorNullPointerException8() {
1124 :     try {
1125 : jsr166 1.36 new CustomTPE(1, 2, 1L, SECONDS,
1126 : jsr166 1.21 new ArrayBlockingQueue<Runnable>(10),
1127 :     (ThreadFactory) null,
1128 :     new NoOpREHandler());
1129 : dl 1.1 shouldThrow();
1130 : jsr166 1.5 } catch (NullPointerException success) {}
1131 : dl 1.1 }
1132 : jsr166 1.2
1133 : dl 1.1 /**
1134 : jsr166 1.19 * execute throws RejectedExecutionException if saturated.
1135 : dl 1.1 */
1136 :     public void testSaturatedExecute() {
1137 : jsr166 1.92 final CountDownLatch done = new CountDownLatch(1);
1138 : jsr166 1.73 final ThreadPoolExecutor p =
1139 : jsr166 1.21 new CustomTPE(1, 1,
1140 :     LONG_DELAY_MS, MILLISECONDS,
1141 :     new ArrayBlockingQueue<Runnable>(1));
1142 : jsr166 1.92 try (PoolCleaner cleaner = cleaner(p, done)) {
1143 : jsr166 1.21 Runnable task = new CheckedRunnable() {
1144 :     public void realRun() throws InterruptedException {
1145 : jsr166 1.89 await(done);
1146 : jsr166 1.21 }};
1147 :     for (int i = 0; i < 2; ++i)
1148 :     p.execute(task);
1149 :     for (int i = 0; i < 2; ++i) {
1150 :     try {
1151 :     p.execute(task);
1152 :     shouldThrow();
1153 :     } catch (RejectedExecutionException success) {}
1154 :     assertTrue(p.getTaskCount() <= 2);
1155 : dl 1.1 }
1156 : jsr166 1.21 }
1157 : dl 1.1 }
1158 :    
1159 :     /**
1160 : jsr166 1.19 * executor using CallerRunsPolicy runs task if saturated.
1161 : dl 1.1 */
1162 :     public void testSaturatedExecute2() {
1163 : jsr166 1.92 final CountDownLatch done = new CountDownLatch(1);
1164 : jsr166 1.74 final ThreadPoolExecutor p =
1165 :     new CustomTPE(1, 1,
1166 :     LONG_DELAY_MS, MILLISECONDS,
1167 :     new ArrayBlockingQueue<Runnable>(1),
1168 :     new CustomTPE.CallerRunsPolicy());
1169 : jsr166 1.92 try (PoolCleaner cleaner = cleaner(p, done)) {
1170 : jsr166 1.74 Runnable blocker = new CheckedRunnable() {
1171 :     public void realRun() throws InterruptedException {
1172 : jsr166 1.89 await(done);
1173 : jsr166 1.74 }};
1174 :     p.execute(blocker);
1175 : dl 1.1 TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
1176 : jsr166 1.74 for (int i = 0; i < tasks.length; i++)
1177 : dl 1.1 tasks[i] = new TrackedNoOpRunnable();
1178 : jsr166 1.74 for (int i = 0; i < tasks.length; i++)
1179 : dl 1.1 p.execute(tasks[i]);
1180 : jsr166 1.74 for (int i = 1; i < tasks.length; i++)
1181 : dl 1.1 assertTrue(tasks[i].done);
1182 : jsr166 1.75 assertFalse(tasks[0].done); // waiting in queue
1183 : dl 1.1 }
1184 :     }
1185 :    
1186 :     /**
1187 : jsr166 1.19 * executor using DiscardPolicy drops task if saturated.
1188 : dl 1.1 */
1189 :     public void testSaturatedExecute3() {
1190 : jsr166 1.75 final TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
1191 :     for (int i = 0; i < tasks.length; ++i)
1192 :     tasks[i] = new TrackedNoOpRunnable();
1193 : jsr166 1.92 final CountDownLatch done = new CountDownLatch(1);
1194 : jsr166 1.75 final ThreadPoolExecutor p =
1195 : jsr166 1.21 new CustomTPE(1, 1,
1196 :     LONG_DELAY_MS, MILLISECONDS,
1197 :     new ArrayBlockingQueue<Runnable>(1),
1198 : jsr166 1.75 new CustomTPE.DiscardPolicy());
1199 : jsr166 1.92 try (PoolCleaner cleaner = cleaner(p, done)) {
1200 : jsr166 1.75 p.execute(awaiter(done));
1201 :    
1202 : jsr166 1.21 for (TrackedNoOpRunnable task : tasks)
1203 :     p.execute(task);
1204 : jsr166 1.75 for (int i = 1; i < tasks.length; i++)
1205 :     assertFalse(tasks[i].done);
1206 : dl 1.1 }
1207 : jsr166 1.75 for (int i = 1; i < tasks.length; i++)
1208 :     assertFalse(tasks[i].done);
1209 :     assertTrue(tasks[0].done); // was waiting in queue
1210 : dl 1.1 }
1211 :    
1212 :     /**
1213 : jsr166 1.19 * executor using DiscardOldestPolicy drops oldest task if saturated.
1214 : dl 1.1 */
1215 :     public void testSaturatedExecute4() {
1216 : jsr166 1.76 final CountDownLatch done = new CountDownLatch(1);
1217 :     LatchAwaiter r1 = awaiter(done);
1218 :     LatchAwaiter r2 = awaiter(done);
1219 :     LatchAwaiter r3 = awaiter(done);
1220 :     final ThreadPoolExecutor p =
1221 :     new CustomTPE(1, 1,
1222 :     LONG_DELAY_MS, MILLISECONDS,
1223 :     new ArrayBlockingQueue<Runnable>(1),
1224 :     new CustomTPE.DiscardOldestPolicy());
1225 : jsr166 1.92 try (PoolCleaner cleaner = cleaner(p, done)) {
1226 : jsr166 1.76 assertEquals(LatchAwaiter.NEW, r1.state);
1227 :     assertEquals(LatchAwaiter.NEW, r2.state);
1228 :     assertEquals(LatchAwaiter.NEW, r3.state);
1229 :     p.execute(r1);
1230 : dl 1.1 p.execute(r2);
1231 :     assertTrue(p.getQueue().contains(r2));
1232 :     p.execute(r3);
1233 :     assertFalse(p.getQueue().contains(r2));
1234 :     assertTrue(p.getQueue().contains(r3));
1235 :     }
1236 : jsr166 1.76 assertEquals(LatchAwaiter.DONE, r1.state);
1237 :     assertEquals(LatchAwaiter.NEW, r2.state);
1238 :     assertEquals(LatchAwaiter.DONE, r3.state);
1239 : dl 1.1 }
1240 :    
1241 :     /**
1242 : jsr166 1.19 * execute throws RejectedExecutionException if shutdown
1243 : dl 1.1 */
1244 :     public void testRejectedExecutionExceptionOnShutdown() {
1245 : jsr166 1.77 final ThreadPoolExecutor p =
1246 :     new CustomTPE(1, 1,
1247 :     LONG_DELAY_MS, MILLISECONDS,
1248 :     new ArrayBlockingQueue<Runnable>(1));
1249 : jsr166 1.21 try { p.shutdown(); } catch (SecurityException ok) { return; }
1250 : jsr166 1.77 try (PoolCleaner cleaner = cleaner(p)) {
1251 :     try {
1252 :     p.execute(new NoOpRunnable());
1253 :     shouldThrow();
1254 :     } catch (RejectedExecutionException success) {}
1255 :     }
1256 : dl 1.1 }
1257 :    
1258 :     /**
1259 : jsr166 1.19 * execute using CallerRunsPolicy drops task on shutdown
1260 : dl 1.1 */
1261 :     public void testCallerRunsOnShutdown() {
1262 : jsr166 1.79 final ThreadPoolExecutor p =
1263 :     new CustomTPE(1, 1,
1264 :     LONG_DELAY_MS, MILLISECONDS,
1265 :     new ArrayBlockingQueue<Runnable>(1),
1266 :     new CustomTPE.CallerRunsPolicy());
1267 : jsr166 1.3 try { p.shutdown(); } catch (SecurityException ok) { return; }
1268 : jsr166 1.78 try (PoolCleaner cleaner = cleaner(p)) {
1269 : dl 1.1 TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1270 : jsr166 1.8 p.execute(r);
1271 : dl 1.1 assertFalse(r.done);
1272 :     }
1273 :     }
1274 :    
1275 :     /**
1276 : jsr166 1.19 * execute using DiscardPolicy drops task on shutdown
1277 : dl 1.1 */
1278 :     public void testDiscardOnShutdown() {
1279 : jsr166 1.79 final ThreadPoolExecutor p =
1280 :     new CustomTPE(1, 1,
1281 :     LONG_DELAY_MS, MILLISECONDS,
1282 :     new ArrayBlockingQueue<Runnable>(1),
1283 :     new CustomTPE.DiscardPolicy());
1284 : jsr166 1.3 try { p.shutdown(); } catch (SecurityException ok) { return; }
1285 : jsr166 1.79 try (PoolCleaner cleaner = cleaner(p)) {
1286 : dl 1.1 TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1287 : jsr166 1.8 p.execute(r);
1288 : dl 1.1 assertFalse(r.done);
1289 :     }
1290 :     }
1291 :    
1292 :     /**
1293 : jsr166 1.19 * execute using DiscardOldestPolicy drops task on shutdown
1294 : dl 1.1 */
1295 :     public void testDiscardOldestOnShutdown() {
1296 : jsr166 1.79 final ThreadPoolExecutor p =
1297 :     new CustomTPE(1, 1,
1298 :     LONG_DELAY_MS, MILLISECONDS,
1299 :     new ArrayBlockingQueue<Runnable>(1),
1300 :     new CustomTPE.DiscardOldestPolicy());
1301 : dl 1.1
1302 : jsr166 1.3 try { p.shutdown(); } catch (SecurityException ok) { return; }
1303 : jsr166 1.79 try (PoolCleaner cleaner = cleaner(p)) {
1304 : dl 1.1 TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1305 : jsr166 1.8 p.execute(r);
1306 : dl 1.1 assertFalse(r.done);
1307 :     }
1308 :     }
1309 :    
1310 :     /**
1311 : jsr166 1.18 * execute(null) throws NPE
1312 : dl 1.1 */
1313 :     public void testExecuteNull() {
1314 : jsr166 1.79 final ThreadPoolExecutor p =
1315 :     new CustomTPE(1, 2,
1316 :     1L, SECONDS,
1317 : jsr166 1.37 new ArrayBlockingQueue<Runnable>(10));
1318 : jsr166 1.79 try (PoolCleaner cleaner = cleaner(p)) {
1319 :     try {
1320 :     p.execute(null);
1321 :     shouldThrow();
1322 :     } catch (NullPointerException success) {}
1323 :     }
1324 : dl 1.1 }
1325 : jsr166 1.2
1326 : dl 1.1 /**
1327 : jsr166 1.19 * setCorePoolSize of negative value throws IllegalArgumentException
1328 : dl 1.1 */
1329 :     public void testCorePoolSizeIllegalArgumentException() {
1330 : jsr166 1.80 final ThreadPoolExecutor p =
1331 : jsr166 1.81 new CustomTPE(1, 2,
1332 :     LONG_DELAY_MS, MILLISECONDS,
1333 :     new ArrayBlockingQueue<Runnable>(10));
1334 :     try (PoolCleaner cleaner = cleaner(p)) {
1335 :     try {
1336 :     p.setCorePoolSize(-1);
1337 :     shouldThrow();
1338 :     } catch (IllegalArgumentException success) {}
1339 : dl 1.1 }
1340 : jsr166 1.2 }
1341 : dl 1.1
1342 :     /**
1343 : jsr166 1.19 * setMaximumPoolSize(int) throws IllegalArgumentException
1344 :     * if given a value less the core pool size
1345 : jsr166 1.2 */
1346 : dl 1.1 public void testMaximumPoolSizeIllegalArgumentException() {
1347 : jsr166 1.80 final ThreadPoolExecutor p =
1348 : jsr166 1.81 new CustomTPE(2, 3,
1349 :     LONG_DELAY_MS, MILLISECONDS,
1350 :     new ArrayBlockingQueue<Runnable>(10));
1351 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(p)) {
1352 :     try {
1353 :     p.setMaximumPoolSize(1);
1354 :     shouldThrow();
1355 :     } catch (IllegalArgumentException success) {}
1356 : dl 1.1 }
1357 :     }
1358 : jsr166 1.2
1359 : dl 1.1 /**
1360 : jsr166 1.19 * setMaximumPoolSize throws IllegalArgumentException
1361 :     * if given a negative value
1362 : dl 1.1 */
1363 :     public void testMaximumPoolSizeIllegalArgumentException2() {
1364 : jsr166 1.80 final ThreadPoolExecutor p =
1365 : jsr166 1.81 new CustomTPE(2, 3,
1366 :     LONG_DELAY_MS,
1367 :     MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1368 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(p)) {
1369 :     try {
1370 :     p.setMaximumPoolSize(-1);
1371 :     shouldThrow();
1372 :     } catch (IllegalArgumentException success) {}
1373 : dl 1.1 }
1374 :     }
1375 : jsr166 1.2
1376 : dl 1.1 /**
1377 : jsr166 1.19 * setKeepAliveTime throws IllegalArgumentException
1378 :     * when given a negative value
1379 : dl 1.1 */
1380 :     public void testKeepAliveTimeIllegalArgumentException() {
1381 : jsr166 1.80 final ThreadPoolExecutor p =
1382 : jsr166 1.81 new CustomTPE(2, 3,
1383 :     LONG_DELAY_MS, MILLISECONDS,
1384 :     new ArrayBlockingQueue<Runnable>(10));
1385 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(p)) {
1386 :     try {
1387 :     p.setKeepAliveTime(-1, MILLISECONDS);
1388 :     shouldThrow();
1389 :     } catch (IllegalArgumentException success) {}
1390 : dl 1.1 }
1391 :     }
1392 :    
1393 :     /**
1394 :     * terminated() is called on termination
1395 :     */
1396 :     public void testTerminated() {
1397 : jsr166 1.21 CustomTPE p = new CustomTPE();
1398 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(p)) {
1399 :     try { p.shutdown(); } catch (SecurityException ok) { return; }
1400 :     assertTrue(p.terminatedCalled());
1401 :     assertTrue(p.isShutdown());
1402 :     }
1403 : dl 1.1 }
1404 :    
1405 :     /**
1406 :     * beforeExecute and afterExecute are called when executing task
1407 :     */
1408 : jsr166 1.5 public void testBeforeAfter() throws InterruptedException {
1409 : jsr166 1.21 CustomTPE p = new CustomTPE();
1410 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(p)) {
1411 : jsr166 1.30 final CountDownLatch done = new CountDownLatch(1);
1412 : jsr166 1.32 p.execute(new CheckedRunnable() {
1413 : jsr166 1.30 public void realRun() {
1414 :     done.countDown();
1415 : jsr166 1.32 }});
1416 : jsr166 1.30 await(p.afterCalled);
1417 :     assertEquals(0, done.getCount());
1418 :     assertTrue(p.afterCalled());
1419 :     assertTrue(p.beforeCalled());
1420 : dl 1.1 }
1421 :     }
1422 :    
1423 :     /**
1424 :     * completed submit of callable returns result
1425 :     */
1426 : jsr166 1.5 public void testSubmitCallable() throws Exception {
1427 : jsr166 1.80 final ExecutorService e =
1428 :     new CustomTPE(2, 2,
1429 :     LONG_DELAY_MS, MILLISECONDS,
1430 :     new ArrayBlockingQueue<Runnable>(10));
1431 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1432 : dl 1.1 Future<String> future = e.submit(new StringTask());
1433 :     String result = future.get();
1434 :     assertSame(TEST_STRING, result);
1435 :     }
1436 :     }
1437 :    
1438 :     /**
1439 :     * completed submit of runnable returns successfully
1440 :     */
1441 : jsr166 1.5 public void testSubmitRunnable() throws Exception {
1442 : jsr166 1.80 final ExecutorService e =
1443 :     new CustomTPE(2, 2,
1444 :     LONG_DELAY_MS, MILLISECONDS,
1445 :     new ArrayBlockingQueue<Runnable>(10));
1446 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1447 : dl 1.1 Future<?> future = e.submit(new NoOpRunnable());
1448 :     future.get();
1449 :     assertTrue(future.isDone());
1450 :     }
1451 :     }
1452 :    
1453 :     /**
1454 :     * completed submit of (runnable, result) returns result
1455 :     */
1456 : jsr166 1.5 public void testSubmitRunnable2() throws Exception {
1457 : jsr166 1.80 final ExecutorService e =
1458 :     new CustomTPE(2, 2,
1459 :     LONG_DELAY_MS, MILLISECONDS,
1460 :     new ArrayBlockingQueue<Runnable>(10));
1461 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1462 : dl 1.1 Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
1463 :     String result = future.get();
1464 :     assertSame(TEST_STRING, result);
1465 :     }
1466 :     }
1467 :    
1468 :     /**
1469 : jsr166 1.99 * invokeAny(null) throws NullPointerException
1470 : dl 1.1 */
1471 : jsr166 1.5 public void testInvokeAny1() throws Exception {
1472 : jsr166 1.80 final ExecutorService e =
1473 :     new CustomTPE(2, 2,
1474 :     LONG_DELAY_MS, MILLISECONDS,
1475 :     new ArrayBlockingQueue<Runnable>(10));
1476 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1477 :     try {
1478 :     e.invokeAny(null);
1479 :     shouldThrow();
1480 :     } catch (NullPointerException success) {}
1481 : dl 1.1 }
1482 :     }
1483 :    
1484 :     /**
1485 : jsr166 1.99 * invokeAny(empty collection) throws IllegalArgumentException
1486 : dl 1.1 */
1487 : jsr166 1.5 public void testInvokeAny2() throws Exception {
1488 : jsr166 1.80 final ExecutorService e =
1489 :     new CustomTPE(2, 2,
1490 :     LONG_DELAY_MS, MILLISECONDS,
1491 :     new ArrayBlockingQueue<Runnable>(10));
1492 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1493 :     try {
1494 :     e.invokeAny(new ArrayList<Callable<String>>());
1495 :     shouldThrow();
1496 :     } catch (IllegalArgumentException success) {}
1497 : dl 1.1 }
1498 :     }
1499 :    
1500 :     /**
1501 :     * invokeAny(c) throws NPE if c has null elements
1502 :     */
1503 : jsr166 1.5 public void testInvokeAny3() throws Exception {
1504 : jsr166 1.17 CountDownLatch latch = new CountDownLatch(1);
1505 : jsr166 1.80 final ExecutorService e =
1506 :     new CustomTPE(2, 2,
1507 :     LONG_DELAY_MS, MILLISECONDS,
1508 :     new ArrayBlockingQueue<Runnable>(10));
1509 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1510 : jsr166 1.97 List<Callable<String>> l = new ArrayList<>();
1511 : jsr166 1.82 l.add(latchAwaitingStringTask(latch));
1512 :     l.add(null);
1513 :     try {
1514 :     e.invokeAny(l);
1515 :     shouldThrow();
1516 :     } catch (NullPointerException success) {}
1517 : jsr166 1.5 latch.countDown();
1518 : dl 1.1 }
1519 :     }
1520 :    
1521 :     /**
1522 :     * invokeAny(c) throws ExecutionException if no task completes
1523 :     */
1524 : jsr166 1.5 public void testInvokeAny4() throws Exception {
1525 : jsr166 1.80 final ExecutorService e =
1526 :     new CustomTPE(2, 2,
1527 :     LONG_DELAY_MS, MILLISECONDS,
1528 :     new ArrayBlockingQueue<Runnable>(10));
1529 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1530 : jsr166 1.97 List<Callable<String>> l = new ArrayList<>();
1531 : jsr166 1.82 l.add(new NPETask());
1532 :     try {
1533 :     e.invokeAny(l);
1534 :     shouldThrow();
1535 :     } catch (ExecutionException success) {
1536 :     assertTrue(success.getCause() instanceof NullPointerException);
1537 :     }
1538 : dl 1.1 }
1539 :     }
1540 :    
1541 :     /**
1542 :     * invokeAny(c) returns result of some task
1543 :     */
1544 : jsr166 1.5 public void testInvokeAny5() throws Exception {
1545 : jsr166 1.80 final ExecutorService e =
1546 :     new CustomTPE(2, 2,
1547 :     LONG_DELAY_MS, MILLISECONDS,
1548 :     new ArrayBlockingQueue<Runnable>(10));
1549 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1550 : jsr166 1.97 List<Callable<String>> l = new ArrayList<>();
1551 : dl 1.1 l.add(new StringTask());
1552 :     l.add(new StringTask());
1553 :     String result = e.invokeAny(l);
1554 :     assertSame(TEST_STRING, result);
1555 :     }
1556 :     }
1557 :    
1558 :     /**
1559 :     * invokeAll(null) throws NPE
1560 :     */
1561 : jsr166 1.5 public void testInvokeAll1() throws Exception {
1562 : jsr166 1.80 final ExecutorService e =
1563 :     new CustomTPE(2, 2,
1564 :     LONG_DELAY_MS, MILLISECONDS,
1565 :     new ArrayBlockingQueue<Runnable>(10));
1566 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1567 :     try {
1568 :     e.invokeAll(null);
1569 :     shouldThrow();
1570 :     } catch (NullPointerException success) {}
1571 : dl 1.1 }
1572 :     }
1573 :    
1574 :     /**
1575 : jsr166 1.99 * invokeAll(empty collection) returns empty list
1576 : dl 1.1 */
1577 : jsr166 1.5 public void testInvokeAll2() throws Exception {
1578 : jsr166 1.80 final ExecutorService e =
1579 :     new CustomTPE(2, 2,
1580 :     LONG_DELAY_MS, MILLISECONDS,
1581 :     new ArrayBlockingQueue<Runnable>(10));
1582 : jsr166 1.99 final Collection<Callable<String>> emptyCollection
1583 :     = Collections.emptyList();
1584 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1585 : jsr166 1.99 List<Future<String>> r = e.invokeAll(emptyCollection);
1586 : dl 1.1 assertTrue(r.isEmpty());
1587 :     }
1588 :     }
1589 :    
1590 :     /**
1591 :     * invokeAll(c) throws NPE if c has null elements
1592 :     */
1593 : jsr166 1.5 public void testInvokeAll3() throws Exception {
1594 : jsr166 1.80 final ExecutorService e =
1595 :     new CustomTPE(2, 2,
1596 :     LONG_DELAY_MS, MILLISECONDS,
1597 :     new ArrayBlockingQueue<Runnable>(10));
1598 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1599 : jsr166 1.97 List<Callable<String>> l = new ArrayList<>();
1600 : jsr166 1.82 l.add(new StringTask());
1601 :     l.add(null);
1602 :     try {
1603 :     e.invokeAll(l);
1604 :     shouldThrow();
1605 :     } catch (NullPointerException success) {}
1606 : dl 1.1 }
1607 :     }
1608 :    
1609 :     /**
1610 :     * get of element of invokeAll(c) throws exception on failed task
1611 :     */
1612 : jsr166 1.5 public void testInvokeAll4() throws Exception {
1613 : jsr166 1.80 final ExecutorService e =
1614 :     new CustomTPE(2, 2,
1615 :     LONG_DELAY_MS, MILLISECONDS,
1616 :     new ArrayBlockingQueue<Runnable>(10));
1617 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1618 : jsr166 1.97 List<Callable<String>> l = new ArrayList<>();
1619 : jsr166 1.82 l.add(new NPETask());
1620 :     List<Future<String>> futures = e.invokeAll(l);
1621 :     assertEquals(1, futures.size());
1622 :     try {
1623 :     futures.get(0).get();
1624 :     shouldThrow();
1625 :     } catch (ExecutionException success) {
1626 :     assertTrue(success.getCause() instanceof NullPointerException);
1627 :     }
1628 : dl 1.1 }
1629 :     }
1630 :    
1631 :     /**
1632 :     * invokeAll(c) returns results of all completed tasks
1633 :     */
1634 : jsr166 1.5 public void testInvokeAll5() throws Exception {
1635 : jsr166 1.80 final ExecutorService e =
1636 :     new CustomTPE(2, 2,
1637 :     LONG_DELAY_MS, MILLISECONDS,
1638 :     new ArrayBlockingQueue<Runnable>(10));
1639 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1640 : jsr166 1.97 List<Callable<String>> l = new ArrayList<>();
1641 : dl 1.1 l.add(new StringTask());
1642 :     l.add(new StringTask());
1643 : jsr166 1.17 List<Future<String>> futures = e.invokeAll(l);
1644 :     assertEquals(2, futures.size());
1645 :     for (Future<String> future : futures)
1646 : jsr166 1.6 assertSame(TEST_STRING, future.get());
1647 : dl 1.1 }
1648 :     }
1649 :    
1650 :     /**
1651 :     * timed invokeAny(null) throws NPE
1652 :     */
1653 : jsr166 1.5 public void testTimedInvokeAny1() throws Exception {
1654 : jsr166 1.80 final ExecutorService e =
1655 :     new CustomTPE(2, 2,
1656 :     LONG_DELAY_MS, MILLISECONDS,
1657 :     new ArrayBlockingQueue<Runnable>(10));
1658 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1659 :     try {
1660 : jsr166 1.99 e.invokeAny(null, randomTimeout(), randomTimeUnit());
1661 : jsr166 1.82 shouldThrow();
1662 :     } catch (NullPointerException success) {}
1663 : dl 1.1 }
1664 :     }
1665 :    
1666 :     /**
1667 :     * timed invokeAny(,,null) throws NPE
1668 :     */
1669 : jsr166 1.5 public void testTimedInvokeAnyNullTimeUnit() throws Exception {
1670 : jsr166 1.80 final ExecutorService e =
1671 :     new CustomTPE(2, 2,
1672 :     LONG_DELAY_MS, MILLISECONDS,
1673 :     new ArrayBlockingQueue<Runnable>(10));
1674 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1675 : jsr166 1.97 List<Callable<String>> l = new ArrayList<>();
1676 : jsr166 1.82 l.add(new StringTask());
1677 :     try {
1678 : jsr166 1.99 e.invokeAny(l, randomTimeout(), null);
1679 : jsr166 1.82 shouldThrow();
1680 :     } catch (NullPointerException success) {}
1681 : dl 1.1 }
1682 :     }
1683 :    
1684 :     /**
1685 : jsr166 1.99 * timed invokeAny(empty collection) throws IllegalArgumentException
1686 : dl 1.1 */
1687 : jsr166 1.5 public void testTimedInvokeAny2() throws Exception {
1688 : jsr166 1.80 final ExecutorService e =
1689 :     new CustomTPE(2, 2,
1690 :     LONG_DELAY_MS, MILLISECONDS,
1691 :     new ArrayBlockingQueue<Runnable>(10));
1692 : jsr166 1.99 final Collection<Callable<String>> emptyCollection
1693 :     = Collections.emptyList();
1694 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1695 :     try {
1696 : jsr166 1.99 e.invokeAny(emptyCollection, randomTimeout(), randomTimeUnit());
1697 : jsr166 1.82 shouldThrow();
1698 :     } catch (IllegalArgumentException success) {}
1699 : dl 1.1 }
1700 :     }
1701 :    
1702 :     /**
1703 :     * timed invokeAny(c) throws NPE if c has null elements
1704 :     */
1705 : jsr166 1.5 public void testTimedInvokeAny3() throws Exception {
1706 : jsr166 1.17 CountDownLatch latch = new CountDownLatch(1);
1707 : jsr166 1.80 final ExecutorService e =
1708 :     new CustomTPE(2, 2,
1709 :     LONG_DELAY_MS, MILLISECONDS,
1710 :     new ArrayBlockingQueue<Runnable>(10));
1711 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1712 : jsr166 1.97 List<Callable<String>> l = new ArrayList<>();
1713 : jsr166 1.82 l.add(latchAwaitingStringTask(latch));
1714 :     l.add(null);
1715 :     try {
1716 : jsr166 1.99 e.invokeAny(l, randomTimeout(), MILLISECONDS);
1717 : jsr166 1.82 shouldThrow();
1718 :     } catch (NullPointerException success) {}
1719 : jsr166 1.12 latch.countDown();
1720 : dl 1.1 }
1721 :     }
1722 :    
1723 :     /**
1724 :     * timed invokeAny(c) throws ExecutionException if no task completes
1725 :     */
1726 : jsr166 1.5 public void testTimedInvokeAny4() throws Exception {
1727 : jsr166 1.80 final ExecutorService e =
1728 :     new CustomTPE(2, 2,
1729 :     LONG_DELAY_MS, MILLISECONDS,
1730 :     new ArrayBlockingQueue<Runnable>(10));
1731 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1732 : jsr166 1.94 long startTime = System.nanoTime();
1733 : jsr166 1.97 List<Callable<String>> l = new ArrayList<>();
1734 : jsr166 1.82 l.add(new NPETask());
1735 :     try {
1736 : jsr166 1.94 e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
1737 : jsr166 1.82 shouldThrow();
1738 :     } catch (ExecutionException success) {
1739 :     assertTrue(success.getCause() instanceof NullPointerException);
1740 :     }
1741 : jsr166 1.94 assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1742 : dl 1.1 }
1743 :     }
1744 :    
1745 :     /**
1746 :     * timed invokeAny(c) returns result of some task
1747 :     */
1748 : jsr166 1.5 public void testTimedInvokeAny5() throws Exception {
1749 : jsr166 1.80 final ExecutorService e =
1750 :     new CustomTPE(2, 2,
1751 :     LONG_DELAY_MS, MILLISECONDS,
1752 :     new ArrayBlockingQueue<Runnable>(10));
1753 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1754 : jsr166 1.95 long startTime = System.nanoTime();
1755 : jsr166 1.97 List<Callable<String>> l = new ArrayList<>();
1756 : dl 1.1 l.add(new StringTask());
1757 :     l.add(new StringTask());
1758 : jsr166 1.95 String result = e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
1759 : dl 1.1 assertSame(TEST_STRING, result);
1760 : jsr166 1.95 assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1761 : dl 1.1 }
1762 :     }
1763 :    
1764 :     /**
1765 :     * timed invokeAll(null) throws NPE
1766 :     */
1767 : jsr166 1.5 public void testTimedInvokeAll1() throws Exception {
1768 : jsr166 1.80 final ExecutorService e =
1769 :     new CustomTPE(2, 2,
1770 :     LONG_DELAY_MS, MILLISECONDS,
1771 :     new ArrayBlockingQueue<Runnable>(10));
1772 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1773 :     try {
1774 : jsr166 1.99 e.invokeAll(null, randomTimeout(), randomTimeUnit());
1775 : jsr166 1.82 shouldThrow();
1776 :     } catch (NullPointerException success) {}
1777 : dl 1.1 }
1778 :     }
1779 :    
1780 :     /**
1781 :     * timed invokeAll(,,null) throws NPE
1782 :     */
1783 : jsr166 1.5 public void testTimedInvokeAllNullTimeUnit() throws Exception {
1784 : jsr166 1.80 final ExecutorService e =
1785 :     new CustomTPE(2, 2,
1786 :     LONG_DELAY_MS, MILLISECONDS,
1787 :     new ArrayBlockingQueue<Runnable>(10));
1788 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1789 : jsr166 1.97 List<Callable<String>> l = new ArrayList<>();
1790 : jsr166 1.82 l.add(new StringTask());
1791 :     try {
1792 : jsr166 1.99 e.invokeAll(l, randomTimeout(), null);
1793 : jsr166 1.82 shouldThrow();
1794 :     } catch (NullPointerException success) {}
1795 : dl 1.1 }
1796 :     }
1797 :    
1798 :     /**
1799 : jsr166 1.99 * timed invokeAll(empty collection) returns empty list
1800 : dl 1.1 */
1801 : jsr166 1.5 public void testTimedInvokeAll2() throws Exception {
1802 : jsr166 1.80 final ExecutorService e =
1803 :     new CustomTPE(2, 2,
1804 :     LONG_DELAY_MS, MILLISECONDS,
1805 :     new ArrayBlockingQueue<Runnable>(10));
1806 : jsr166 1.99 final Collection<Callable<String>> emptyCollection
1807 :     = Collections.emptyList();
1808 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1809 : jsr166 1.99 List<Future<String>> r =
1810 :     e.invokeAll(emptyCollection, randomTimeout(), randomTimeUnit());
1811 : dl 1.1 assertTrue(r.isEmpty());
1812 :     }
1813 :     }
1814 :    
1815 :     /**
1816 :     * timed invokeAll(c) throws NPE if c has null elements
1817 :     */
1818 : jsr166 1.5 public void testTimedInvokeAll3() throws Exception {
1819 : jsr166 1.80 final ExecutorService e =
1820 :     new CustomTPE(2, 2,
1821 :     LONG_DELAY_MS, MILLISECONDS,
1822 :     new ArrayBlockingQueue<Runnable>(10));
1823 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1824 : jsr166 1.97 List<Callable<String>> l = new ArrayList<>();
1825 : jsr166 1.82 l.add(new StringTask());
1826 :     l.add(null);
1827 :     try {
1828 : jsr166 1.99 e.invokeAll(l, randomTimeout(), randomTimeUnit());
1829 : jsr166 1.82 shouldThrow();
1830 :     } catch (NullPointerException success) {}
1831 : dl 1.1 }
1832 :     }
1833 :    
1834 :     /**
1835 :     * get of element of invokeAll(c) throws exception on failed task
1836 :     */
1837 : jsr166 1.5 public void testTimedInvokeAll4() throws Exception {
1838 : jsr166 1.80 final ExecutorService e =
1839 :     new CustomTPE(2, 2,
1840 :     LONG_DELAY_MS, MILLISECONDS,
1841 :     new ArrayBlockingQueue<Runnable>(10));
1842 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1843 : jsr166 1.97 List<Callable<String>> l = new ArrayList<>();
1844 : jsr166 1.82 l.add(new NPETask());
1845 :     List<Future<String>> futures =
1846 : jsr166 1.88 e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
1847 : jsr166 1.82 assertEquals(1, futures.size());
1848 :     try {
1849 :     futures.get(0).get();
1850 :     shouldThrow();
1851 :     } catch (ExecutionException success) {
1852 :     assertTrue(success.getCause() instanceof NullPointerException);
1853 :     }
1854 : dl 1.1 }
1855 :     }
1856 :    
1857 :     /**
1858 :     * timed invokeAll(c) returns results of all completed tasks
1859 :     */
1860 : jsr166 1.5 public void testTimedInvokeAll5() throws Exception {
1861 : jsr166 1.80 final ExecutorService e =
1862 :     new CustomTPE(2, 2,
1863 :     LONG_DELAY_MS, MILLISECONDS,
1864 :     new ArrayBlockingQueue<Runnable>(10));
1865 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1866 : jsr166 1.97 List<Callable<String>> l = new ArrayList<>();
1867 : dl 1.1 l.add(new StringTask());
1868 :     l.add(new StringTask());
1869 : jsr166 1.17 List<Future<String>> futures =
1870 : jsr166 1.45 e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
1871 : jsr166 1.17 assertEquals(2, futures.size());
1872 :     for (Future<String> future : futures)
1873 : jsr166 1.6 assertSame(TEST_STRING, future.get());
1874 : dl 1.1 }
1875 :     }
1876 :    
1877 :     /**
1878 :     * timed invokeAll(c) cancels tasks not completed by timeout
1879 :     */
1880 : jsr166 1.5 public void testTimedInvokeAll6() throws Exception {
1881 : jsr166 1.93 for (long timeout = timeoutMillis();;) {
1882 :     final CountDownLatch done = new CountDownLatch(1);
1883 :     final Callable<String> waiter = new CheckedCallable<String>() {
1884 :     public String realCall() {
1885 :     try { done.await(LONG_DELAY_MS, MILLISECONDS); }
1886 :     catch (InterruptedException ok) {}
1887 :     return "1"; }};
1888 :     final ExecutorService p =
1889 :     new CustomTPE(2, 2,
1890 :     LONG_DELAY_MS, MILLISECONDS,
1891 :     new ArrayBlockingQueue<Runnable>(10));
1892 :     try (PoolCleaner cleaner = cleaner(p, done)) {
1893 : jsr166 1.39 List<Callable<String>> tasks = new ArrayList<>();
1894 :     tasks.add(new StringTask("0"));
1895 : jsr166 1.93 tasks.add(waiter);
1896 : jsr166 1.39 tasks.add(new StringTask("2"));
1897 :     long startTime = System.nanoTime();
1898 :     List<Future<String>> futures =
1899 : jsr166 1.93 p.invokeAll(tasks, timeout, MILLISECONDS);
1900 : jsr166 1.39 assertEquals(tasks.size(), futures.size());
1901 :     assertTrue(millisElapsedSince(startTime) >= timeout);
1902 :     for (Future future : futures)
1903 :     assertTrue(future.isDone());
1904 :     assertTrue(futures.get(1).isCancelled());
1905 :     try {
1906 :     assertEquals("0", futures.get(0).get());
1907 :     assertEquals("2", futures.get(2).get());
1908 :     break;
1909 :     } catch (CancellationException retryWithLongerTimeout) {
1910 :     timeout *= 2;
1911 :     if (timeout >= LONG_DELAY_MS / 2)
1912 :     fail("expected exactly one task to be cancelled");
1913 :     }
1914 :     }
1915 : dl 1.1 }
1916 :     }
1917 :    
1918 :     /**
1919 :     * Execution continues if there is at least one thread even if
1920 :     * thread factory fails to create more
1921 :     */
1922 : jsr166 1.5 public void testFailingThreadFactory() throws InterruptedException {
1923 : jsr166 1.21 final ExecutorService e =
1924 :     new CustomTPE(100, 100,
1925 :     LONG_DELAY_MS, MILLISECONDS,
1926 :     new LinkedBlockingQueue<Runnable>(),
1927 :     new FailingThreadFactory());
1928 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(e)) {
1929 : jsr166 1.21 final int TASKS = 100;
1930 :     final CountDownLatch done = new CountDownLatch(TASKS);
1931 :     for (int k = 0; k < TASKS; ++k)
1932 :     e.execute(new CheckedRunnable() {
1933 :     public void realRun() {
1934 :     done.countDown();
1935 :     }});
1936 : jsr166 1.98 await(done);
1937 : dl 1.1 }
1938 :     }
1939 :    
1940 :     /**
1941 :     * allowsCoreThreadTimeOut is by default false.
1942 :     */
1943 :     public void testAllowsCoreThreadTimeOut() {
1944 : jsr166 1.80 final ThreadPoolExecutor p =
1945 :     new CustomTPE(2, 2,
1946 :     1000, MILLISECONDS,
1947 :     new ArrayBlockingQueue<Runnable>(10));
1948 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(p)) {
1949 :     assertFalse(p.allowsCoreThreadTimeOut());
1950 :     }
1951 : dl 1.1 }
1952 :    
1953 :     /**
1954 :     * allowCoreThreadTimeOut(true) causes idle threads to time out
1955 :     */
1956 : jsr166 1.21 public void testAllowCoreThreadTimeOut_true() throws Exception {
1957 : jsr166 1.39 long keepAliveTime = timeoutMillis();
1958 : jsr166 1.21 final ThreadPoolExecutor p =
1959 :     new CustomTPE(2, 10,
1960 : jsr166 1.39 keepAliveTime, MILLISECONDS,
1961 : jsr166 1.21 new ArrayBlockingQueue<Runnable>(10));
1962 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(p)) {
1963 :     final CountDownLatch threadStarted = new CountDownLatch(1);
1964 : jsr166 1.21 p.allowCoreThreadTimeOut(true);
1965 :     p.execute(new CheckedRunnable() {
1966 : jsr166 1.39 public void realRun() {
1967 : jsr166 1.21 threadStarted.countDown();
1968 :     assertEquals(1, p.getPoolSize());
1969 :     }});
1970 : jsr166 1.29 await(threadStarted);
1971 : jsr166 1.39 delay(keepAliveTime);
1972 : jsr166 1.29 long startTime = System.nanoTime();
1973 :     while (p.getPoolSize() > 0
1974 :     && millisElapsedSince(startTime) < LONG_DELAY_MS)
1975 :     Thread.yield();
1976 :     assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1977 : jsr166 1.21 assertEquals(0, p.getPoolSize());
1978 : dl 1.1 }
1979 :     }
1980 :    
1981 :     /**
1982 :     * allowCoreThreadTimeOut(false) causes idle threads not to time out
1983 :     */
1984 : jsr166 1.21 public void testAllowCoreThreadTimeOut_false() throws Exception {
1985 : jsr166 1.39 long keepAliveTime = timeoutMillis();
1986 : jsr166 1.21 final ThreadPoolExecutor p =
1987 :     new CustomTPE(2, 10,
1988 : jsr166 1.39 keepAliveTime, MILLISECONDS,
1989 : jsr166 1.21 new ArrayBlockingQueue<Runnable>(10));
1990 : jsr166 1.82 try (PoolCleaner cleaner = cleaner(p)) {
1991 :     final CountDownLatch threadStarted = new CountDownLatch(1);
1992 : jsr166 1.21 p.allowCoreThreadTimeOut(false);
1993 :     p.execute(new CheckedRunnable() {
1994 :     public void realRun() throws InterruptedException {
1995 :     threadStarted.countDown();
1996 :     assertTrue(p.getPoolSize() >= 1);
1997 :     }});
1998 : jsr166 1.39 delay(2 * keepAliveTime);
1999 : jsr166 1.21 assertTrue(p.getPoolSize() >= 1);
2000 : dl 1.1 }
2001 :     }
2002 :    
2003 : jsr166 1.44 /**
2004 :     * get(cancelled task) throws CancellationException
2005 :     * (in part, a test of CustomTPE itself)
2006 :     */
2007 :     public void testGet_cancelled() throws Exception {
2008 : jsr166 1.92 final CountDownLatch done = new CountDownLatch(1);
2009 : jsr166 1.44 final ExecutorService e =
2010 :     new CustomTPE(1, 1,
2011 :     LONG_DELAY_MS, MILLISECONDS,
2012 :     new LinkedBlockingQueue<Runnable>());
2013 : jsr166 1.92 try (PoolCleaner cleaner = cleaner(e, done)) {
2014 : jsr166 1.44 final CountDownLatch blockerStarted = new CountDownLatch(1);
2015 :     final List<Future<?>> futures = new ArrayList<>();
2016 :     for (int i = 0; i < 2; i++) {
2017 :     Runnable r = new CheckedRunnable() { public void realRun()
2018 :     throws Throwable {
2019 :     blockerStarted.countDown();
2020 :     assertTrue(done.await(2 * LONG_DELAY_MS, MILLISECONDS));
2021 :     }};
2022 :     futures.add(e.submit(r));
2023 :     }
2024 : jsr166 1.91 await(blockerStarted);
2025 : jsr166 1.44 for (Future<?> future : futures) future.cancel(false);
2026 :     for (Future<?> future : futures) {
2027 :     try {
2028 :     future.get();
2029 :     shouldThrow();
2030 :     } catch (CancellationException success) {}
2031 :     try {
2032 :     future.get(LONG_DELAY_MS, MILLISECONDS);
2033 :     shouldThrow();
2034 :     } catch (CancellationException success) {}
2035 :     assertTrue(future.isCancelled());
2036 :     assertTrue(future.isDone());
2037 :     }
2038 :     }
2039 :     }
2040 :    
2041 : dl 1.1 }

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8