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.211 by jsr166, Mon Nov 14 23:52:22 2016 UTC vs.
Revision 1.223 by jsr166, Sat May 13 19:13:09 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
13 < * @modules java.management
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 < * @run junit/othervm/timeout=1000 -Djsr166.testImplementationDetails=true JSR166TestCase
17 < * @run junit/othervm/timeout=1000 -Djava.util.concurrent.ForkJoinPool.common.parallelism=0 -Djsr166.testImplementationDetails=true JSR166TestCase
18 < * @run junit/othervm/timeout=1000 -Djava.util.concurrent.ForkJoinPool.common.parallelism=1 -Djava.util.secureRandomSeed=true JSR166TestCase
16 > * @modules java.management
17 > * @run junit/othervm/timeout=1000 JSR166TestCase
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   */
42  
43   import static java.util.concurrent.TimeUnit.MILLISECONDS;
# Line 30 | Line 54 | import java.lang.management.ThreadMXBean
54   import java.lang.reflect.Constructor;
55   import java.lang.reflect.Method;
56   import java.lang.reflect.Modifier;
33 – import java.nio.file.Files;
34 – import java.nio.file.Paths;
57   import java.security.CodeSource;
58   import java.security.Permission;
59   import java.security.PermissionCollection;
# Line 69 | Line 91 | import java.util.concurrent.ThreadPoolEx
91   import java.util.concurrent.TimeoutException;
92   import java.util.concurrent.atomic.AtomicBoolean;
93   import java.util.concurrent.atomic.AtomicReference;
72 – import java.util.regex.Matcher;
94   import java.util.regex.Pattern;
95  
96   import junit.framework.AssertionFailedError;
# Line 279 | Line 300 | public class JSR166TestCase extends Test
300  
301   //     public static String cpuModel() {
302   //         try {
303 < //             Matcher matcher = Pattern.compile("model name\\s*: (.*)")
303 > //             java.util.regex.Matcher matcher
304 > //               = Pattern.compile("model name\\s*: (.*)")
305   //                 .matcher(new String(
306 < //                      Files.readAllBytes(Paths.get("/proc/cpuinfo")), "UTF-8"));
306 > //                     java.nio.file.Files.readAllBytes(
307 > //                         java.nio.file.Paths.get("/proc/cpuinfo")), "UTF-8"));
308   //             matcher.find();
309   //             return matcher.group(1);
310   //         } catch (Exception ex) { return null; }
# Line 515 | Line 538 | public class JSR166TestCase extends Test
538                  "DoubleAdderTest",
539                  "ForkJoinPool8Test",
540                  "ForkJoinTask8Test",
541 +                "LinkedBlockingDeque8Test",
542 +                "LinkedBlockingQueue8Test",
543                  "LongAccumulatorTest",
544                  "LongAdderTest",
545                  "SplittableRandomTest",
# Line 537 | Line 562 | public class JSR166TestCase extends Test
562                  "AtomicReference9Test",
563                  "AtomicReferenceArray9Test",
564                  "ExecutorCompletionService9Test",
565 +                "ForkJoinPool9Test",
566              };
567              addNamedTestClasses(suite, java9TestClassNames);
568          }
# Line 547 | Line 573 | public class JSR166TestCase extends Test
573      /** Returns list of junit-style test method names in given class. */
574      public static ArrayList<String> testMethodNames(Class<?> testClass) {
575          Method[] methods = testClass.getDeclaredMethods();
576 <        ArrayList<String> names = new ArrayList<String>(methods.length);
576 >        ArrayList<String> names = new ArrayList<>(methods.length);
577          for (Method method : methods) {
578              if (method.getName().startsWith("test")
579                  && Modifier.isPublic(method.getModifiers())
# Line 632 | 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 653 | Line 684 | public class JSR166TestCase extends Test
684       * The first exception encountered if any threadAssertXXX method fails.
685       */
686      private final AtomicReference<Throwable> threadFailure
687 <        = new AtomicReference<Throwable>(null);
687 >        = new AtomicReference<>(null);
688  
689      /**
690       * Records an exception so that it can be rethrown later in the test
# Line 1112 | Line 1143 | public class JSR166TestCase extends Test
1143      }
1144  
1145      /**
1146 +     * The maximum number of consecutive spurious wakeups we should
1147 +     * tolerate (from APIs like LockSupport.park) before failing a test.
1148 +     */
1149 +    static final int MAX_SPURIOUS_WAKEUPS = 10;
1150 +
1151 +    /**
1152       * The number of elements to place in collections, arrays, etc.
1153       */
1154      public static final int SIZE = 20;
# Line 1215 | Line 1252 | public class JSR166TestCase extends Test
1252          }
1253          public void refresh() {}
1254          public String toString() {
1255 <            List<Permission> ps = new ArrayList<Permission>();
1255 >            List<Permission> ps = new ArrayList<>();
1256              for (Enumeration<Permission> e = perms.elements(); e.hasMoreElements();)
1257                  ps.add(e.nextElement());
1258              return "AdjustablePolicy with permissions " + ps;
# Line 1274 | Line 1311 | public class JSR166TestCase extends Test
1311                  startTime = System.nanoTime();
1312              else if (millisElapsedSince(startTime) > timeoutMillis) {
1313                  threadAssertTrue(thread.isAlive());
1314 <                return;
1314 >                fail("timed out waiting for thread to enter wait state");
1315              }
1316              Thread.yield();
1317          }
1318      }
1319  
1320      /**
1321 <     * Waits up to LONG_DELAY_MS for the given thread to enter a wait
1322 <     * state: BLOCKED, WAITING, or TIMED_WAITING.
1321 >     * Spin-waits up to the specified number of milliseconds for the given
1322 >     * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING,
1323 >     * and additionally satisfy the given condition.
1324 >     */
1325 >    void waitForThreadToEnterWaitState(
1326 >        Thread thread, long timeoutMillis, Callable<Boolean> waitingForGodot) {
1327 >        long startTime = 0L;
1328 >        for (;;) {
1329 >            Thread.State s = thread.getState();
1330 >            if (s == Thread.State.BLOCKED ||
1331 >                s == Thread.State.WAITING ||
1332 >                s == Thread.State.TIMED_WAITING) {
1333 >                try {
1334 >                    if (waitingForGodot.call())
1335 >                        return;
1336 >                } catch (Throwable fail) { threadUnexpectedException(fail); }
1337 >            }
1338 >            else if (s == Thread.State.TERMINATED)
1339 >                fail("Unexpected thread termination");
1340 >            else if (startTime == 0L)
1341 >                startTime = System.nanoTime();
1342 >            else if (millisElapsedSince(startTime) > timeoutMillis) {
1343 >                threadAssertTrue(thread.isAlive());
1344 >                fail("timed out waiting for thread to enter wait state");
1345 >            }
1346 >            Thread.yield();
1347 >        }
1348 >    }
1349 >
1350 >    /**
1351 >     * Spin-waits up to LONG_DELAY_MS milliseconds for the given thread to
1352 >     * enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1353       */
1354      void waitForThreadToEnterWaitState(Thread thread) {
1355          waitForThreadToEnterWaitState(thread, LONG_DELAY_MS);
1356      }
1357  
1358      /**
1359 +     * Spin-waits up to LONG_DELAY_MS milliseconds for the given thread to
1360 +     * enter a wait state: BLOCKED, WAITING, or TIMED_WAITING,
1361 +     * and additionally satisfy the given condition.
1362 +     */
1363 +    void waitForThreadToEnterWaitState(
1364 +        Thread thread, Callable<Boolean> waitingForGodot) {
1365 +        waitForThreadToEnterWaitState(thread, LONG_DELAY_MS, waitingForGodot);
1366 +    }
1367 +
1368 +    /**
1369       * Returns the number of milliseconds since time given by
1370       * startNanoTime, which must have been previously returned from a
1371       * call to {@link System#nanoTime()}.

Diff Legend

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