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.249 by jsr166, Sat Nov 24 21:41:20 2018 UTC vs.
Revision 1.271 by jsr166, Sat Feb 1 18:52:17 2020 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 ...
295 <            final int timeoutMinutes =
296 <                Math.min(15, Math.max(runsPerTest / 60, 1));
295 >            final int timeoutMinutesMin = Math.max(runsPerTest / 60, 1)
296 >                * Math.max((int) delayFactor, 1);
297 >            final int timeoutMinutes = Math.min(15, timeoutMinutesMin);
298              for (TestCase lastTestCase = currentTestCase;;) {
299                  try { MINUTES.sleep(timeoutMinutes); }
300                  catch (InterruptedException unexpected) { break; }
# Line 309 | 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 353 | 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 460 | Line 465 | public class JSR166TestCase extends Test
465      public static boolean atLeastJava9()  { return JAVA_CLASS_VERSION >= 53.0; }
466      public static boolean atLeastJava10() { return JAVA_CLASS_VERSION >= 54.0; }
467      public static boolean atLeastJava11() { return JAVA_CLASS_VERSION >= 55.0; }
468 +    public static boolean atLeastJava12() { return JAVA_CLASS_VERSION >= 56.0; }
469 +    public static boolean atLeastJava13() { return JAVA_CLASS_VERSION >= 57.0; }
470 +    public static boolean atLeastJava14() { return JAVA_CLASS_VERSION >= 58.0; }
471 +    public static boolean atLeastJava15() { return JAVA_CLASS_VERSION >= 59.0; }
472 +    public static boolean atLeastJava16() { return JAVA_CLASS_VERSION >= 60.0; }
473 +    public static boolean atLeastJava17() { return JAVA_CLASS_VERSION >= 61.0; }
474  
475      /**
476       * Collects all JSR166 unit tests as one suite.
# Line 511 | Line 522 | public class JSR166TestCase extends Test
522              ExecutorsTest.suite(),
523              ExecutorCompletionServiceTest.suite(),
524              FutureTaskTest.suite(),
525 +            HashtableTest.suite(),
526              LinkedBlockingDequeTest.suite(),
527              LinkedBlockingQueueTest.suite(),
528              LinkedListTest.suite(),
# Line 550 | Line 562 | public class JSR166TestCase extends Test
562                  "HashMapTest",
563                  "LinkedBlockingDeque8Test",
564                  "LinkedBlockingQueue8Test",
565 +                "LinkedHashMapTest",
566                  "LongAccumulatorTest",
567                  "LongAdderTest",
568                  "SplittableRandomTest",
# Line 648 | 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 676 | Line 695 | public class JSR166TestCase extends Test
695      static TimeUnit randomTimeUnit() { return RANDOM_TIMEUNIT; }
696  
697      /**
698 +     * Returns a random boolean; a "coin flip".
699 +     */
700 +    static boolean randomBoolean() {
701 +        return ThreadLocalRandom.current().nextBoolean();
702 +    }
703 +
704 +    /**
705 +     * Returns a random element from given choices.
706 +     */
707 +    <T> T chooseRandomly(List<T> choices) {
708 +        return choices.get(ThreadLocalRandom.current().nextInt(choices.size()));
709 +    }
710 +
711 +    /**
712 +     * Returns a random element from given choices.
713 +     */
714 +    <T> T chooseRandomly(T... choices) {
715 +        return choices[ThreadLocalRandom.current().nextInt(choices.length)];
716 +    }
717 +
718 +    /**
719       * Returns the shortest timed delay. This can be scaled up for
720       * slow machines using the jsr166.delay.factor system property,
721       * or via jtreg's -timeoutFactor: flag.
# Line 693 | Line 733 | public class JSR166TestCase extends Test
733          SMALL_DELAY_MS  = SHORT_DELAY_MS * 5;
734          MEDIUM_DELAY_MS = SHORT_DELAY_MS * 10;
735          LONG_DELAY_MS   = SHORT_DELAY_MS * 200;
736 +        LONGER_DELAY_MS = 2 * LONG_DELAY_MS;
737      }
738  
739      private static final long TIMEOUT_DELAY_MS
# Line 731 | Line 772 | public class JSR166TestCase extends Test
772       */
773      public void threadRecordFailure(Throwable t) {
774          System.err.println(t);
775 <        dumpTestThreads();
776 <        threadFailure.compareAndSet(null, t);
775 >        if (threadFailure.compareAndSet(null, t))
776 >            dumpTestThreads();
777      }
778  
779      public void setUp() {
# Line 1053 | Line 1094 | public class JSR166TestCase extends Test
1094          }
1095      }
1096  
1097 +    /** Returns true if thread info might be useful in a thread dump. */
1098 +    static boolean threadOfInterest(ThreadInfo info) {
1099 +        final String name = info.getThreadName();
1100 +        String lockName;
1101 +        if (name == null)
1102 +            return true;
1103 +        if (name.equals("Signal Dispatcher")
1104 +            || name.equals("WedgedTestDetector"))
1105 +            return false;
1106 +        if (name.equals("Reference Handler")) {
1107 +            // Reference Handler stacktrace changed in JDK-8156500
1108 +            StackTraceElement[] stackTrace; String methodName;
1109 +            if ((stackTrace = info.getStackTrace()) != null
1110 +                && stackTrace.length > 0
1111 +                && (methodName = stackTrace[0].getMethodName()) != null
1112 +                && methodName.equals("waitForReferencePendingList"))
1113 +                return false;
1114 +            // jdk8 Reference Handler stacktrace
1115 +            if ((lockName = info.getLockName()) != null
1116 +                && lockName.startsWith("java.lang.ref"))
1117 +                return false;
1118 +        }
1119 +        if ((name.equals("Finalizer") || name.equals("Common-Cleaner"))
1120 +            && (lockName = info.getLockName()) != null
1121 +            && lockName.startsWith("java.lang.ref"))
1122 +            return false;
1123 +        if (name.startsWith("ForkJoinPool.commonPool-worker")
1124 +            && (lockName = info.getLockName()) != null
1125 +            && lockName.startsWith("java.util.concurrent.ForkJoinPool"))
1126 +            return false;
1127 +        return true;
1128 +    }
1129 +
1130      /**
1131       * A debugging tool to print stack traces of most threads, as jstack does.
1132       * Uninteresting threads are filtered out.
# Line 1067 | Line 1141 | public class JSR166TestCase extends Test
1141              }
1142          }
1143  
1070 –        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
1144          System.err.println("------ stacktrace dump start ------");
1145 <        for (ThreadInfo info : threadMXBean.dumpAllThreads(true, true)) {
1146 <            final String name = info.getThreadName();
1147 <            String lockName;
1075 <            if ("Signal Dispatcher".equals(name))
1076 <                continue;
1077 <            if ("Reference Handler".equals(name)
1078 <                && (lockName = info.getLockName()) != null
1079 <                && lockName.startsWith("java.lang.ref.Reference$Lock"))
1080 <                continue;
1081 <            if ("Finalizer".equals(name)
1082 <                && (lockName = info.getLockName()) != null
1083 <                && lockName.startsWith("java.lang.ref.ReferenceQueue$Lock"))
1084 <                continue;
1085 <            if ("checkForWedgedTest".equals(name))
1086 <                continue;
1087 <            System.err.print(info);
1088 <        }
1145 >        for (ThreadInfo info : THREAD_MXBEAN.dumpAllThreads(true, true))
1146 >            if (threadOfInterest(info))
1147 >                System.err.print(info);
1148          System.err.println("------ stacktrace dump end ------");
1149  
1150          if (sm != null) System.setSecurityManager(sm);
# Line 1112 | Line 1171 | public class JSR166TestCase extends Test
1171      }
1172  
1173      /**
1174 +     * Returns the thread's blocker's class name, if any, else null.
1175 +     */
1176 +    String blockerClassName(Thread thread) {
1177 +        ThreadInfo threadInfo; LockInfo lockInfo;
1178 +        if ((threadInfo = THREAD_MXBEAN.getThreadInfo(thread.getId(), 0)) != null
1179 +            && (lockInfo = threadInfo.getLockInfo()) != null)
1180 +            return lockInfo.getClassName();
1181 +        return null;
1182 +    }
1183 +
1184 +    /**
1185       * Checks that future.get times out, with the default timeout of
1186       * {@code timeoutMillis()}.
1187       */
# Line 1130 | Line 1200 | public class JSR166TestCase extends Test
1200          } catch (TimeoutException success) {
1201          } catch (Exception fail) {
1202              threadUnexpectedException(fail);
1203 <        } finally { future.cancel(true); }
1203 >        }
1204          assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
1205 +        assertFalse(future.isDone());
1206      }
1207  
1208      /**
# Line 1305 | Line 1376 | public class JSR166TestCase extends Test
1376                                         Callable<Boolean> waitingForGodot) {
1377          for (long startTime = 0L;;) {
1378              switch (thread.getState()) {
1379 +            default: break;
1380              case BLOCKED: case WAITING: case TIMED_WAITING:
1381                  try {
1382                      if (waitingForGodot == null || waitingForGodot.call())
# Line 1357 | Line 1429 | public class JSR166TestCase extends Test
1429      }
1430  
1431      /**
1432 +     * Spin-waits up to LONG_DELAY_MS milliseconds for the current thread to
1433 +     * be interrupted.  Clears the interrupt status before returning.
1434 +     */
1435 +    void awaitInterrupted() {
1436 +        for (long startTime = 0L; !Thread.interrupted(); ) {
1437 +            if (startTime == 0L)
1438 +                startTime = System.nanoTime();
1439 +            else if (millisElapsedSince(startTime) > LONG_DELAY_MS)
1440 +                fail("timed out waiting for thread interrupt");
1441 +            Thread.yield();
1442 +        }
1443 +    }
1444 +
1445 +    /**
1446       * Returns the number of milliseconds since time given by
1447       * startNanoTime, which must have been previously returned from a
1448       * call to {@link System#nanoTime()}.
# Line 1365 | Line 1451 | public class JSR166TestCase extends Test
1451          return NANOSECONDS.toMillis(System.nanoTime() - startNanoTime);
1452      }
1453  
1368 – //     void assertTerminatesPromptly(long timeoutMillis, Runnable r) {
1369 – //         long startTime = System.nanoTime();
1370 – //         try {
1371 – //             r.run();
1372 – //         } catch (Throwable fail) { threadUnexpectedException(fail); }
1373 – //         if (millisElapsedSince(startTime) > timeoutMillis/2)
1374 – //             throw new AssertionError("did not return promptly");
1375 – //     }
1376 –
1377 – //     void assertTerminatesPromptly(Runnable r) {
1378 – //         assertTerminatesPromptly(LONG_DELAY_MS/2, r);
1379 – //     }
1380 –
1454      /**
1455       * Checks that timed f.get() returns the expected value, and does not
1456       * wait for the timeout to elapse before returning.
# Line 1408 | Line 1481 | public class JSR166TestCase extends Test
1481      }
1482  
1483      /**
1484 +     * Returns a new started daemon Thread running the given action,
1485 +     * wrapped in a CheckedRunnable.
1486 +     */
1487 +    Thread newStartedThread(Action action) {
1488 +        return newStartedThread(checkedRunnable(action));
1489 +    }
1490 +
1491 +    /**
1492       * Waits for the specified time (in milliseconds) for the thread
1493       * to terminate (using {@link Thread#join(long)}), else interrupts
1494       * the thread (in the hope that it may terminate later) and fails.
1495       */
1496 <    void awaitTermination(Thread t, long timeoutMillis) {
1496 >    void awaitTermination(Thread thread, long timeoutMillis) {
1497          try {
1498 <            t.join(timeoutMillis);
1498 >            thread.join(timeoutMillis);
1499          } catch (InterruptedException fail) {
1500              threadUnexpectedException(fail);
1501 <        } finally {
1502 <            if (t.getState() != Thread.State.TERMINATED) {
1503 <                t.interrupt();
1504 <                threadFail("timed out waiting for thread to terminate");
1501 >        }
1502 >        if (thread.getState() != Thread.State.TERMINATED) {
1503 >            String detail = String.format(
1504 >                    "timed out waiting for thread to terminate, thread=%s, state=%s" ,
1505 >                    thread, thread.getState());
1506 >            try {
1507 >                threadFail(detail);
1508 >            } finally {
1509 >                // Interrupt thread __after__ having reported its stack trace
1510 >                thread.interrupt();
1511              }
1512          }
1513      }
# Line 1448 | Line 1535 | public class JSR166TestCase extends Test
1535          }
1536      }
1537  
1538 +    Runnable checkedRunnable(Action action) {
1539 +        return new CheckedRunnable() {
1540 +            public void realRun() throws Throwable {
1541 +                action.run();
1542 +            }};
1543 +    }
1544 +
1545      public abstract class ThreadShouldThrow extends Thread {
1546          protected abstract void realRun() throws Throwable;
1547  
# Line 1686 | Line 1780 | public class JSR166TestCase extends Test
1780  
1781          public int await() {
1782              try {
1783 <                return super.await(2 * LONG_DELAY_MS, MILLISECONDS);
1783 >                return super.await(LONGER_DELAY_MS, MILLISECONDS);
1784              } catch (TimeoutException timedOut) {
1785                  throw new AssertionError("timed out");
1786              } catch (Exception fail) {
# Line 1742 | Line 1836 | public class JSR166TestCase extends Test
1836          }
1837      }
1838  
1839 <    void assertImmutable(final Object o) {
1839 >    void assertImmutable(Object o) {
1840          if (o instanceof Collection) {
1841              assertThrows(
1842                  UnsupportedOperationException.class,
1843 <                new Runnable() { public void run() {
1750 <                        ((Collection) o).add(null);}});
1843 >                () -> ((Collection) o).add(null));
1844          }
1845      }
1846  
# Line 1807 | Line 1900 | public class JSR166TestCase extends Test
1900      }
1901  
1902      public void assertThrows(Class<? extends Throwable> expectedExceptionClass,
1903 <                             Runnable... throwingActions) {
1904 <        for (Runnable throwingAction : throwingActions) {
1903 >                             Action... throwingActions) {
1904 >        for (Action throwingAction : throwingActions) {
1905              boolean threw = false;
1906              try { throwingAction.run(); }
1907              catch (Throwable t) {

Diff Legend

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