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.260 by jsr166, Thu Sep 5 17:27:07 2019 UTC vs.
Revision 1.268 by jsr166, Sun Sep 22 01:59:57 2019 UTC

# Line 49 | Line 49 | import java.io.ByteArrayOutputStream;
49   import java.io.ObjectInputStream;
50   import java.io.ObjectOutputStream;
51   import java.lang.management.ManagementFactory;
52 + import java.lang.management.LockInfo;
53   import java.lang.management.ThreadInfo;
54   import java.lang.management.ThreadMXBean;
55   import java.lang.reflect.Constructor;
# Line 243 | Line 244 | public class JSR166TestCase extends Test
244          }
245      }
246  
247 +    private static final ThreadMXBean THREAD_MXBEAN
248 +        = ManagementFactory.getThreadMXBean();
249 +
250      /**
251       * The scaling factor to apply to standard delays used in tests.
252       * May be initialized from any of:
# Line 284 | Line 288 | public class JSR166TestCase extends Test
288      static volatile TestCase currentTestCase;
289      // static volatile int currentRun = 0;
290      static {
291 <        Runnable checkForWedgedTest = new Runnable() { public void run() {
291 >        Runnable wedgedTestDetector = new Runnable() { public void run() {
292              // Avoid spurious reports with enormous runsPerTest.
293              // A single test case run should never take more than 1 second.
294              // But let's cap it at the high end too ...
# Line 310 | Line 314 | public class JSR166TestCase extends Test
314                  }
315                  lastTestCase = currentTestCase;
316              }}};
317 <        Thread thread = new Thread(checkForWedgedTest, "checkForWedgedTest");
317 >        Thread thread = new Thread(wedgedTestDetector, "WedgedTestDetector");
318          thread.setDaemon(true);
319          thread.start();
320      }
# Line 354 | Line 358 | public class JSR166TestCase extends Test
358              // Never report first run of any test; treat it as a
359              // warmup run, notably to trigger all needed classloading,
360              if (i > 0)
361 <                System.out.printf("%n%s: %d%n", toString(), elapsedMillis);
361 >                System.out.printf("%s: %d%n", toString(), elapsedMillis);
362          }
363      }
364  
# Line 657 | Line 661 | public class JSR166TestCase extends Test
661      public static long MEDIUM_DELAY_MS;
662      public static long LONG_DELAY_MS;
663  
664 +    /**
665 +     * A delay significantly longer than LONG_DELAY_MS.
666 +     * Use this in a thread that is waited for via awaitTermination(Thread).
667 +     */
668 +    public static long LONGER_DELAY_MS;
669 +
670      private static final long RANDOM_TIMEOUT;
671      private static final long RANDOM_EXPIRED_TIMEOUT;
672      private static final TimeUnit RANDOM_TIMEUNIT;
# Line 716 | Line 726 | public class JSR166TestCase extends Test
726          SMALL_DELAY_MS  = SHORT_DELAY_MS * 5;
727          MEDIUM_DELAY_MS = SHORT_DELAY_MS * 10;
728          LONG_DELAY_MS   = SHORT_DELAY_MS * 200;
729 +        LONGER_DELAY_MS = 2 * LONG_DELAY_MS;
730      }
731  
732      private static final long TIMEOUT_DELAY_MS
# Line 1076 | Line 1087 | public class JSR166TestCase extends Test
1087          }
1088      }
1089  
1090 +    /** Returns true if thread info might be useful in a thread dump. */
1091 +    static boolean threadOfInterest(ThreadInfo info) {
1092 +        final String name = info.getThreadName();
1093 +        String lockName;
1094 +        if (name == null)
1095 +            return true;
1096 +        if (name.equals("Signal Dispatcher")
1097 +            || name.equals("WedgedTestDetector"))
1098 +            return false;
1099 +        if (name.equals("Reference Handler")) {
1100 +            // Reference Handler stacktrace changed in JDK-8156500
1101 +            StackTraceElement[] stackTrace; String methodName;
1102 +            if ((stackTrace = info.getStackTrace()) != null
1103 +                && stackTrace.length > 0
1104 +                && (methodName = stackTrace[0].getMethodName()) != null
1105 +                && methodName.equals("waitForReferencePendingList"))
1106 +                return false;
1107 +            // jdk8 Reference Handler stacktrace
1108 +            if ((lockName = info.getLockName()) != null
1109 +                && lockName.startsWith("java.lang.ref"))
1110 +                return false;
1111 +        }
1112 +        if ((name.equals("Finalizer") || name.equals("Common-Cleaner"))
1113 +            && (lockName = info.getLockName()) != null
1114 +            && lockName.startsWith("java.lang.ref"))
1115 +            return false;
1116 +        if (name.startsWith("ForkJoinPool.commonPool-worker")
1117 +            && (lockName = info.getLockName()) != null
1118 +            && lockName.startsWith("java.util.concurrent.ForkJoinPool"))
1119 +            return false;
1120 +        return true;
1121 +    }
1122 +
1123      /**
1124       * A debugging tool to print stack traces of most threads, as jstack does.
1125       * Uninteresting threads are filtered out.
# Line 1090 | Line 1134 | public class JSR166TestCase extends Test
1134              }
1135          }
1136  
1093 –        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
1137          System.err.println("------ stacktrace dump start ------");
1138 <        for (ThreadInfo info : threadMXBean.dumpAllThreads(true, true)) {
1139 <            final String name = info.getThreadName();
1140 <            String lockName;
1098 <            if ("Signal Dispatcher".equals(name))
1099 <                continue;
1100 <            if ("Reference Handler".equals(name)
1101 <                && (lockName = info.getLockName()) != null
1102 <                && lockName.startsWith("java.lang.ref.Reference$Lock"))
1103 <                continue;
1104 <            if ("Finalizer".equals(name)
1105 <                && (lockName = info.getLockName()) != null
1106 <                && lockName.startsWith("java.lang.ref.ReferenceQueue$Lock"))
1107 <                continue;
1108 <            if ("checkForWedgedTest".equals(name))
1109 <                continue;
1110 <            System.err.print(info);
1111 <        }
1138 >        for (ThreadInfo info : THREAD_MXBEAN.dumpAllThreads(true, true))
1139 >            if (threadOfInterest(info))
1140 >                System.err.print(info);
1141          System.err.println("------ stacktrace dump end ------");
1142  
1143          if (sm != null) System.setSecurityManager(sm);
# Line 1135 | Line 1164 | public class JSR166TestCase extends Test
1164      }
1165  
1166      /**
1167 +     * Returns the thread's blocker's class name, if any, else null.
1168 +     */
1169 +    String blockerClassName(Thread thread) {
1170 +        ThreadInfo threadInfo; LockInfo lockInfo;
1171 +        if ((threadInfo = THREAD_MXBEAN.getThreadInfo(thread.getId(), 0)) != null
1172 +            && (lockInfo = threadInfo.getLockInfo()) != null)
1173 +            return lockInfo.getClassName();
1174 +        return null;
1175 +    }
1176 +
1177 +    /**
1178       * Checks that future.get times out, with the default timeout of
1179       * {@code timeoutMillis()}.
1180       */
# Line 1403 | Line 1443 | public class JSR166TestCase extends Test
1443          return NANOSECONDS.toMillis(System.nanoTime() - startNanoTime);
1444      }
1445  
1406 – //     void assertTerminatesPromptly(long timeoutMillis, Runnable r) {
1407 – //         long startTime = System.nanoTime();
1408 – //         try {
1409 – //             r.run();
1410 – //         } catch (Throwable fail) { threadUnexpectedException(fail); }
1411 – //         if (millisElapsedSince(startTime) > timeoutMillis/2)
1412 – //             throw new AssertionError("did not return promptly");
1413 – //     }
1414 –
1415 – //     void assertTerminatesPromptly(Runnable r) {
1416 – //         assertTerminatesPromptly(LONG_DELAY_MS/2, r);
1417 – //     }
1418 –
1446      /**
1447       * Checks that timed f.get() returns the expected value, and does not
1448       * wait for the timeout to elapse before returning.
# Line 1446 | Line 1473 | public class JSR166TestCase extends Test
1473      }
1474  
1475      /**
1476 +     * Returns a new started daemon Thread running the given action,
1477 +     * wrapped in a CheckedRunnable.
1478 +     */
1479 +    Thread newStartedThread(Action action) {
1480 +        return newStartedThread(checkedRunnable(action));
1481 +    }
1482 +
1483 +    /**
1484       * Waits for the specified time (in milliseconds) for the thread
1485       * to terminate (using {@link Thread#join(long)}), else interrupts
1486       * the thread (in the hope that it may terminate later) and fails.
1487       */
1488 <    void awaitTermination(Thread t, long timeoutMillis) {
1488 >    void awaitTermination(Thread thread, long timeoutMillis) {
1489          try {
1490 <            t.join(timeoutMillis);
1490 >            thread.join(timeoutMillis);
1491          } catch (InterruptedException fail) {
1492              threadUnexpectedException(fail);
1493          }
1494 <        Thread.State state;
1495 <        if ((state = t.getState()) != Thread.State.TERMINATED) {
1496 <            t.interrupt();
1497 <            threadFail("timed out waiting for thread to terminate; "
1498 <                       + "state=" + state);
1494 >        if (thread.getState() != Thread.State.TERMINATED) {
1495 >            String detail = String.format(
1496 >                    "timed out waiting for thread to terminate, thread=%s, state=%s" ,
1497 >                    thread, thread.getState());
1498 >            try {
1499 >                threadFail(detail);
1500 >            } finally {
1501 >                // Interrupt thread __after__ having reported its stack trace
1502 >                thread.interrupt();
1503 >            }
1504          }
1505      }
1506  
# Line 1487 | Line 1527 | public class JSR166TestCase extends Test
1527          }
1528      }
1529  
1530 +    Runnable checkedRunnable(Action action) {
1531 +        return new CheckedRunnable() {
1532 +            public void realRun() throws Throwable {
1533 +                action.run();
1534 +            }};
1535 +    }
1536 +
1537      public abstract class ThreadShouldThrow extends Thread {
1538          protected abstract void realRun() throws Throwable;
1539  

Diff Legend

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