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.243 by jsr166, Thu Apr 5 03:36:54 2018 UTC vs.
Revision 1.256 by jsr166, Sun Aug 11 22:29:26 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 451 | Line 460 | public class JSR166TestCase extends Test
460      public static boolean atLeastJava8()  { return JAVA_CLASS_VERSION >= 52.0; }
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 502 | 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 541 | Line 558 | public class JSR166TestCase extends Test
558                  "HashMapTest",
559                  "LinkedBlockingDeque8Test",
560                  "LinkedBlockingQueue8Test",
561 +                "LinkedHashMapTest",
562                  "LongAccumulatorTest",
563                  "LongAdderTest",
564                  "SplittableRandomTest",
# Line 667 | 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 the shortest timed delay. This can be scaled up for
696       * slow machines using the jsr166.delay.factor system property,
697       * or via jtreg's -timeoutFactor: flag.
# Line 1290 | Line 1315 | public class JSR166TestCase extends Test
1315      /**
1316       * Spin-waits up to the specified number of milliseconds for the given
1317       * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1318 +     * @param waitingForGodot if non-null, an additional condition to satisfy
1319       */
1320 <    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
1321 <        long startTime = 0L;
1322 <        for (;;) {
1323 <            Thread.State s = thread.getState();
1324 <            if (s == Thread.State.BLOCKED ||
1325 <                s == Thread.State.WAITING ||
1326 <                s == Thread.State.TIMED_WAITING)
1327 <                return;
1328 <            else if (s == Thread.State.TERMINATED)
1320 >    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis,
1321 >                                       Callable<Boolean> waitingForGodot) {
1322 >        for (long startTime = 0L;;) {
1323 >            switch (thread.getState()) {
1324 >            default: break;
1325 >            case BLOCKED: case WAITING: case TIMED_WAITING:
1326 >                try {
1327 >                    if (waitingForGodot == null || waitingForGodot.call())
1328 >                        return;
1329 >                } catch (Throwable fail) { threadUnexpectedException(fail); }
1330 >                break;
1331 >            case TERMINATED:
1332                  fail("Unexpected thread termination");
1333 <            else if (startTime == 0L)
1333 >            }
1334 >
1335 >            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");
1338 >                assertTrue(thread.isAlive());
1339 >                if (waitingForGodot == null
1340 >                    || thread.getState() == Thread.State.RUNNABLE)
1341 >                    fail("timed out waiting for thread to enter wait state");
1342 >                else
1343 >                    fail("timed out waiting for condition, thread state="
1344 >                         + thread.getState());
1345              }
1346              Thread.yield();
1347          }
# Line 1313 | Line 1349 | public class JSR166TestCase extends Test
1349  
1350      /**
1351       * Spin-waits up to the specified number of milliseconds for the given
1352 <     * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING,
1317 <     * and additionally satisfy the given condition.
1352 >     * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1353       */
1354 <    void waitForThreadToEnterWaitState(
1355 <        Thread thread, long timeoutMillis, Callable<Boolean> waitingForGodot) {
1321 <        long startTime = 0L;
1322 <        for (;;) {
1323 <            Thread.State s = thread.getState();
1324 <            if (s == Thread.State.BLOCKED ||
1325 <                s == Thread.State.WAITING ||
1326 <                s == Thread.State.TIMED_WAITING) {
1327 <                try {
1328 <                    if (waitingForGodot.call())
1329 <                        return;
1330 <                } catch (Throwable fail) { threadUnexpectedException(fail); }
1331 <            }
1332 <            else if (s == Thread.State.TERMINATED)
1333 <                fail("Unexpected thread termination");
1334 <            else if (startTime == 0L)
1335 <                startTime = System.nanoTime();
1336 <            else if (millisElapsedSince(startTime) > timeoutMillis) {
1337 <                threadAssertTrue(thread.isAlive());
1338 <                fail("timed out waiting for thread to enter wait state");
1339 <            }
1340 <            Thread.yield();
1341 <        }
1354 >    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
1355 >        waitForThreadToEnterWaitState(thread, timeoutMillis, null);
1356      }
1357  
1358      /**
# Line 1346 | Line 1360 | public class JSR166TestCase extends Test
1360       * enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1361       */
1362      void waitForThreadToEnterWaitState(Thread thread) {
1363 <        waitForThreadToEnterWaitState(thread, LONG_DELAY_MS);
1363 >        waitForThreadToEnterWaitState(thread, LONG_DELAY_MS, null);
1364      }
1365  
1366      /**
# Line 1354 | Line 1368 | public class JSR166TestCase extends Test
1368       * enter a wait state: BLOCKED, WAITING, or TIMED_WAITING,
1369       * and additionally satisfy the given condition.
1370       */
1371 <    void waitForThreadToEnterWaitState(
1372 <        Thread thread, Callable<Boolean> waitingForGodot) {
1371 >    void waitForThreadToEnterWaitState(Thread thread,
1372 >                                       Callable<Boolean> waitingForGodot) {
1373          waitForThreadToEnterWaitState(thread, LONG_DELAY_MS, waitingForGodot);
1374      }
1375  
# Line 1387 | Line 1401 | public class JSR166TestCase extends Test
1401       */
1402      <T> void checkTimedGet(Future<T> f, T expectedValue, long timeoutMillis) {
1403          long startTime = System.nanoTime();
1404 +        T actual = null;
1405          try {
1406 <            assertEquals(expectedValue, f.get(timeoutMillis, MILLISECONDS));
1406 >            actual = f.get(timeoutMillis, MILLISECONDS);
1407          } catch (Throwable fail) { threadUnexpectedException(fail); }
1408 +        assertEquals(expectedValue, actual);
1409          if (millisElapsedSince(startTime) > timeoutMillis/2)
1410              throw new AssertionError("timed get did not return promptly");
1411      }
# Line 1461 | Line 1477 | public class JSR166TestCase extends Test
1477          public final void run() {
1478              try {
1479                  realRun();
1464 –                threadShouldThrow(exceptionClass.getSimpleName());
1480              } catch (Throwable t) {
1481                  if (! exceptionClass.isInstance(t))
1482                      threadUnexpectedException(t);
1483 +                return;
1484              }
1485 +            threadShouldThrow(exceptionClass.getSimpleName());
1486          }
1487      }
1488  
# Line 1475 | Line 1492 | public class JSR166TestCase extends Test
1492          public final void run() {
1493              try {
1494                  realRun();
1478 –                threadShouldThrow("InterruptedException");
1495              } catch (InterruptedException success) {
1496                  threadAssertFalse(Thread.interrupted());
1497 +                return;
1498              } catch (Throwable fail) {
1499                  threadUnexpectedException(fail);
1500              }
1501 +            threadShouldThrow("InterruptedException");
1502          }
1503      }
1504  
# Line 1492 | Line 1510 | public class JSR166TestCase extends Test
1510                  return realCall();
1511              } catch (Throwable fail) {
1512                  threadUnexpectedException(fail);
1495 –                return null;
1496 –            }
1497 –        }
1498 –    }
1499 –
1500 –    public abstract class CheckedInterruptedCallable<T>
1501 –        implements Callable<T> {
1502 –        protected abstract T realCall() throws Throwable;
1503 –
1504 –        public final T call() {
1505 –            try {
1506 –                T result = realCall();
1507 –                threadShouldThrow("InterruptedException");
1508 –                return result;
1509 –            } catch (InterruptedException success) {
1510 –                threadAssertFalse(Thread.interrupted());
1511 –            } catch (Throwable fail) {
1512 –                threadUnexpectedException(fail);
1513              }
1514 <            return null;
1514 >            throw new AssertionError("unreached");
1515          }
1516      }
1517  
# Line 1568 | Line 1568 | public class JSR166TestCase extends Test
1568      }
1569  
1570      public void await(CountDownLatch latch, long timeoutMillis) {
1571 +        boolean timedOut = false;
1572          try {
1573 <            if (!latch.await(timeoutMillis, MILLISECONDS))
1573 <                fail("timed out waiting for CountDownLatch for "
1574 <                     + (timeoutMillis/1000) + " sec");
1573 >            timedOut = !latch.await(timeoutMillis, MILLISECONDS);
1574          } catch (Throwable fail) {
1575              threadUnexpectedException(fail);
1576          }
1577 +        if (timedOut)
1578 +            fail("timed out waiting for CountDownLatch for "
1579 +                 + (timeoutMillis/1000) + " sec");
1580      }
1581  
1582      public void await(CountDownLatch latch) {
# Line 1582 | Line 1584 | public class JSR166TestCase extends Test
1584      }
1585  
1586      public void await(Semaphore semaphore) {
1587 +        boolean timedOut = false;
1588          try {
1589 <            if (!semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS))
1587 <                fail("timed out waiting for Semaphore for "
1588 <                     + (LONG_DELAY_MS/1000) + " sec");
1589 >            timedOut = !semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS);
1590          } catch (Throwable fail) {
1591              threadUnexpectedException(fail);
1592          }
1593 +        if (timedOut)
1594 +            fail("timed out waiting for Semaphore for "
1595 +                 + (LONG_DELAY_MS/1000) + " sec");
1596      }
1597  
1598      public void await(CyclicBarrier barrier) {
# Line 1622 | Line 1626 | public class JSR166TestCase extends Test
1626          public String call() { throw new NullPointerException(); }
1627      }
1628  
1625 –    public class SmallPossiblyInterruptedRunnable extends CheckedRunnable {
1626 –        protected void realRun() {
1627 –            try {
1628 –                delay(SMALL_DELAY_MS);
1629 –            } catch (InterruptedException ok) {}
1630 –        }
1631 –    }
1632 –
1629      public Runnable possiblyInterruptedRunnable(final long timeoutMillis) {
1630          return new CheckedRunnable() {
1631              protected void realRun() {
# Line 1685 | Line 1681 | public class JSR166TestCase extends Test
1681                  return realCompute();
1682              } catch (Throwable fail) {
1683                  threadUnexpectedException(fail);
1688 –                return null;
1684              }
1685 +            throw new AssertionError("unreached");
1686          }
1687      }
1688  
# Line 1763 | Line 1759 | public class JSR166TestCase extends Test
1759          }
1760      }
1761  
1762 <    void assertImmutable(final Object o) {
1762 >    void assertImmutable(Object o) {
1763          if (o instanceof Collection) {
1764              assertThrows(
1765                  UnsupportedOperationException.class,
1766 <                new Runnable() { public void run() {
1771 <                        ((Collection) o).add(null);}});
1766 >                () -> ((Collection) o).add(null));
1767          }
1768      }
1769  
1770      @SuppressWarnings("unchecked")
1771      <T> T serialClone(T o) {
1772 +        T clone = null;
1773          try {
1774              ObjectInputStream ois = new ObjectInputStream
1775                  (new ByteArrayInputStream(serialBytes(o)));
1776 <            T clone = (T) ois.readObject();
1781 <            if (o == clone) assertImmutable(o);
1782 <            assertSame(o.getClass(), clone.getClass());
1783 <            return clone;
1776 >            clone = (T) ois.readObject();
1777          } catch (Throwable fail) {
1778              threadUnexpectedException(fail);
1786 –            return null;
1779          }
1780 +        if (o == clone) assertImmutable(o);
1781 +        else assertSame(o.getClass(), clone.getClass());
1782 +        return clone;
1783      }
1784  
1785      /**
# Line 1803 | Line 1798 | public class JSR166TestCase extends Test
1798              (new ByteArrayInputStream(bos.toByteArray()));
1799          T clone = (T) ois.readObject();
1800          if (o == clone) assertImmutable(o);
1801 <        assertSame(o.getClass(), clone.getClass());
1801 >        else assertSame(o.getClass(), clone.getClass());
1802          return clone;
1803      }
1804  
# Line 1828 | Line 1823 | public class JSR166TestCase extends Test
1823      }
1824  
1825      public void assertThrows(Class<? extends Throwable> expectedExceptionClass,
1826 <                             Runnable... throwingActions) {
1827 <        for (Runnable throwingAction : throwingActions) {
1826 >                             Action... throwingActions) {
1827 >        for (Action throwingAction : throwingActions) {
1828              boolean threw = false;
1829              try { throwingAction.run(); }
1830              catch (Throwable t) {

Diff Legend

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