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.241 by jsr166, Sun Jan 28 16:20:42 2018 UTC vs.
Revision 1.254 by jsr166, Wed Apr 24 17:36:09 2019 UTC

# Line 66 | Line 66 | import java.util.Arrays;
66   import java.util.Collection;
67   import java.util.Collections;
68   import java.util.Date;
69 + import java.util.Deque;
70   import java.util.Enumeration;
71 + import java.util.HashSet;
72   import java.util.Iterator;
73   import java.util.List;
74   import java.util.NoSuchElementException;
75   import java.util.PropertyPermission;
76 + import java.util.Set;
77   import java.util.concurrent.BlockingQueue;
78   import java.util.concurrent.Callable;
79   import java.util.concurrent.CountDownLatch;
# Line 114 | 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 448 | Line 459 | public class JSR166TestCase extends Test
459      public static boolean atLeastJava8()  { return JAVA_CLASS_VERSION >= 52.0; }
460      public static boolean atLeastJava9()  { return JAVA_CLASS_VERSION >= 53.0; }
461      public static boolean atLeastJava10() { return JAVA_CLASS_VERSION >= 54.0; }
462 +    public static boolean atLeastJava11() { return JAVA_CLASS_VERSION >= 55.0; }
463 +    public static boolean atLeastJava12() { return JAVA_CLASS_VERSION >= 56.0; }
464 +    public static boolean atLeastJava13() { return JAVA_CLASS_VERSION >= 57.0; }
465 +    public static boolean atLeastJava14() { return JAVA_CLASS_VERSION >= 58.0; }
466 +    public static boolean atLeastJava15() { return JAVA_CLASS_VERSION >= 59.0; }
467 +    public static boolean atLeastJava16() { return JAVA_CLASS_VERSION >= 60.0; }
468 +    public static boolean atLeastJava17() { return JAVA_CLASS_VERSION >= 61.0; }
469  
470      /**
471       * Collects all JSR166 unit tests as one suite.
# Line 499 | Line 517 | public class JSR166TestCase extends Test
517              ExecutorsTest.suite(),
518              ExecutorCompletionServiceTest.suite(),
519              FutureTaskTest.suite(),
520 +            HashtableTest.suite(),
521              LinkedBlockingDequeTest.suite(),
522              LinkedBlockingQueueTest.suite(),
523              LinkedListTest.suite(),
# Line 538 | Line 557 | public class JSR166TestCase extends Test
557                  "HashMapTest",
558                  "LinkedBlockingDeque8Test",
559                  "LinkedBlockingQueue8Test",
560 +                "LinkedHashMapTest",
561                  "LongAccumulatorTest",
562                  "LongAdderTest",
563                  "SplittableRandomTest",
# Line 1287 | Line 1307 | public class JSR166TestCase extends Test
1307      /**
1308       * Spin-waits up to the specified number of milliseconds for the given
1309       * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1310 +     * @param waitingForGodot if non-null, an additional condition to satisfy
1311       */
1312 <    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
1313 <        long startTime = 0L;
1314 <        for (;;) {
1315 <            Thread.State s = thread.getState();
1316 <            if (s == Thread.State.BLOCKED ||
1317 <                s == Thread.State.WAITING ||
1318 <                s == Thread.State.TIMED_WAITING)
1319 <                return;
1320 <            else if (s == Thread.State.TERMINATED)
1312 >    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis,
1313 >                                       Callable<Boolean> waitingForGodot) {
1314 >        for (long startTime = 0L;;) {
1315 >            switch (thread.getState()) {
1316 >            default: break;
1317 >            case BLOCKED: case WAITING: case TIMED_WAITING:
1318 >                try {
1319 >                    if (waitingForGodot == null || waitingForGodot.call())
1320 >                        return;
1321 >                } catch (Throwable fail) { threadUnexpectedException(fail); }
1322 >                break;
1323 >            case TERMINATED:
1324                  fail("Unexpected thread termination");
1325 <            else if (startTime == 0L)
1325 >            }
1326 >
1327 >            if (startTime == 0L)
1328                  startTime = System.nanoTime();
1329              else if (millisElapsedSince(startTime) > timeoutMillis) {
1330 <                threadAssertTrue(thread.isAlive());
1331 <                fail("timed out waiting for thread to enter wait state");
1330 >                assertTrue(thread.isAlive());
1331 >                if (waitingForGodot == null
1332 >                    || thread.getState() == Thread.State.RUNNABLE)
1333 >                    fail("timed out waiting for thread to enter wait state");
1334 >                else
1335 >                    fail("timed out waiting for condition, thread state="
1336 >                         + thread.getState());
1337              }
1338              Thread.yield();
1339          }
# Line 1310 | Line 1341 | public class JSR166TestCase extends Test
1341  
1342      /**
1343       * Spin-waits up to the specified number of milliseconds for the given
1344 <     * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING,
1314 <     * and additionally satisfy the given condition.
1344 >     * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1345       */
1346 <    void waitForThreadToEnterWaitState(
1347 <        Thread thread, long timeoutMillis, Callable<Boolean> waitingForGodot) {
1318 <        long startTime = 0L;
1319 <        for (;;) {
1320 <            Thread.State s = thread.getState();
1321 <            if (s == Thread.State.BLOCKED ||
1322 <                s == Thread.State.WAITING ||
1323 <                s == Thread.State.TIMED_WAITING) {
1324 <                try {
1325 <                    if (waitingForGodot.call())
1326 <                        return;
1327 <                } catch (Throwable fail) { threadUnexpectedException(fail); }
1328 <            }
1329 <            else if (s == Thread.State.TERMINATED)
1330 <                fail("Unexpected thread termination");
1331 <            else if (startTime == 0L)
1332 <                startTime = System.nanoTime();
1333 <            else if (millisElapsedSince(startTime) > timeoutMillis) {
1334 <                threadAssertTrue(thread.isAlive());
1335 <                fail("timed out waiting for thread to enter wait state");
1336 <            }
1337 <            Thread.yield();
1338 <        }
1346 >    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
1347 >        waitForThreadToEnterWaitState(thread, timeoutMillis, null);
1348      }
1349  
1350      /**
# Line 1343 | Line 1352 | public class JSR166TestCase extends Test
1352       * enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1353       */
1354      void waitForThreadToEnterWaitState(Thread thread) {
1355 <        waitForThreadToEnterWaitState(thread, LONG_DELAY_MS);
1355 >        waitForThreadToEnterWaitState(thread, LONG_DELAY_MS, null);
1356      }
1357  
1358      /**
# Line 1351 | Line 1360 | public class JSR166TestCase extends Test
1360       * enter a wait state: BLOCKED, WAITING, or TIMED_WAITING,
1361       * and additionally satisfy the given condition.
1362       */
1363 <    void waitForThreadToEnterWaitState(
1364 <        Thread thread, Callable<Boolean> waitingForGodot) {
1363 >    void waitForThreadToEnterWaitState(Thread thread,
1364 >                                       Callable<Boolean> waitingForGodot) {
1365          waitForThreadToEnterWaitState(thread, LONG_DELAY_MS, waitingForGodot);
1366      }
1367  
# Line 1384 | Line 1393 | public class JSR166TestCase extends Test
1393       */
1394      <T> void checkTimedGet(Future<T> f, T expectedValue, long timeoutMillis) {
1395          long startTime = System.nanoTime();
1396 +        T actual = null;
1397          try {
1398 <            assertEquals(expectedValue, f.get(timeoutMillis, MILLISECONDS));
1398 >            actual = f.get(timeoutMillis, MILLISECONDS);
1399          } catch (Throwable fail) { threadUnexpectedException(fail); }
1400 +        assertEquals(expectedValue, actual);
1401          if (millisElapsedSince(startTime) > timeoutMillis/2)
1402              throw new AssertionError("timed get did not return promptly");
1403      }
# Line 1446 | Line 1457 | public class JSR166TestCase extends Test
1457          }
1458      }
1459  
1449 –    public abstract class RunnableShouldThrow implements Runnable {
1450 –        protected abstract void realRun() throws Throwable;
1451 –
1452 –        final Class<?> exceptionClass;
1453 –
1454 –        <T extends Throwable> RunnableShouldThrow(Class<T> exceptionClass) {
1455 –            this.exceptionClass = exceptionClass;
1456 –        }
1457 –
1458 –        public final void run() {
1459 –            try {
1460 –                realRun();
1461 –                threadShouldThrow(exceptionClass.getSimpleName());
1462 –            } catch (Throwable t) {
1463 –                if (! exceptionClass.isInstance(t))
1464 –                    threadUnexpectedException(t);
1465 –            }
1466 –        }
1467 –    }
1468 –
1460      public abstract class ThreadShouldThrow extends Thread {
1461          protected abstract void realRun() throws Throwable;
1462  
# Line 1478 | Line 1469 | public class JSR166TestCase extends Test
1469          public final void run() {
1470              try {
1471                  realRun();
1481 –                threadShouldThrow(exceptionClass.getSimpleName());
1472              } catch (Throwable t) {
1473                  if (! exceptionClass.isInstance(t))
1474                      threadUnexpectedException(t);
1475 +                return;
1476              }
1477 +            threadShouldThrow(exceptionClass.getSimpleName());
1478          }
1479      }
1480  
# Line 1492 | Line 1484 | public class JSR166TestCase extends Test
1484          public final void run() {
1485              try {
1486                  realRun();
1495 –                threadShouldThrow("InterruptedException");
1487              } catch (InterruptedException success) {
1488                  threadAssertFalse(Thread.interrupted());
1489 +                return;
1490              } catch (Throwable fail) {
1491                  threadUnexpectedException(fail);
1492              }
1493 +            threadShouldThrow("InterruptedException");
1494          }
1495      }
1496  
# Line 1509 | Line 1502 | public class JSR166TestCase extends Test
1502                  return realCall();
1503              } catch (Throwable fail) {
1504                  threadUnexpectedException(fail);
1512 –                return null;
1513 –            }
1514 –        }
1515 –    }
1516 –
1517 –    public abstract class CheckedInterruptedCallable<T>
1518 –        implements Callable<T> {
1519 –        protected abstract T realCall() throws Throwable;
1520 –
1521 –        public final T call() {
1522 –            try {
1523 –                T result = realCall();
1524 –                threadShouldThrow("InterruptedException");
1525 –                return result;
1526 –            } catch (InterruptedException success) {
1527 –                threadAssertFalse(Thread.interrupted());
1528 –            } catch (Throwable fail) {
1529 –                threadUnexpectedException(fail);
1505              }
1506 <            return null;
1506 >            throw new AssertionError("unreached");
1507          }
1508      }
1509  
# Line 1585 | Line 1560 | public class JSR166TestCase extends Test
1560      }
1561  
1562      public void await(CountDownLatch latch, long timeoutMillis) {
1563 +        boolean timedOut = false;
1564          try {
1565 <            if (!latch.await(timeoutMillis, MILLISECONDS))
1590 <                fail("timed out waiting for CountDownLatch for "
1591 <                     + (timeoutMillis/1000) + " sec");
1565 >            timedOut = !latch.await(timeoutMillis, MILLISECONDS);
1566          } catch (Throwable fail) {
1567              threadUnexpectedException(fail);
1568          }
1569 +        if (timedOut)
1570 +            fail("timed out waiting for CountDownLatch for "
1571 +                 + (timeoutMillis/1000) + " sec");
1572      }
1573  
1574      public void await(CountDownLatch latch) {
# Line 1599 | Line 1576 | public class JSR166TestCase extends Test
1576      }
1577  
1578      public void await(Semaphore semaphore) {
1579 +        boolean timedOut = false;
1580          try {
1581 <            if (!semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS))
1604 <                fail("timed out waiting for Semaphore for "
1605 <                     + (LONG_DELAY_MS/1000) + " sec");
1581 >            timedOut = !semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS);
1582          } catch (Throwable fail) {
1583              threadUnexpectedException(fail);
1584          }
1585 +        if (timedOut)
1586 +            fail("timed out waiting for Semaphore for "
1587 +                 + (LONG_DELAY_MS/1000) + " sec");
1588      }
1589  
1590      public void await(CyclicBarrier barrier) {
# Line 1639 | Line 1618 | public class JSR166TestCase extends Test
1618          public String call() { throw new NullPointerException(); }
1619      }
1620  
1642 –    public class SmallPossiblyInterruptedRunnable extends CheckedRunnable {
1643 –        protected void realRun() {
1644 –            try {
1645 –                delay(SMALL_DELAY_MS);
1646 –            } catch (InterruptedException ok) {}
1647 –        }
1648 –    }
1649 –
1621      public Runnable possiblyInterruptedRunnable(final long timeoutMillis) {
1622          return new CheckedRunnable() {
1623              protected void realRun() {
# Line 1702 | Line 1673 | public class JSR166TestCase extends Test
1673                  return realCompute();
1674              } catch (Throwable fail) {
1675                  threadUnexpectedException(fail);
1705 –                return null;
1676              }
1677 +            throw new AssertionError("unreached");
1678          }
1679      }
1680  
# Line 1780 | Line 1751 | public class JSR166TestCase extends Test
1751          }
1752      }
1753  
1754 <    void assertImmutable(final Object o) {
1754 >    void assertImmutable(Object o) {
1755          if (o instanceof Collection) {
1756              assertThrows(
1757                  UnsupportedOperationException.class,
1758 <                new Runnable() { public void run() {
1788 <                        ((Collection) o).add(null);}});
1758 >                () -> ((Collection) o).add(null));
1759          }
1760      }
1761  
1762      @SuppressWarnings("unchecked")
1763      <T> T serialClone(T o) {
1764 +        T clone = null;
1765          try {
1766              ObjectInputStream ois = new ObjectInputStream
1767                  (new ByteArrayInputStream(serialBytes(o)));
1768 <            T clone = (T) ois.readObject();
1798 <            if (o == clone) assertImmutable(o);
1799 <            assertSame(o.getClass(), clone.getClass());
1800 <            return clone;
1768 >            clone = (T) ois.readObject();
1769          } catch (Throwable fail) {
1770              threadUnexpectedException(fail);
1803 –            return null;
1771          }
1772 +        if (o == clone) assertImmutable(o);
1773 +        else assertSame(o.getClass(), clone.getClass());
1774 +        return clone;
1775      }
1776  
1777      /**
# Line 1820 | Line 1790 | public class JSR166TestCase extends Test
1790              (new ByteArrayInputStream(bos.toByteArray()));
1791          T clone = (T) ois.readObject();
1792          if (o == clone) assertImmutable(o);
1793 <        assertSame(o.getClass(), clone.getClass());
1793 >        else assertSame(o.getClass(), clone.getClass());
1794          return clone;
1795      }
1796  
# Line 1845 | Line 1815 | public class JSR166TestCase extends Test
1815      }
1816  
1817      public void assertThrows(Class<? extends Throwable> expectedExceptionClass,
1818 <                             Runnable... throwingActions) {
1819 <        for (Runnable throwingAction : throwingActions) {
1818 >                             Action... throwingActions) {
1819 >        for (Action throwingAction : throwingActions) {
1820              boolean threw = false;
1821              try { throwingAction.run(); }
1822              catch (Throwable t) {
# Line 2071 | Line 2041 | public class JSR166TestCase extends Test
2041          assertEquals(savedCompletedTaskCount, p.getCompletedTaskCount());
2042          assertEquals(savedQueueSize, p.getQueue().size());
2043      }
2044 +
2045 +    void assertCollectionsEquals(Collection<?> x, Collection<?> y) {
2046 +        assertEquals(x, y);
2047 +        assertEquals(y, x);
2048 +        assertEquals(x.isEmpty(), y.isEmpty());
2049 +        assertEquals(x.size(), y.size());
2050 +        if (x instanceof List) {
2051 +            assertEquals(x.toString(), y.toString());
2052 +        }
2053 +        if (x instanceof List || x instanceof Set) {
2054 +            assertEquals(x.hashCode(), y.hashCode());
2055 +        }
2056 +        if (x instanceof List || x instanceof Deque) {
2057 +            assertTrue(Arrays.equals(x.toArray(), y.toArray()));
2058 +            assertTrue(Arrays.equals(x.toArray(new Object[0]),
2059 +                                     y.toArray(new Object[0])));
2060 +        }
2061 +    }
2062 +
2063 +    /**
2064 +     * A weaker form of assertCollectionsEquals which does not insist
2065 +     * that the two collections satisfy Object#equals(Object), since
2066 +     * they may use identity semantics as Deques do.
2067 +     */
2068 +    void assertCollectionsEquivalent(Collection<?> x, Collection<?> y) {
2069 +        if (x instanceof List || x instanceof Set)
2070 +            assertCollectionsEquals(x, y);
2071 +        else {
2072 +            assertEquals(x.isEmpty(), y.isEmpty());
2073 +            assertEquals(x.size(), y.size());
2074 +            assertEquals(new HashSet(x), new HashSet(y));
2075 +            if (x instanceof Deque) {
2076 +                assertTrue(Arrays.equals(x.toArray(), y.toArray()));
2077 +                assertTrue(Arrays.equals(x.toArray(new Object[0]),
2078 +                                         y.toArray(new Object[0])));
2079 +            }
2080 +        }
2081 +    }
2082   }

Diff Legend

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