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.247 by jsr166, Sun Jul 22 21:37:31 2018 UTC vs.
Revision 1.262 by jsr166, Thu Sep 5 21:26:24 2019 UTC

# Line 117 | Line 117 | import junit.framework.TestSuite;
117   *
118   * <ol>
119   *
120 < * <li>All assertions in code running in generated threads must use
121 < * the forms {@link #threadFail}, {@link #threadAssertTrue}, {@link
122 < * #threadAssertEquals}, or {@link #threadAssertNull}, (not
123 < * {@code fail}, {@code assertTrue}, etc.) It is OK (but not
124 < * particularly recommended) for other code to use these forms too.
125 < * Only the most typically used JUnit assertion methods are defined
126 < * this way, but enough to live with.
120 > * <li>All code not running in the main test thread (manually spawned threads
121 > * or the common fork join pool) must be checked for failure (and completion!).
122 > * Mechanisms that can be used to ensure this are:
123 > *   <ol>
124 > *   <li>Signalling via a synchronizer like AtomicInteger or CountDownLatch
125 > *    that the task completed normally, which is checked before returning from
126 > *    the test method in the main thread.
127 > *   <li>Using the forms {@link #threadFail}, {@link #threadAssertTrue},
128 > *    or {@link #threadAssertNull}, (not {@code fail}, {@code assertTrue}, etc.)
129 > *    Only the most typically used JUnit assertion methods are defined
130 > *    this way, but enough to live with.
131 > *   <li>Recording failure explicitly using {@link #threadUnexpectedException}
132 > *    or {@link #threadRecordFailure}.
133 > *   <li>Using a wrapper like CheckedRunnable that uses one the mechanisms above.
134 > *   </ol>
135   *
136   * <li>If you override {@link #setUp} or {@link #tearDown}, make sure
137   * to invoke {@code super.setUp} and {@code super.tearDown} within
# Line 280 | Line 288 | public class JSR166TestCase extends Test
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 452 | 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 503 | 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 542 | Line 558 | public class JSR166TestCase extends Test
558                  "HashMapTest",
559                  "LinkedBlockingDeque8Test",
560                  "LinkedBlockingQueue8Test",
561 +                "LinkedHashMapTest",
562                  "LongAccumulatorTest",
563                  "LongAdderTest",
564                  "SplittableRandomTest",
# Line 640 | 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 668 | 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 685 | 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 723 | 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 1291 | Line 1329 | public class JSR166TestCase extends Test
1329      /**
1330       * Spin-waits up to the specified number of milliseconds for the given
1331       * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1332 +     * @param waitingForGodot if non-null, an additional condition to satisfy
1333       */
1334 <    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
1335 <        long startTime = 0L;
1336 <        for (;;) {
1337 <            Thread.State s = thread.getState();
1338 <            if (s == Thread.State.BLOCKED ||
1339 <                s == Thread.State.WAITING ||
1340 <                s == Thread.State.TIMED_WAITING)
1341 <                return;
1342 <            else if (s == Thread.State.TERMINATED)
1334 >    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis,
1335 >                                       Callable<Boolean> waitingForGodot) {
1336 >        for (long startTime = 0L;;) {
1337 >            switch (thread.getState()) {
1338 >            default: break;
1339 >            case BLOCKED: case WAITING: case TIMED_WAITING:
1340 >                try {
1341 >                    if (waitingForGodot == null || waitingForGodot.call())
1342 >                        return;
1343 >                } catch (Throwable fail) { threadUnexpectedException(fail); }
1344 >                break;
1345 >            case TERMINATED:
1346                  fail("Unexpected thread termination");
1347 <            else if (startTime == 0L)
1347 >            }
1348 >
1349 >            if (startTime == 0L)
1350                  startTime = System.nanoTime();
1351              else if (millisElapsedSince(startTime) > timeoutMillis) {
1352 <                threadAssertTrue(thread.isAlive());
1353 <                fail("timed out waiting for thread to enter wait state");
1352 >                assertTrue(thread.isAlive());
1353 >                if (waitingForGodot == null
1354 >                    || thread.getState() == Thread.State.RUNNABLE)
1355 >                    fail("timed out waiting for thread to enter wait state");
1356 >                else
1357 >                    fail("timed out waiting for condition, thread state="
1358 >                         + thread.getState());
1359              }
1360              Thread.yield();
1361          }
# Line 1314 | Line 1363 | public class JSR166TestCase extends Test
1363  
1364      /**
1365       * Spin-waits up to the specified number of milliseconds for the given
1366 <     * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING,
1318 <     * and additionally satisfy the given condition.
1366 >     * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1367       */
1368 <    void waitForThreadToEnterWaitState(
1369 <        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 <        }
1368 >    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
1369 >        waitForThreadToEnterWaitState(thread, timeoutMillis, null);
1370      }
1371  
1372      /**
# Line 1347 | Line 1374 | public class JSR166TestCase extends Test
1374       * enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1375       */
1376      void waitForThreadToEnterWaitState(Thread thread) {
1377 <        waitForThreadToEnterWaitState(thread, LONG_DELAY_MS);
1377 >        waitForThreadToEnterWaitState(thread, LONG_DELAY_MS, null);
1378      }
1379  
1380      /**
# Line 1355 | Line 1382 | public class JSR166TestCase extends Test
1382       * enter a wait state: BLOCKED, WAITING, or TIMED_WAITING,
1383       * and additionally satisfy the given condition.
1384       */
1385 <    void waitForThreadToEnterWaitState(
1386 <        Thread thread, Callable<Boolean> waitingForGodot) {
1385 >    void waitForThreadToEnterWaitState(Thread thread,
1386 >                                       Callable<Boolean> waitingForGodot) {
1387          waitForThreadToEnterWaitState(thread, LONG_DELAY_MS, waitingForGodot);
1388      }
1389  
1390      /**
1391 +     * Spin-waits up to LONG_DELAY_MS milliseconds for the current thread to
1392 +     * be interrupted.  Clears the interrupt status before returning.
1393 +     */
1394 +    void awaitInterrupted() {
1395 +        for (long startTime = 0L; !Thread.interrupted(); ) {
1396 +            if (startTime == 0L)
1397 +                startTime = System.nanoTime();
1398 +            else if (millisElapsedSince(startTime) > LONG_DELAY_MS)
1399 +                fail("timed out waiting for thread interrupt");
1400 +            Thread.yield();
1401 +        }
1402 +    }
1403 +
1404 +    /**
1405       * Returns the number of milliseconds since time given by
1406       * startNanoTime, which must have been previously returned from a
1407       * call to {@link System#nanoTime()}.
# Line 1416 | Line 1457 | public class JSR166TestCase extends Test
1457       * to terminate (using {@link Thread#join(long)}), else interrupts
1458       * the thread (in the hope that it may terminate later) and fails.
1459       */
1460 <    void awaitTermination(Thread t, long timeoutMillis) {
1460 >    void awaitTermination(Thread thread, long timeoutMillis) {
1461          try {
1462 <            t.join(timeoutMillis);
1462 >            thread.join(timeoutMillis);
1463          } catch (InterruptedException fail) {
1464              threadUnexpectedException(fail);
1465 <        } finally {
1466 <            if (t.getState() != Thread.State.TERMINATED) {
1467 <                t.interrupt();
1468 <                threadFail("timed out waiting for thread to terminate");
1465 >        }
1466 >        if (thread.getState() != Thread.State.TERMINATED) {
1467 >            String detail = String.format(
1468 >                    "timed out waiting for thread to terminate, thread=%s, state=%s" ,
1469 >                    thread, thread.getState());
1470 >            try {
1471 >                threadFail(detail);
1472 >            } finally {
1473 >                // Interrupt thread __after__ having reported its stack trace
1474 >                thread.interrupt();
1475              }
1476          }
1477      }
# Line 1464 | Line 1511 | public class JSR166TestCase extends Test
1511          public final void run() {
1512              try {
1513                  realRun();
1467 –                threadShouldThrow(exceptionClass.getSimpleName());
1514              } catch (Throwable t) {
1515                  if (! exceptionClass.isInstance(t))
1516                      threadUnexpectedException(t);
1517 +                return;
1518              }
1519 +            threadShouldThrow(exceptionClass.getSimpleName());
1520          }
1521      }
1522  
# Line 1478 | Line 1526 | public class JSR166TestCase extends Test
1526          public final void run() {
1527              try {
1528                  realRun();
1481 –                threadShouldThrow("InterruptedException");
1529              } catch (InterruptedException success) {
1530                  threadAssertFalse(Thread.interrupted());
1531 +                return;
1532              } catch (Throwable fail) {
1533                  threadUnexpectedException(fail);
1534              }
1535 +            threadShouldThrow("InterruptedException");
1536          }
1537      }
1538  
# Line 1495 | Line 1544 | public class JSR166TestCase extends Test
1544                  return realCall();
1545              } catch (Throwable fail) {
1546                  threadUnexpectedException(fail);
1498 –                return null;
1547              }
1548 <        }
1501 <    }
1502 <
1503 <    public abstract class CheckedInterruptedCallable<T>
1504 <        implements Callable<T> {
1505 <        protected abstract T realCall() throws Throwable;
1506 <
1507 <        public final T call() {
1508 <            try {
1509 <                T result = realCall();
1510 <                threadShouldThrow("InterruptedException");
1511 <                return result;
1512 <            } catch (InterruptedException success) {
1513 <                threadAssertFalse(Thread.interrupted());
1514 <            } catch (Throwable fail) {
1515 <                threadUnexpectedException(fail);
1516 <            }
1517 <            return null;
1548 >            throw new AssertionError("unreached");
1549          }
1550      }
1551  
# Line 1629 | Line 1660 | public class JSR166TestCase extends Test
1660          public String call() { throw new NullPointerException(); }
1661      }
1662  
1632 –    public class SmallPossiblyInterruptedRunnable extends CheckedRunnable {
1633 –        protected void realRun() {
1634 –            try {
1635 –                delay(SMALL_DELAY_MS);
1636 –            } catch (InterruptedException ok) {}
1637 –        }
1638 –    }
1639 –
1663      public Runnable possiblyInterruptedRunnable(final long timeoutMillis) {
1664          return new CheckedRunnable() {
1665              protected void realRun() {
# Line 1692 | Line 1715 | public class JSR166TestCase extends Test
1715                  return realCompute();
1716              } catch (Throwable fail) {
1717                  threadUnexpectedException(fail);
1695 –                return null;
1718              }
1719 +            throw new AssertionError("unreached");
1720          }
1721      }
1722  
# Line 1770 | Line 1793 | public class JSR166TestCase extends Test
1793          }
1794      }
1795  
1796 <    void assertImmutable(final Object o) {
1796 >    void assertImmutable(Object o) {
1797          if (o instanceof Collection) {
1798              assertThrows(
1799                  UnsupportedOperationException.class,
1800 <                new Runnable() { public void run() {
1778 <                        ((Collection) o).add(null);}});
1800 >                () -> ((Collection) o).add(null));
1801          }
1802      }
1803  
# Line 1835 | Line 1857 | public class JSR166TestCase extends Test
1857      }
1858  
1859      public void assertThrows(Class<? extends Throwable> expectedExceptionClass,
1860 <                             Runnable... throwingActions) {
1861 <        for (Runnable throwingAction : throwingActions) {
1860 >                             Action... throwingActions) {
1861 >        for (Action throwingAction : throwingActions) {
1862              boolean threw = false;
1863              try { throwingAction.run(); }
1864              catch (Throwable t) {

Diff Legend

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