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

Comparing jsr166/src/test/tck/JSR166TestCase.java (file contents):
Revision 1.220 by jsr166, Sat Mar 11 17:33:32 2017 UTC vs.
Revision 1.226 by jsr166, Sun May 14 00:37:42 2017 UTC

# Line 1 | Line 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
2 > * Written by Doug Lea and Martin Buchholz with assistance from
3 > * members of JCP JSR-166 Expert Group and released to the public
4 > * domain, as explained at
5   * http://creativecommons.org/publicdomain/zero/1.0/
6   * Other contributors include Andrew Wright, Jeffrey Hayes,
7   * Pat Fisher, Mike Judd.
# Line 8 | Line 9
9  
10   /*
11   * @test
12 < * @summary JSR-166 tck tests (conformance testing mode)
12 > * @summary JSR-166 tck tests, in a number of variations.
13 > *          The first is the conformance testing variant,
14 > *          while others also test implementation details.
15   * @build *
16   * @modules java.management
17   * @run junit/othervm/timeout=1000 JSR166TestCase
15 – */
16 –
17 – /*
18 – * @test
19 – * @summary JSR-166 tck tests (whitebox tests allowed)
20 – * @build *
21 – * @modules java.base/java.util.concurrent:open
22 – *          java.base/java.lang:open
23 – *          java.management
18   * @run junit/othervm/timeout=1000
19 + *      --add-opens java.base/java.util.concurrent=ALL-UNNAMED
20 + *      --add-opens java.base/java.lang=ALL-UNNAMED
21   *      -Djsr166.testImplementationDetails=true
22   *      JSR166TestCase
23   * @run junit/othervm/timeout=1000
24 + *      --add-opens java.base/java.util.concurrent=ALL-UNNAMED
25 + *      --add-opens java.base/java.lang=ALL-UNNAMED
26   *      -Djsr166.testImplementationDetails=true
27   *      -Djava.util.concurrent.ForkJoinPool.common.parallelism=0
28   *      JSR166TestCase
29   * @run junit/othervm/timeout=1000
30 + *      --add-opens java.base/java.util.concurrent=ALL-UNNAMED
31 + *      --add-opens java.base/java.lang=ALL-UNNAMED
32   *      -Djsr166.testImplementationDetails=true
33   *      -Djava.util.concurrent.ForkJoinPool.common.parallelism=1
34   *      -Djava.util.secureRandomSeed=true
35   *      JSR166TestCase
36   * @run junit/othervm/timeout=1000/policy=tck.policy
37 + *      --add-opens java.base/java.util.concurrent=ALL-UNNAMED
38 + *      --add-opens java.base/java.lang=ALL-UNNAMED
39   *      -Djsr166.testImplementationDetails=true
40   *      JSR166TestCase
41   */
# Line 656 | Line 658 | public class JSR166TestCase extends Test
658          LONG_DELAY_MS   = SHORT_DELAY_MS * 200;
659      }
660  
661 +    private static final long TIMEOUT_DELAY_MS
662 +        = (long) (12.0 * Math.cbrt(delayFactor));
663 +
664      /**
665 <     * Returns a timeout in milliseconds to be used in tests that
666 <     * verify that operations block or time out.
665 >     * Returns a timeout in milliseconds to be used in tests that verify
666 >     * that operations block or time out.  We want this to be longer
667 >     * than the OS scheduling quantum, but not too long, so don't scale
668 >     * linearly with delayFactor; we use "crazy" cube root instead.
669       */
670 <    long timeoutMillis() {
671 <        return SHORT_DELAY_MS / 4;
670 >    static long timeoutMillis() {
671 >        return TIMEOUT_DELAY_MS;
672      }
673  
674      /**
# Line 1056 | Line 1063 | public class JSR166TestCase extends Test
1063      }
1064  
1065      /**
1066 +     * Checks that thread eventually enters the expected blocked thread state.
1067 +     */
1068 +    void assertThreadBlocks(Thread thread, Thread.State expected) {
1069 +        // always sleep at least 1 ms, avoiding transitional states
1070 +        // with high probability
1071 +        for (long retries = LONG_DELAY_MS * 3 / 4; retries-->0; ) {
1072 +            try { delay(1); }
1073 +            catch (InterruptedException fail) {
1074 +                fail("Unexpected InterruptedException");
1075 +            }
1076 +            Thread.State s = thread.getState();
1077 +            if (s == expected)
1078 +                return;
1079 +            else if (s == Thread.State.TERMINATED)
1080 +                fail("Unexpected thread termination");
1081 +        }
1082 +        fail("timed out waiting for thread to enter thread state " + expected);
1083 +    }
1084 +
1085 +    /**
1086       * Checks that thread does not terminate within the default
1087       * millisecond delay of {@code timeoutMillis()}.
1088       */
# Line 1136 | Line 1163 | public class JSR166TestCase extends Test
1163      }
1164  
1165      /**
1166 +     * The maximum number of consecutive spurious wakeups we should
1167 +     * tolerate (from APIs like LockSupport.park) before failing a test.
1168 +     */
1169 +    static final int MAX_SPURIOUS_WAKEUPS = 10;
1170 +
1171 +    /**
1172       * The number of elements to place in collections, arrays, etc.
1173       */
1174      public static final int SIZE = 20;
# Line 1602 | Line 1635 | public class JSR166TestCase extends Test
1635          } catch (Throwable fail) {
1636              threadUnexpectedException(fail);
1637          }
1638 +    }
1639 +
1640 +    public void await(CyclicBarrier barrier) {
1641 +        try {
1642 +            barrier.await(LONG_DELAY_MS, MILLISECONDS);
1643 +        } catch (Throwable fail) {
1644 +            threadUnexpectedException(fail);
1645 +        }
1646      }
1647  
1648   //     /**

Diff Legend

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