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.246 by jsr166, Sun Jul 22 21:25:16 2018 UTC vs.
Revision 1.259 by jsr166, Thu Aug 22 22:27:57 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 668 | Line 685 | public class JSR166TestCase extends Test
685      static TimeUnit randomTimeUnit() { return RANDOM_TIMEUNIT; }
686  
687      /**
688 +     * Returns a random boolean; a "coin flip".
689 +     */
690 +    static boolean randomBoolean() {
691 +        return ThreadLocalRandom.current().nextBoolean();
692 +    }
693 +
694 +    /**
695 +     * Returns a random element from given choices.
696 +     */
697 +    <T> T chooseRandomly(T... choices) {
698 +        return choices[ThreadLocalRandom.current().nextInt(choices.length)];
699 +    }
700 +
701 +    /**
702       * Returns the shortest timed delay. This can be scaled up for
703       * slow machines using the jsr166.delay.factor system property,
704       * or via jtreg's -timeoutFactor: flag.
# Line 1291 | Line 1322 | public class JSR166TestCase extends Test
1322      /**
1323       * Spin-waits up to the specified number of milliseconds for the given
1324       * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1325 +     * @param waitingForGodot if non-null, an additional condition to satisfy
1326       */
1327 <    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
1328 <        long startTime = 0L;
1329 <        for (;;) {
1330 <            Thread.State s = thread.getState();
1331 <            if (s == Thread.State.BLOCKED ||
1332 <                s == Thread.State.WAITING ||
1333 <                s == Thread.State.TIMED_WAITING)
1334 <                return;
1335 <            else if (s == Thread.State.TERMINATED)
1327 >    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis,
1328 >                                       Callable<Boolean> waitingForGodot) {
1329 >        for (long startTime = 0L;;) {
1330 >            switch (thread.getState()) {
1331 >            default: break;
1332 >            case BLOCKED: case WAITING: case TIMED_WAITING:
1333 >                try {
1334 >                    if (waitingForGodot == null || waitingForGodot.call())
1335 >                        return;
1336 >                } catch (Throwable fail) { threadUnexpectedException(fail); }
1337 >                break;
1338 >            case TERMINATED:
1339                  fail("Unexpected thread termination");
1340 <            else if (startTime == 0L)
1340 >            }
1341 >
1342 >            if (startTime == 0L)
1343                  startTime = System.nanoTime();
1344              else if (millisElapsedSince(startTime) > timeoutMillis) {
1345 <                threadAssertTrue(thread.isAlive());
1346 <                fail("timed out waiting for thread to enter wait state");
1345 >                assertTrue(thread.isAlive());
1346 >                if (waitingForGodot == null
1347 >                    || thread.getState() == Thread.State.RUNNABLE)
1348 >                    fail("timed out waiting for thread to enter wait state");
1349 >                else
1350 >                    fail("timed out waiting for condition, thread state="
1351 >                         + thread.getState());
1352              }
1353              Thread.yield();
1354          }
# Line 1314 | Line 1356 | public class JSR166TestCase extends Test
1356  
1357      /**
1358       * Spin-waits up to the specified number of milliseconds for the given
1359 <     * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING,
1318 <     * and additionally satisfy the given condition.
1359 >     * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1360       */
1361 <    void waitForThreadToEnterWaitState(
1362 <        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 <        }
1361 >    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
1362 >        waitForThreadToEnterWaitState(thread, timeoutMillis, null);
1363      }
1364  
1365      /**
# Line 1347 | Line 1367 | public class JSR166TestCase extends Test
1367       * enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1368       */
1369      void waitForThreadToEnterWaitState(Thread thread) {
1370 <        waitForThreadToEnterWaitState(thread, LONG_DELAY_MS);
1370 >        waitForThreadToEnterWaitState(thread, LONG_DELAY_MS, null);
1371      }
1372  
1373      /**
# Line 1355 | Line 1375 | public class JSR166TestCase extends Test
1375       * enter a wait state: BLOCKED, WAITING, or TIMED_WAITING,
1376       * and additionally satisfy the given condition.
1377       */
1378 <    void waitForThreadToEnterWaitState(
1379 <        Thread thread, Callable<Boolean> waitingForGodot) {
1378 >    void waitForThreadToEnterWaitState(Thread thread,
1379 >                                       Callable<Boolean> waitingForGodot) {
1380          waitForThreadToEnterWaitState(thread, LONG_DELAY_MS, waitingForGodot);
1381      }
1382  
1383      /**
1384 +     * Spin-waits up to LONG_DELAY_MS milliseconds for the current thread to
1385 +     * be interrupted.  Clears the interrupt status before returning.
1386 +     */
1387 +    void awaitInterrupted() {
1388 +        for (long startTime = 0L; !Thread.interrupted(); ) {
1389 +            if (startTime == 0L)
1390 +                startTime = System.nanoTime();
1391 +            else if (millisElapsedSince(startTime) > LONG_DELAY_MS)
1392 +                fail("timed out waiting for thread interrupt");
1393 +            Thread.yield();
1394 +        }
1395 +    }
1396 +
1397 +    /**
1398       * Returns the number of milliseconds since time given by
1399       * startNanoTime, which must have been previously returned from a
1400       * call to {@link System#nanoTime()}.
# Line 1421 | Line 1455 | public class JSR166TestCase extends Test
1455              t.join(timeoutMillis);
1456          } catch (InterruptedException fail) {
1457              threadUnexpectedException(fail);
1458 <        } finally {
1459 <            if (t.getState() != Thread.State.TERMINATED) {
1460 <                t.interrupt();
1461 <                threadFail("timed out waiting for thread to terminate");
1462 <            }
1458 >        }
1459 >        Thread.State state;
1460 >        if ((state = t.getState()) != Thread.State.TERMINATED) {
1461 >            t.interrupt();
1462 >            threadFail("timed out waiting for thread to terminate; "
1463 >                       + "state=" + state);
1464          }
1465      }
1466  
# Line 1464 | Line 1499 | public class JSR166TestCase extends Test
1499          public final void run() {
1500              try {
1501                  realRun();
1467                threadShouldThrow(exceptionClass.getSimpleName());
1502              } catch (Throwable t) {
1503                  if (! exceptionClass.isInstance(t))
1504                      threadUnexpectedException(t);
1505 +                return;
1506              }
1507 +            threadShouldThrow(exceptionClass.getSimpleName());
1508          }
1509      }
1510  
# Line 1478 | Line 1514 | public class JSR166TestCase extends Test
1514          public final void run() {
1515              try {
1516                  realRun();
1481                threadShouldThrow("InterruptedException");
1517              } catch (InterruptedException success) {
1518                  threadAssertFalse(Thread.interrupted());
1519 +                return;
1520              } catch (Throwable fail) {
1521                  threadUnexpectedException(fail);
1522              }
1523 +            threadShouldThrow("InterruptedException");
1524          }
1525      }
1526  
# Line 1495 | Line 1532 | public class JSR166TestCase extends Test
1532                  return realCall();
1533              } catch (Throwable fail) {
1534                  threadUnexpectedException(fail);
1498                return null;
1499            }
1500        }
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);
1535              }
1536 <            return null;
1536 >            throw new AssertionError("unreached");
1537          }
1538      }
1539  
# Line 1629 | Line 1648 | public class JSR166TestCase extends Test
1648          public String call() { throw new NullPointerException(); }
1649      }
1650  
1632    public class SmallPossiblyInterruptedRunnable extends CheckedRunnable {
1633        protected void realRun() {
1634            try {
1635                delay(SMALL_DELAY_MS);
1636            } catch (InterruptedException ok) {}
1637        }
1638    }
1639
1651      public Runnable possiblyInterruptedRunnable(final long timeoutMillis) {
1652          return new CheckedRunnable() {
1653              protected void realRun() {
# Line 1692 | Line 1703 | public class JSR166TestCase extends Test
1703                  return realCompute();
1704              } catch (Throwable fail) {
1705                  threadUnexpectedException(fail);
1695                return null;
1706              }
1707 +            throw new AssertionError("unreached");
1708          }
1709      }
1710  
# Line 1770 | Line 1781 | public class JSR166TestCase extends Test
1781          }
1782      }
1783  
1784 <    void assertImmutable(final Object o) {
1784 >    void assertImmutable(Object o) {
1785          if (o instanceof Collection) {
1786              assertThrows(
1787                  UnsupportedOperationException.class,
1788 <                new Runnable() { public void run() {
1778 <                        ((Collection) o).add(null);}});
1788 >                () -> ((Collection) o).add(null));
1789          }
1790      }
1791  
1792      @SuppressWarnings("unchecked")
1793      <T> T serialClone(T o) {
1794 +        T clone = null;
1795          try {
1796              ObjectInputStream ois = new ObjectInputStream
1797                  (new ByteArrayInputStream(serialBytes(o)));
1798 <            T clone = (T) ois.readObject();
1788 <            if (o == clone) assertImmutable(o);
1789 <            assertSame(o.getClass(), clone.getClass());
1790 <            return clone;
1798 >            clone = (T) ois.readObject();
1799          } catch (Throwable fail) {
1800              threadUnexpectedException(fail);
1793            return null;
1801          }
1802 +        if (o == clone) assertImmutable(o);
1803 +        else assertSame(o.getClass(), clone.getClass());
1804 +        return clone;
1805      }
1806  
1807      /**
# Line 1810 | Line 1820 | public class JSR166TestCase extends Test
1820              (new ByteArrayInputStream(bos.toByteArray()));
1821          T clone = (T) ois.readObject();
1822          if (o == clone) assertImmutable(o);
1823 <        assertSame(o.getClass(), clone.getClass());
1823 >        else assertSame(o.getClass(), clone.getClass());
1824          return clone;
1825      }
1826  
# Line 1835 | Line 1845 | public class JSR166TestCase extends Test
1845      }
1846  
1847      public void assertThrows(Class<? extends Throwable> expectedExceptionClass,
1848 <                             Runnable... throwingActions) {
1849 <        for (Runnable throwingAction : throwingActions) {
1848 >                             Action... throwingActions) {
1849 >        for (Action throwingAction : throwingActions) {
1850              boolean threw = false;
1851              try { throwingAction.run(); }
1852              catch (Throwable t) {

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines