ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ForkJoinPoolTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ForkJoinPoolTest.java (file contents):
Revision 1.21 by jsr166, Wed Aug 25 00:07:03 2010 UTC vs.
Revision 1.26 by jsr166, Thu Sep 16 00:52:49 2010 UTC

# Line 4 | Line 4
4   * http://creativecommons.org/licenses/publicdomain
5   */
6  
7 –
7   import junit.framework.*;
8 < import java.util.*;
9 < import java.util.concurrent.Executor;
8 > import java.util.ArrayList;
9 > import java.util.Collection;
10 > import java.util.List;
11   import java.util.concurrent.Executors;
12   import java.util.concurrent.ExecutorService;
13   import java.util.concurrent.AbstractExecutorService;
# Line 20 | Line 20 | import java.util.concurrent.RejectedExec
20   import java.util.concurrent.ForkJoinPool;
21   import java.util.concurrent.ForkJoinTask;
22   import java.util.concurrent.ForkJoinWorkerThread;
23 – import java.util.concurrent.RecursiveAction;
23   import java.util.concurrent.RecursiveTask;
24   import java.util.concurrent.TimeUnit;
25 < import java.util.concurrent.locks.*;
26 < import java.security.*;
25 > import java.util.concurrent.locks.ReentrantLock;
26 > import java.security.AccessControlException;
27 > import java.security.Policy;
28 > import java.security.PrivilegedAction;
29 > import java.security.PrivilegedExceptionAction;
30  
31   public class ForkJoinPoolTest extends JSR166TestCase {
32      public static void main(String[] args) {
33          junit.textui.TestRunner.run(suite());
34      }
35 +
36      public static Test suite() {
37          return new TestSuite(ForkJoinPoolTest.class);
38      }
# Line 156 | Line 159 | public class ForkJoinPoolTest extends JS
159       * tasks, and quiescent running state.
160       */
161      public void testDefaultInitialState() {
162 <        ForkJoinPool p = null;
162 >        ForkJoinPool p = new ForkJoinPool(1);
163          try {
164 <            p = new ForkJoinPool(1);
165 <            assertTrue(p.getFactory() ==
163 <                       ForkJoinPool.defaultForkJoinWorkerThreadFactory);
164 >            assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
165 >                       p.getFactory());
166              assertTrue(p.isQuiescent());
167              assertFalse(p.getAsyncMode());
168 <            assertTrue(p.getActiveThreadCount() == 0);
169 <            assertTrue(p.getStealCount() == 0);
170 <            assertTrue(p.getQueuedTaskCount() == 0);
171 <            assertTrue(p.getQueuedSubmissionCount() == 0);
168 >            assertEquals(0, p.getActiveThreadCount());
169 >            assertEquals(0, p.getStealCount());
170 >            assertEquals(0, p.getQueuedTaskCount());
171 >            assertEquals(0, p.getQueuedSubmissionCount());
172              assertFalse(p.hasQueuedSubmissions());
173              assertFalse(p.isShutdown());
174              assertFalse(p.isTerminating());
# Line 201 | Line 203 | public class ForkJoinPoolTest extends JS
203       * getParallelism returns size set in constructor
204       */
205      public void testGetParallelism() {
206 <        ForkJoinPool p = null;
206 >        ForkJoinPool p = new ForkJoinPool(1);
207          try {
208 <            p = new ForkJoinPool(1);
207 <            assertTrue(p.getParallelism() == 1);
208 >            assertEquals(1, p.getParallelism());
209          } finally {
210              joinPool(p);
211          }
# Line 214 | Line 215 | public class ForkJoinPoolTest extends JS
215       * getPoolSize returns number of started workers.
216       */
217      public void testGetPoolSize() {
218 <        ForkJoinPool p = null;
218 >        ForkJoinPool p = new ForkJoinPool(1);
219          try {
220 <            p = new ForkJoinPool(1);
220 <            assertTrue(p.getActiveThreadCount() == 0);
220 >            assertEquals(0, p.getActiveThreadCount());
221              Future<String> future = p.submit(new StringTask());
222 <            assertTrue(p.getPoolSize() == 1);
223 <
222 >            assertEquals(1, p.getPoolSize());
223          } finally {
224              joinPool(p);
225          }
# Line 233 | Line 232 | public class ForkJoinPoolTest extends JS
232       * performs its defined action
233       */
234      public void testSetUncaughtExceptionHandler() throws InterruptedException {
235 <        ForkJoinPool p = null;
235 >        MyHandler eh = new MyHandler();
236 >        ForkJoinPool p = new ForkJoinPool(1, new FailingThreadFactory(),
237 >                                          eh, false);
238          try {
239 <            MyHandler eh = new MyHandler();
239 <            p = new ForkJoinPool(1, new FailingThreadFactory(), eh, false);
240 <            assert(eh == p.getUncaughtExceptionHandler());
239 >            assertSame(eh, p.getUncaughtExceptionHandler());
240              p.execute(new FailingTask());
241              Thread.sleep(MEDIUM_DELAY_MS);
242              assertTrue(eh.catches > 0);
# Line 253 | Line 252 | public class ForkJoinPoolTest extends JS
252       * construction parameters continue to hold
253       */
254      public void testisQuiescent() throws InterruptedException {
255 <        ForkJoinPool p = null;
255 >        ForkJoinPool p = new ForkJoinPool(2);
256          try {
258 –            p = new ForkJoinPool(2);
257              p.invoke(new FibTask(20));
258 <            assertTrue(p.getFactory() ==
259 <                       ForkJoinPool.defaultForkJoinWorkerThreadFactory);
258 >            assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
259 >                       p.getFactory());
260              Thread.sleep(MEDIUM_DELAY_MS);
261              assertTrue(p.isQuiescent());
262              assertFalse(p.getAsyncMode());
263 <            assertTrue(p.getActiveThreadCount() == 0);
264 <            assertTrue(p.getQueuedTaskCount() == 0);
265 <            assertTrue(p.getQueuedSubmissionCount() == 0);
263 >            assertEquals(0, p.getActiveThreadCount());
264 >            assertEquals(0, p.getQueuedTaskCount());
265 >            assertEquals(0, p.getQueuedSubmissionCount());
266              assertFalse(p.hasQueuedSubmissions());
267              assertFalse(p.isShutdown());
268              assertFalse(p.isTerminating());
# Line 278 | Line 276 | public class ForkJoinPoolTest extends JS
276       * Completed submit(ForkJoinTask) returns result
277       */
278      public void testSubmitForkJoinTask() throws Throwable {
279 <        ForkJoinPool p = null;
279 >        ForkJoinPool p = new ForkJoinPool(1);
280          try {
283 –            p = new ForkJoinPool(1);
281              ForkJoinTask<Integer> f = p.submit(new FibTask(8));
282 <            int r = f.get();
286 <            assertTrue(r == 21);
282 >            assertEquals(21, (int) f.get());
283          } finally {
284              joinPool(p);
285          }
# Line 293 | Line 289 | public class ForkJoinPoolTest extends JS
289       * A task submitted after shutdown is rejected
290       */
291      public void testSubmitAfterShutdown() {
292 <        ForkJoinPool p = null;
292 >        ForkJoinPool p = new ForkJoinPool(1);
293          try {
298 –            p = new ForkJoinPool(1);
294              p.shutdown();
295              assertTrue(p.isShutdown());
296 <            ForkJoinTask<Integer> f = p.submit(new FibTask(8));
297 <            shouldThrow();
298 <        } catch (RejectedExecutionException success) {
296 >            try {
297 >                ForkJoinTask<Integer> f = p.submit(new FibTask(8));
298 >                shouldThrow();
299 >            } catch (RejectedExecutionException success) {}
300          } finally {
301              joinPool(p);
302          }
# Line 310 | Line 306 | public class ForkJoinPoolTest extends JS
306       * Pool maintains parallelism when using ManagedBlocker
307       */
308      public void testBlockingForkJoinTask() throws Throwable {
309 <        ForkJoinPool p = null;
309 >        ForkJoinPool p = new ForkJoinPool(4);
310          try {
315 –            p = new ForkJoinPool(4);
311              ReentrantLock lock = new ReentrantLock();
312              ManagedLocker locker = new ManagedLocker(lock);
313              ForkJoinTask<Integer> f = new LockingFibTask(30, locker, lock);
314              p.execute(f);
315 <            int r = f.get();
321 <            assertTrue(r == 832040);
315 >            assertEquals(832040, (int) f.get());
316          } finally {
317              p.shutdownNow(); // don't wait out shutdown
318          }
# Line 328 | Line 322 | public class ForkJoinPoolTest extends JS
322       * pollSubmission returns unexecuted submitted task, if present
323       */
324      public void testPollSubmission() {
325 <        SubFJP p = null;
325 >        SubFJP p = new SubFJP();
326          try {
333 –            p = new SubFJP();
327              ForkJoinTask a = p.submit(new MediumRunnable());
328              ForkJoinTask b = p.submit(new MediumRunnable());
329              ForkJoinTask c = p.submit(new MediumRunnable());
# Line 346 | Line 339 | public class ForkJoinPoolTest extends JS
339       * drainTasksTo transfers unexecuted submitted tasks, if present
340       */
341      public void testDrainTasksTo() {
342 <        SubFJP p = null;
342 >        SubFJP p = new SubFJP();
343          try {
351 –            p = new SubFJP();
344              ForkJoinTask a = p.submit(new MediumRunnable());
345              ForkJoinTask b = p.submit(new MediumRunnable());
346              ForkJoinTask c = p.submit(new MediumRunnable());
# Line 372 | Line 364 | public class ForkJoinPoolTest extends JS
364       */
365      public void testExecuteRunnable() throws Throwable {
366          ExecutorService e = new ForkJoinPool(1);
367 <        TrackedShortRunnable task = new TrackedShortRunnable();
368 <        assertFalse(task.done);
369 <        Future<?> future = e.submit(task);
370 <        future.get();
371 <        assertTrue(task.done);
367 >        try {
368 >            TrackedShortRunnable task = new TrackedShortRunnable();
369 >            assertFalse(task.done);
370 >            Future<?> future = e.submit(task);
371 >            future.get();
372 >            assertTrue(task.done);
373 >        } finally {
374 >            joinPool(e);
375 >        }
376      }
377  
378  
# Line 385 | Line 381 | public class ForkJoinPoolTest extends JS
381       */
382      public void testSubmitCallable() throws Throwable {
383          ExecutorService e = new ForkJoinPool(1);
384 <        Future<String> future = e.submit(new StringTask());
385 <        String result = future.get();
386 <        assertSame(TEST_STRING, result);
384 >        try {
385 >            Future<String> future = e.submit(new StringTask());
386 >            String result = future.get();
387 >            assertSame(TEST_STRING, result);
388 >        } finally {
389 >            joinPool(e);
390 >        }
391      }
392  
393      /**
# Line 395 | Line 395 | public class ForkJoinPoolTest extends JS
395       */
396      public void testSubmitRunnable() throws Throwable {
397          ExecutorService e = new ForkJoinPool(1);
398 <        Future<?> future = e.submit(new NoOpRunnable());
399 <        future.get();
400 <        assertTrue(future.isDone());
398 >        try {
399 >            Future<?> future = e.submit(new NoOpRunnable());
400 >            future.get();
401 >            assertTrue(future.isDone());
402 >        } finally {
403 >            joinPool(e);
404 >        }
405      }
406  
407      /**
# Line 405 | Line 409 | public class ForkJoinPoolTest extends JS
409       */
410      public void testSubmitRunnable2() throws Throwable {
411          ExecutorService e = new ForkJoinPool(1);
412 <        Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
413 <        String result = future.get();
414 <        assertSame(TEST_STRING, result);
412 >        try {
413 >            Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
414 >            String result = future.get();
415 >            assertSame(TEST_STRING, result);
416 >        } finally {
417 >            joinPool(e);
418 >        }
419      }
420  
421  
# Line 425 | Line 433 | public class ForkJoinPoolTest extends JS
433          } catch (AccessControlException ok) {
434              return;
435          }
436 +
437          try {
438              ExecutorService e = new ForkJoinPool(1);
439 <            Future future = e.submit(Executors.callable(new PrivilegedAction() {
439 >            try {
440 >                Future future = e.submit(Executors.callable(new PrivilegedAction() {
441                      public Object run() {
442                          return TEST_STRING;
443                      }}));
444  
445 <            Object result = future.get();
446 <            assertSame(TEST_STRING, result);
447 <        }
448 <        finally {
445 >                Object result = future.get();
446 >                assertSame(TEST_STRING, result);
447 >            } finally {
448 >                joinPool(e);
449 >            }
450 >        } finally {
451              Policy.setPolicy(savedPolicy);
452          }
453      }
# Line 457 | Line 469 | public class ForkJoinPoolTest extends JS
469  
470          try {
471              ExecutorService e = new ForkJoinPool(1);
472 <            Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
472 >            try {
473 >                Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
474                      public Object run() {
475                          return TEST_STRING;
476                      }}));
477  
478 <            Object result = future.get();
479 <            assertSame(TEST_STRING, result);
480 <        }
481 <        finally {
478 >                Object result = future.get();
479 >                assertSame(TEST_STRING, result);
480 >            } finally {
481 >                joinPool(e);
482 >            }
483 >        } finally {
484              Policy.setPolicy(savedPolicy);
485          }
486      }
# Line 485 | Line 500 | public class ForkJoinPoolTest extends JS
500              return;
501          }
502  
488 –
503          try {
504              ExecutorService e = new ForkJoinPool(1);
505 <            Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
505 >            try {
506 >                Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
507                      public Object run() throws Exception {
508                          throw new IndexOutOfBoundsException();
509                      }}));
510  
511 <            Object result = future.get();
512 <            shouldThrow();
513 <        } catch (ExecutionException success) {
514 <            assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
511 >                Object result = future.get();
512 >                shouldThrow();
513 >            } catch (ExecutionException success) {
514 >                assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
515 >            } finally {
516 >                joinPool(e);
517 >            }
518          } finally {
519              Policy.setPolicy(savedPolicy);
520          }
# Line 506 | Line 524 | public class ForkJoinPoolTest extends JS
524       * execute(null runnable) throws NullPointerException
525       */
526      public void testExecuteNullRunnable() {
527 +        ExecutorService e = new ForkJoinPool(1);
528 +        TrackedShortRunnable task = null;
529          try {
510 –            ExecutorService e = new ForkJoinPool(1);
511 –            TrackedShortRunnable task = null;
530              Future<?> future = e.submit(task);
531              shouldThrow();
532 <        } catch (NullPointerException success) {}
532 >        } catch (NullPointerException success) {
533 >        } finally {
534 >            joinPool(e);
535 >        }
536      }
537  
538  
# Line 519 | Line 540 | public class ForkJoinPoolTest extends JS
540       * submit(null callable) throws NullPointerException
541       */
542      public void testSubmitNullCallable() {
543 +        ExecutorService e = new ForkJoinPool(1);
544 +        StringTask t = null;
545          try {
523 –            ExecutorService e = new ForkJoinPool(1);
524 –            StringTask t = null;
546              Future<String> future = e.submit(t);
547              shouldThrow();
548 <        } catch (NullPointerException success) {}
548 >        } catch (NullPointerException success) {
549 >        } finally {
550 >            joinPool(e);
551 >        }
552      }
553  
554  
# Line 570 | Line 594 | public class ForkJoinPoolTest extends JS
594              shouldThrow();
595          } catch (ExecutionException success) {
596              assertTrue(success.getCause() instanceof ArithmeticException);
597 +        } finally {
598 +            joinPool(p);
599          }
574 –        
575 –        joinPool(p);
600      }
601  
602      /**

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines