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.202 by jsr166, Thu Sep 15 00:32:45 2016 UTC vs.
Revision 1.222 by jsr166, Fri May 12 18:12:51 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 41 | Line 63 | import java.security.ProtectionDomain;
63   import java.security.SecurityPermission;
64   import java.util.ArrayList;
65   import java.util.Arrays;
66 + import java.util.Collection;
67   import java.util.Collections;
68   import java.util.Date;
69   import java.util.Enumeration;
# Line 68 | 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;
71 – import java.util.regex.Matcher;
94   import java.util.regex.Pattern;
95  
96   import junit.framework.AssertionFailedError;
# Line 278 | 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 447 | Line 471 | public class JSR166TestCase extends Test
471              AbstractQueuedLongSynchronizerTest.suite(),
472              ArrayBlockingQueueTest.suite(),
473              ArrayDequeTest.suite(),
474 +            ArrayListTest.suite(),
475              AtomicBooleanTest.suite(),
476              AtomicIntegerArrayTest.suite(),
477              AtomicIntegerFieldUpdaterTest.suite(),
# Line 469 | Line 494 | public class JSR166TestCase extends Test
494              CopyOnWriteArrayListTest.suite(),
495              CopyOnWriteArraySetTest.suite(),
496              CountDownLatchTest.suite(),
497 +            CountedCompleterTest.suite(),
498              CyclicBarrierTest.suite(),
499              DelayQueueTest.suite(),
500              EntryTest.suite(),
# Line 497 | Line 523 | public class JSR166TestCase extends Test
523              TreeMapTest.suite(),
524              TreeSetTest.suite(),
525              TreeSubMapTest.suite(),
526 <            TreeSubSetTest.suite());
526 >            TreeSubSetTest.suite(),
527 >            VectorTest.suite());
528  
529          // Java8+ test classes
530          if (atLeastJava8()) {
531              String[] java8TestClassNames = {
532 +                "ArrayDeque8Test",
533                  "Atomic8Test",
534                  "CompletableFutureTest",
535                  "ConcurrentHashMap8Test",
536 <                "CountedCompleterTest",
536 >                "CountedCompleter8Test",
537                  "DoubleAccumulatorTest",
538                  "DoubleAdderTest",
539                  "ForkJoinPool8Test",
540                  "ForkJoinTask8Test",
541 +                "LinkedBlockingDeque8Test",
542 +                "LinkedBlockingQueue8Test",
543                  "LongAccumulatorTest",
544                  "LongAdderTest",
545                  "SplittableRandomTest",
# Line 532 | Line 562 | public class JSR166TestCase extends Test
562                  "AtomicReference9Test",
563                  "AtomicReferenceArray9Test",
564                  "ExecutorCompletionService9Test",
565 +                "ForkJoinPool9Test",
566              };
567              addNamedTestClasses(suite, java9TestClassNames);
568          }
# Line 542 | 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 648 | Line 679 | public class JSR166TestCase extends Test
679       * The first exception encountered if any threadAssertXXX method fails.
680       */
681      private final AtomicReference<Throwable> threadFailure
682 <        = new AtomicReference<Throwable>(null);
682 >        = new AtomicReference<>(null);
683  
684      /**
685       * Records an exception so that it can be rethrown later in the test
# Line 1005 | Line 1036 | public class JSR166TestCase extends Test
1036          ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
1037          System.err.println("------ stacktrace dump start ------");
1038          for (ThreadInfo info : threadMXBean.dumpAllThreads(true, true)) {
1039 <            String name = info.getThreadName();
1039 >            final String name = info.getThreadName();
1040 >            String lockName;
1041              if ("Signal Dispatcher".equals(name))
1042                  continue;
1043              if ("Reference Handler".equals(name)
1044 <                && info.getLockName().startsWith("java.lang.ref.Reference$Lock"))
1044 >                && (lockName = info.getLockName()) != null
1045 >                && lockName.startsWith("java.lang.ref.Reference$Lock"))
1046                  continue;
1047              if ("Finalizer".equals(name)
1048 <                && info.getLockName().startsWith("java.lang.ref.ReferenceQueue$Lock"))
1048 >                && (lockName = info.getLockName()) != null
1049 >                && lockName.startsWith("java.lang.ref.ReferenceQueue$Lock"))
1050                  continue;
1051              if ("checkForWedgedTest".equals(name))
1052                  continue;
# Line 1104 | Line 1138 | public class JSR166TestCase extends Test
1138      }
1139  
1140      /**
1141 +     * The maximum number of consecutive spurious wakeups we should
1142 +     * tolerate (from APIs like LockSupport.park) before failing a test.
1143 +     */
1144 +    static final int MAX_SPURIOUS_WAKEUPS = 10;
1145 +
1146 +    /**
1147       * The number of elements to place in collections, arrays, etc.
1148       */
1149      public static final int SIZE = 20;
# Line 1207 | Line 1247 | public class JSR166TestCase extends Test
1247          }
1248          public void refresh() {}
1249          public String toString() {
1250 <            List<Permission> ps = new ArrayList<Permission>();
1250 >            List<Permission> ps = new ArrayList<>();
1251              for (Enumeration<Permission> e = perms.elements(); e.hasMoreElements();)
1252                  ps.add(e.nextElement());
1253              return "AdjustablePolicy with permissions " + ps;
# Line 1266 | Line 1306 | public class JSR166TestCase extends Test
1306                  startTime = System.nanoTime();
1307              else if (millisElapsedSince(startTime) > timeoutMillis) {
1308                  threadAssertTrue(thread.isAlive());
1309 <                return;
1309 >                fail("timed out waiting for thread to enter wait state");
1310 >            }
1311 >            Thread.yield();
1312 >        }
1313 >    }
1314 >
1315 >    /**
1316 >     * Spin-waits up to the specified number of milliseconds for the given
1317 >     * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING,
1318 >     * and additionally satisfy the given condition.
1319 >     */
1320 >    void waitForThreadToEnterWaitState(
1321 >        Thread thread, long timeoutMillis, Callable<Boolean> waitingForGodot) {
1322 >        long startTime = 0L;
1323 >        for (;;) {
1324 >            Thread.State s = thread.getState();
1325 >            if (s == Thread.State.BLOCKED ||
1326 >                s == Thread.State.WAITING ||
1327 >                s == Thread.State.TIMED_WAITING) {
1328 >                try {
1329 >                    if (waitingForGodot.call())
1330 >                        return;
1331 >                } catch (Throwable fail) { threadUnexpectedException(fail); }
1332 >            }
1333 >            else if (s == Thread.State.TERMINATED)
1334 >                fail("Unexpected thread termination");
1335 >            else if (startTime == 0L)
1336 >                startTime = System.nanoTime();
1337 >            else if (millisElapsedSince(startTime) > timeoutMillis) {
1338 >                threadAssertTrue(thread.isAlive());
1339 >                fail("timed out waiting for thread to enter wait state");
1340              }
1341              Thread.yield();
1342          }
1343      }
1344  
1345      /**
1346 <     * Waits up to LONG_DELAY_MS for the given thread to enter a wait
1347 <     * state: BLOCKED, WAITING, or TIMED_WAITING.
1346 >     * Spin-waits up to LONG_DELAY_MS milliseconds for the given thread to
1347 >     * enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1348       */
1349      void waitForThreadToEnterWaitState(Thread thread) {
1350          waitForThreadToEnterWaitState(thread, LONG_DELAY_MS);
1351      }
1352  
1353      /**
1354 +     * Spin-waits up to LONG_DELAY_MS milliseconds for the given thread to
1355 +     * enter a wait state: BLOCKED, WAITING, or TIMED_WAITING,
1356 +     * and additionally satisfy the given condition.
1357 +     */
1358 +    void waitForThreadToEnterWaitState(
1359 +        Thread thread, Callable<Boolean> waitingForGodot) {
1360 +        waitForThreadToEnterWaitState(thread, LONG_DELAY_MS, waitingForGodot);
1361 +    }
1362 +
1363 +    /**
1364       * Returns the number of milliseconds since time given by
1365       * startNanoTime, which must have been previously returned from a
1366       * call to {@link System#nanoTime()}.
# Line 1820 | Line 1900 | public class JSR166TestCase extends Test
1900          }
1901      }
1902  
1903 +    void assertImmutable(final Object o) {
1904 +        if (o instanceof Collection) {
1905 +            assertThrows(
1906 +                UnsupportedOperationException.class,
1907 +                new Runnable() { public void run() {
1908 +                        ((Collection) o).add(null);}});
1909 +        }
1910 +    }
1911 +
1912      @SuppressWarnings("unchecked")
1913      <T> T serialClone(T o) {
1914          try {
1915              ObjectInputStream ois = new ObjectInputStream
1916                  (new ByteArrayInputStream(serialBytes(o)));
1917              T clone = (T) ois.readObject();
1918 +            if (o == clone) assertImmutable(o);
1919              assertSame(o.getClass(), clone.getClass());
1920              return clone;
1921          } catch (Throwable fail) {
# Line 1834 | Line 1924 | public class JSR166TestCase extends Test
1924          }
1925      }
1926  
1927 +    /**
1928 +     * A version of serialClone that leaves error handling (for
1929 +     * e.g. NotSerializableException) up to the caller.
1930 +     */
1931 +    @SuppressWarnings("unchecked")
1932 +    <T> T serialClonePossiblyFailing(T o)
1933 +        throws ReflectiveOperationException, java.io.IOException {
1934 +        ByteArrayOutputStream bos = new ByteArrayOutputStream();
1935 +        ObjectOutputStream oos = new ObjectOutputStream(bos);
1936 +        oos.writeObject(o);
1937 +        oos.flush();
1938 +        oos.close();
1939 +        ObjectInputStream ois = new ObjectInputStream
1940 +            (new ByteArrayInputStream(bos.toByteArray()));
1941 +        T clone = (T) ois.readObject();
1942 +        if (o == clone) assertImmutable(o);
1943 +        assertSame(o.getClass(), clone.getClass());
1944 +        return clone;
1945 +    }
1946 +
1947 +    /**
1948 +     * If o implements Cloneable and has a public clone method,
1949 +     * returns a clone of o, else null.
1950 +     */
1951 +    @SuppressWarnings("unchecked")
1952 +    <T> T cloneableClone(T o) {
1953 +        if (!(o instanceof Cloneable)) return null;
1954 +        final T clone;
1955 +        try {
1956 +            clone = (T) o.getClass().getMethod("clone").invoke(o);
1957 +        } catch (NoSuchMethodException ok) {
1958 +            return null;
1959 +        } catch (ReflectiveOperationException unexpected) {
1960 +            throw new Error(unexpected);
1961 +        }
1962 +        assertNotSame(o, clone); // not 100% guaranteed by spec
1963 +        assertSame(o.getClass(), clone.getClass());
1964 +        return clone;
1965 +    }
1966 +
1967      public void assertThrows(Class<? extends Throwable> expectedExceptionClass,
1968                               Runnable... throwingActions) {
1969          for (Runnable throwingAction : throwingActions) {

Diff Legend

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