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.250 by jsr166, Sat Nov 24 21:48:19 2018 UTC vs.
Revision 1.266 by jsr166, Sat Sep 7 17:40:05 2019 UTC

# Line 284 | Line 284 | public class JSR166TestCase extends Test
284      static volatile TestCase currentTestCase;
285      // static volatile int currentRun = 0;
286      static {
287 <        Runnable checkForWedgedTest = new Runnable() { public void run() {
287 >        Runnable wedgedTestDetector = new Runnable() { public void run() {
288              // Avoid spurious reports with enormous runsPerTest.
289              // A single test case run should never take more than 1 second.
290              // But let's cap it at the high end too ...
291 <            final int timeoutMinutes =
292 <                Math.min(15, Math.max(runsPerTest / 60, 1));
291 >            final int timeoutMinutesMin = Math.max(runsPerTest / 60, 1)
292 >                * Math.max((int) delayFactor, 1);
293 >            final int timeoutMinutes = Math.min(15, timeoutMinutesMin);
294              for (TestCase lastTestCase = currentTestCase;;) {
295                  try { MINUTES.sleep(timeoutMinutes); }
296                  catch (InterruptedException unexpected) { break; }
# Line 309 | Line 310 | public class JSR166TestCase extends Test
310                  }
311                  lastTestCase = currentTestCase;
312              }}};
313 <        Thread thread = new Thread(checkForWedgedTest, "checkForWedgedTest");
313 >        Thread thread = new Thread(wedgedTestDetector, "WedgedTestDetector");
314          thread.setDaemon(true);
315          thread.start();
316      }
# Line 460 | Line 461 | public class JSR166TestCase extends Test
461      public static boolean atLeastJava9()  { return JAVA_CLASS_VERSION >= 53.0; }
462      public static boolean atLeastJava10() { return JAVA_CLASS_VERSION >= 54.0; }
463      public static boolean atLeastJava11() { return JAVA_CLASS_VERSION >= 55.0; }
464 +    public static boolean atLeastJava12() { return JAVA_CLASS_VERSION >= 56.0; }
465 +    public static boolean atLeastJava13() { return JAVA_CLASS_VERSION >= 57.0; }
466 +    public static boolean atLeastJava14() { return JAVA_CLASS_VERSION >= 58.0; }
467 +    public static boolean atLeastJava15() { return JAVA_CLASS_VERSION >= 59.0; }
468 +    public static boolean atLeastJava16() { return JAVA_CLASS_VERSION >= 60.0; }
469 +    public static boolean atLeastJava17() { return JAVA_CLASS_VERSION >= 61.0; }
470  
471      /**
472       * Collects all JSR166 unit tests as one suite.
# Line 511 | Line 518 | public class JSR166TestCase extends Test
518              ExecutorsTest.suite(),
519              ExecutorCompletionServiceTest.suite(),
520              FutureTaskTest.suite(),
521 +            HashtableTest.suite(),
522              LinkedBlockingDequeTest.suite(),
523              LinkedBlockingQueueTest.suite(),
524              LinkedListTest.suite(),
# Line 550 | Line 558 | public class JSR166TestCase extends Test
558                  "HashMapTest",
559                  "LinkedBlockingDeque8Test",
560                  "LinkedBlockingQueue8Test",
561 +                "LinkedHashMapTest",
562                  "LongAccumulatorTest",
563                  "LongAdderTest",
564                  "SplittableRandomTest",
# Line 648 | Line 657 | public class JSR166TestCase extends Test
657      public static long MEDIUM_DELAY_MS;
658      public static long LONG_DELAY_MS;
659  
660 +    /**
661 +     * A delay significantly longer than LONG_DELAY_MS.
662 +     * Use this in a thread that is waited for via awaitTermination(Thread).
663 +     */
664 +    public static long LONGER_DELAY_MS;
665 +
666      private static final long RANDOM_TIMEOUT;
667      private static final long RANDOM_EXPIRED_TIMEOUT;
668      private static final TimeUnit RANDOM_TIMEUNIT;
# Line 676 | Line 691 | public class JSR166TestCase extends Test
691      static TimeUnit randomTimeUnit() { return RANDOM_TIMEUNIT; }
692  
693      /**
694 +     * Returns a random boolean; a "coin flip".
695 +     */
696 +    static boolean randomBoolean() {
697 +        return ThreadLocalRandom.current().nextBoolean();
698 +    }
699 +
700 +    /**
701 +     * Returns a random element from given choices.
702 +     */
703 +    <T> T chooseRandomly(T... choices) {
704 +        return choices[ThreadLocalRandom.current().nextInt(choices.length)];
705 +    }
706 +
707 +    /**
708       * Returns the shortest timed delay. This can be scaled up for
709       * slow machines using the jsr166.delay.factor system property,
710       * or via jtreg's -timeoutFactor: flag.
# Line 693 | Line 722 | public class JSR166TestCase extends Test
722          SMALL_DELAY_MS  = SHORT_DELAY_MS * 5;
723          MEDIUM_DELAY_MS = SHORT_DELAY_MS * 10;
724          LONG_DELAY_MS   = SHORT_DELAY_MS * 200;
725 +        LONGER_DELAY_MS = 2 * LONG_DELAY_MS;
726      }
727  
728      private static final long TIMEOUT_DELAY_MS
# Line 731 | Line 761 | public class JSR166TestCase extends Test
761       */
762      public void threadRecordFailure(Throwable t) {
763          System.err.println(t);
764 <        dumpTestThreads();
765 <        threadFailure.compareAndSet(null, t);
764 >        if (threadFailure.compareAndSet(null, t))
765 >            dumpTestThreads();
766      }
767  
768      public void setUp() {
# Line 1053 | Line 1083 | public class JSR166TestCase extends Test
1083          }
1084      }
1085  
1086 +    /** Returns true if thread info might be useful in a thread dump. */
1087 +    static boolean threadOfInterest(ThreadInfo info) {
1088 +        final String name = info.getThreadName();
1089 +        String lockName;
1090 +        if (name == null)
1091 +            return true;
1092 +        if (name.equals("Signal Dispatcher")
1093 +            || name.equals("WedgedTestDetector"))
1094 +            return false;
1095 +        if (name.equals("Reference Handler")) {
1096 +            // Reference Handler stacktrace changed in JDK-8156500
1097 +            StackTraceElement[] stackTrace; String methodName;
1098 +            if ((stackTrace = info.getStackTrace()) != null
1099 +                && stackTrace.length > 0
1100 +                && (methodName = stackTrace[0].getMethodName()) != null
1101 +                && methodName.equals("waitForReferencePendingList"))
1102 +                return false;
1103 +            // jdk8 Reference Handler stacktrace
1104 +            if ((lockName = info.getLockName()) != null
1105 +                && lockName.startsWith("java.lang.ref"))
1106 +                return false;
1107 +        }
1108 +        if ((name.equals("Finalizer") || name.equals("Common-Cleaner"))
1109 +            && (lockName = info.getLockName()) != null
1110 +            && lockName.startsWith("java.lang.ref"))
1111 +            return false;
1112 +        if (name.startsWith("ForkJoinPool.commonPool-worker")
1113 +            && (lockName = info.getLockName()) != null
1114 +            && lockName.startsWith("java.util.concurrent.ForkJoinPool"))
1115 +            return false;
1116 +        return true;
1117 +    }
1118 +
1119      /**
1120       * A debugging tool to print stack traces of most threads, as jstack does.
1121       * Uninteresting threads are filtered out.
# Line 1069 | Line 1132 | public class JSR166TestCase extends Test
1132  
1133          ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
1134          System.err.println("------ stacktrace dump start ------");
1135 <        for (ThreadInfo info : threadMXBean.dumpAllThreads(true, true)) {
1136 <            final String name = info.getThreadName();
1137 <            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 <        }
1135 >        for (ThreadInfo info : threadMXBean.dumpAllThreads(true, true))
1136 >            if (threadOfInterest(info))
1137 >                System.err.print(info);
1138          System.err.println("------ stacktrace dump end ------");
1139  
1140          if (sm != null) System.setSecurityManager(sm);
# Line 1358 | Line 1407 | public class JSR166TestCase extends Test
1407      }
1408  
1409      /**
1410 +     * Spin-waits up to LONG_DELAY_MS milliseconds for the current thread to
1411 +     * be interrupted.  Clears the interrupt status before returning.
1412 +     */
1413 +    void awaitInterrupted() {
1414 +        for (long startTime = 0L; !Thread.interrupted(); ) {
1415 +            if (startTime == 0L)
1416 +                startTime = System.nanoTime();
1417 +            else if (millisElapsedSince(startTime) > LONG_DELAY_MS)
1418 +                fail("timed out waiting for thread interrupt");
1419 +            Thread.yield();
1420 +        }
1421 +    }
1422 +
1423 +    /**
1424       * Returns the number of milliseconds since time given by
1425       * startNanoTime, which must have been previously returned from a
1426       * call to {@link System#nanoTime()}.
# Line 1366 | Line 1429 | public class JSR166TestCase extends Test
1429          return NANOSECONDS.toMillis(System.nanoTime() - startNanoTime);
1430      }
1431  
1369 – //     void assertTerminatesPromptly(long timeoutMillis, Runnable r) {
1370 – //         long startTime = System.nanoTime();
1371 – //         try {
1372 – //             r.run();
1373 – //         } catch (Throwable fail) { threadUnexpectedException(fail); }
1374 – //         if (millisElapsedSince(startTime) > timeoutMillis/2)
1375 – //             throw new AssertionError("did not return promptly");
1376 – //     }
1377 –
1378 – //     void assertTerminatesPromptly(Runnable r) {
1379 – //         assertTerminatesPromptly(LONG_DELAY_MS/2, r);
1380 – //     }
1381 –
1432      /**
1433       * Checks that timed f.get() returns the expected value, and does not
1434       * wait for the timeout to elapse before returning.
# Line 1413 | Line 1463 | public class JSR166TestCase extends Test
1463       * to terminate (using {@link Thread#join(long)}), else interrupts
1464       * the thread (in the hope that it may terminate later) and fails.
1465       */
1466 <    void awaitTermination(Thread t, long timeoutMillis) {
1466 >    void awaitTermination(Thread thread, long timeoutMillis) {
1467          try {
1468 <            t.join(timeoutMillis);
1468 >            thread.join(timeoutMillis);
1469          } catch (InterruptedException fail) {
1470              threadUnexpectedException(fail);
1471 <        } finally {
1472 <            if (t.getState() != Thread.State.TERMINATED) {
1473 <                t.interrupt();
1474 <                threadFail("timed out waiting for thread to terminate");
1471 >        }
1472 >        if (thread.getState() != Thread.State.TERMINATED) {
1473 >            String detail = String.format(
1474 >                    "timed out waiting for thread to terminate, thread=%s, state=%s" ,
1475 >                    thread, thread.getState());
1476 >            try {
1477 >                threadFail(detail);
1478 >            } finally {
1479 >                // Interrupt thread __after__ having reported its stack trace
1480 >                thread.interrupt();
1481              }
1482          }
1483      }
# Line 1743 | Line 1799 | public class JSR166TestCase extends Test
1799          }
1800      }
1801  
1802 <    void assertImmutable(final Object o) {
1802 >    void assertImmutable(Object o) {
1803          if (o instanceof Collection) {
1804              assertThrows(
1805                  UnsupportedOperationException.class,
1806 <                new Runnable() { public void run() {
1751 <                        ((Collection) o).add(null);}});
1806 >                () -> ((Collection) o).add(null));
1807          }
1808      }
1809  
# Line 1808 | Line 1863 | public class JSR166TestCase extends Test
1863      }
1864  
1865      public void assertThrows(Class<? extends Throwable> expectedExceptionClass,
1866 <                             Runnable... throwingActions) {
1867 <        for (Runnable throwingAction : throwingActions) {
1866 >                             Action... throwingActions) {
1867 >        for (Action throwingAction : throwingActions) {
1868              boolean threw = false;
1869              try { throwingAction.run(); }
1870              catch (Throwable t) {

Diff Legend

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