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

Comparing jsr166/src/test/tck/ForkJoinPool8Test.java (file contents):
Revision 1.26 by jsr166, Sat Nov 1 16:02:23 2014 UTC vs.
Revision 1.32 by jsr166, Tue Oct 13 21:07:54 2015 UTC

# Line 4 | Line 4
4   * http://creativecommons.org/publicdomain/zero/1.0/
5   */
6  
7 < import junit.framework.*;
7 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
8 > import static java.util.concurrent.TimeUnit.SECONDS;
9 >
10 > import java.util.HashSet;
11   import java.util.concurrent.CancellationException;
12 + import java.util.concurrent.CountedCompleter;
13   import java.util.concurrent.ExecutionException;
14   import java.util.concurrent.ForkJoinPool;
15   import java.util.concurrent.ForkJoinTask;
12 – import java.util.concurrent.ForkJoinWorkerThread;
16   import java.util.concurrent.RecursiveAction;
14 – import java.util.concurrent.CountedCompleter;
15 – import java.util.concurrent.ThreadLocalRandom;
16 – import java.util.concurrent.TimeUnit;
17   import java.util.concurrent.TimeoutException;
18 < import static java.util.concurrent.TimeUnit.SECONDS;
19 < import static java.util.concurrent.TimeUnit.MILLISECONDS;
20 < import java.util.Arrays;
21 < import java.util.HashSet;
18 >
19 > import junit.framework.Test;
20 > import junit.framework.TestSuite;
21  
22   public class ForkJoinPool8Test extends JSR166TestCase {
23      public static void main(String[] args) {
24 <        junit.textui.TestRunner.run(suite());
24 >        main(suite(), args);
25      }
26  
27      public static Test suite() {
# Line 479 | Line 478 | public class ForkJoinPool8Test extends J
478                  FailingFibAction f = new FailingFibAction(8);
479                  assertSame(f, f.fork());
480                  try {
481 <                    f.get(5L, TimeUnit.SECONDS);
481 >                    f.get(5L, SECONDS);
482                      shouldThrow();
483                  } catch (ExecutionException success) {
484                      Throwable cause = success.getCause();
# Line 1490 | Line 1489 | public class ForkJoinPool8Test extends J
1489       */
1490      public void testAwaitQuiescence1() throws Exception {
1491          final ForkJoinPool p = new ForkJoinPool();
1492 <        try {
1492 >        try (PoolCleaner cleaner = cleaner(p)) {
1493              final long startTime = System.nanoTime();
1494              assertTrue(p.isQuiescent());
1495              ForkJoinTask a = new CheckedRecursiveAction() {
# Line 1521 | Line 1520 | public class ForkJoinPool8Test extends J
1520                  assertFalse(p.isTerminated());
1521                  Thread.yield();
1522              }
1524 –            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1523              assertEquals(0, p.getQueuedTaskCount());
1524              assertFalse(p.getAsyncMode());
1527 –            assertEquals(0, p.getActiveThreadCount());
1528 –            assertEquals(0, p.getQueuedTaskCount());
1525              assertEquals(0, p.getQueuedSubmissionCount());
1526              assertFalse(p.hasQueuedSubmissions());
1527 +            while (p.getActiveThreadCount() != 0
1528 +                   && millisElapsedSince(startTime) < LONG_DELAY_MS)
1529 +                Thread.yield();
1530              assertFalse(p.isShutdown());
1531              assertFalse(p.isTerminating());
1532              assertFalse(p.isTerminated());
1533 <        } finally {
1535 <            joinPool(p);
1533 >            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1534          }
1535      }
1536  
# Line 1541 | Line 1539 | public class ForkJoinPool8Test extends J
1539       * timeout elapsed
1540       */
1541      public void testAwaitQuiescence2() throws Exception {
1542 +        /**
1543 +         * """It is possible to disable or limit the use of threads in the
1544 +         * common pool by setting the parallelism property to zero. However
1545 +         * doing so may cause unjoined tasks to never be executed."""
1546 +         */
1547 +        if ("0".equals(System.getProperty(
1548 +             "java.util.concurrent.ForkJoinPool.common.parallelism")))
1549 +            return;
1550          final ForkJoinPool p = new ForkJoinPool();
1551 <        try {
1551 >        try (PoolCleaner cleaner = cleaner(p)) {
1552              assertTrue(p.isQuiescent());
1553              final long startTime = System.nanoTime();
1554              ForkJoinTask a = new CheckedRecursiveAction() {
# Line 1563 | Line 1569 | public class ForkJoinPool8Test extends J
1569                  }};
1570              p.execute(a);
1571              assertTrue(p.awaitQuiescence(LONG_DELAY_MS, MILLISECONDS));
1566 –            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1572              assertTrue(p.isQuiescent());
1573              assertTrue(a.isDone());
1574              assertEquals(0, p.getQueuedTaskCount());
1575              assertFalse(p.getAsyncMode());
1571 –            assertEquals(0, p.getActiveThreadCount());
1572 –            assertEquals(0, p.getQueuedTaskCount());
1576              assertEquals(0, p.getQueuedSubmissionCount());
1577              assertFalse(p.hasQueuedSubmissions());
1578 +            while (p.getActiveThreadCount() != 0
1579 +                   && millisElapsedSince(startTime) < LONG_DELAY_MS)
1580 +                Thread.yield();
1581              assertFalse(p.isShutdown());
1582              assertFalse(p.isTerminating());
1583              assertFalse(p.isTerminated());
1584 <        } finally {
1579 <            joinPool(p);
1584 >            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1585          }
1586      }
1587  

Diff Legend

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