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.233 by jsr166, Sat Jul 15 23:15:21 2017 UTC vs.
Revision 1.263 by jsr166, Thu Sep 5 22:05:30 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;
80   import java.util.concurrent.CyclicBarrier;
81   import java.util.concurrent.ExecutionException;
82 + import java.util.concurrent.Executor;
83   import java.util.concurrent.Executors;
84   import java.util.concurrent.ExecutorService;
85   import java.util.concurrent.ForkJoinPool;
86   import java.util.concurrent.Future;
87 + import java.util.concurrent.FutureTask;
88   import java.util.concurrent.RecursiveAction;
89   import java.util.concurrent.RecursiveTask;
90 + import java.util.concurrent.RejectedExecutionException;
91   import java.util.concurrent.RejectedExecutionHandler;
92   import java.util.concurrent.Semaphore;
93 + import java.util.concurrent.ScheduledExecutorService;
94 + import java.util.concurrent.ScheduledFuture;
95   import java.util.concurrent.SynchronousQueue;
96   import java.util.concurrent.ThreadFactory;
97   import java.util.concurrent.ThreadLocalRandom;
# Line 94 | Line 102 | import java.util.concurrent.atomic.Atomi
102   import java.util.concurrent.atomic.AtomicReference;
103   import java.util.regex.Pattern;
104  
97 import junit.framework.AssertionFailedError;
105   import junit.framework.Test;
106   import junit.framework.TestCase;
107   import junit.framework.TestResult;
# Line 110 | 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 273 | 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 414 | Line 430 | public class JSR166TestCase extends Test
430          for (String testClassName : testClassNames) {
431              try {
432                  Class<?> testClass = Class.forName(testClassName);
433 <                Method m = testClass.getDeclaredMethod("suite",
418 <                                                       new Class<?>[0]);
433 >                Method m = testClass.getDeclaredMethod("suite");
434                  suite.addTest(newTestSuite((Test)m.invoke(null)));
435 <            } catch (Exception e) {
436 <                throw new Error("Missing test class", e);
435 >            } catch (ReflectiveOperationException e) {
436 >                throw new AssertionError("Missing test class", e);
437              }
438          }
439      }
# Line 440 | Line 455 | public class JSR166TestCase extends Test
455          }
456      }
457  
458 <    public static boolean atLeastJava6() { return JAVA_CLASS_VERSION >= 50.0; }
459 <    public static boolean atLeastJava7() { return JAVA_CLASS_VERSION >= 51.0; }
460 <    public static boolean atLeastJava8() { return JAVA_CLASS_VERSION >= 52.0; }
461 <    public static boolean atLeastJava9() {
462 <        return JAVA_CLASS_VERSION >= 53.0
463 <            // As of 2015-09, java9 still uses 52.0 class file version
464 <            || JAVA_SPECIFICATION_VERSION.matches("^(1\\.)?(9|[0-9][0-9])$");
465 <    }
466 <    public static boolean atLeastJava10() {
467 <        return JAVA_CLASS_VERSION >= 54.0
468 <            || JAVA_SPECIFICATION_VERSION.matches("^(1\\.)?[0-9][0-9]$");
469 <    }
458 >    public static boolean atLeastJava6()  { return JAVA_CLASS_VERSION >= 50.0; }
459 >    public static boolean atLeastJava7()  { return JAVA_CLASS_VERSION >= 51.0; }
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 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 539 | Line 555 | public class JSR166TestCase extends Test
555                  "DoubleAdderTest",
556                  "ForkJoinPool8Test",
557                  "ForkJoinTask8Test",
558 +                "HashMapTest",
559                  "LinkedBlockingDeque8Test",
560                  "LinkedBlockingQueue8Test",
561 +                "LinkedHashMapTest",
562                  "LongAccumulatorTest",
563                  "LongAdderTest",
564                  "SplittableRandomTest",
# Line 601 | Line 619 | public class JSR166TestCase extends Test
619              for (String methodName : testMethodNames(testClass))
620                  suite.addTest((Test) c.newInstance(data, methodName));
621              return suite;
622 <        } catch (Exception e) {
623 <            throw new Error(e);
622 >        } catch (ReflectiveOperationException e) {
623 >            throw new AssertionError(e);
624          }
625      }
626  
# Line 618 | Line 636 | public class JSR166TestCase extends Test
636          if (atLeastJava8()) {
637              String name = testClass.getName();
638              String name8 = name.replaceAll("Test$", "8Test");
639 <            if (name.equals(name8)) throw new Error(name);
639 >            if (name.equals(name8)) throw new AssertionError(name);
640              try {
641                  return (Test)
642                      Class.forName(name8)
643 <                    .getMethod("testSuite", new Class[] { dataClass })
643 >                    .getMethod("testSuite", dataClass)
644                      .invoke(null, data);
645 <            } catch (Exception e) {
646 <                throw new Error(e);
645 >            } catch (ReflectiveOperationException e) {
646 >                throw new AssertionError(e);
647              }
648          } else {
649              return new TestSuite();
# Line 639 | 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 667 | 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 684 | 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 722 | 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 734 | Line 773 | public class JSR166TestCase extends Test
773          String msg = toString() + ": " + String.format(format, args);
774          System.err.println(msg);
775          dumpTestThreads();
776 <        throw new AssertionFailedError(msg);
776 >        throw new AssertionError(msg);
777      }
778  
779      /**
# Line 755 | Line 794 | public class JSR166TestCase extends Test
794                  throw (RuntimeException) t;
795              else if (t instanceof Exception)
796                  throw (Exception) t;
797 <            else {
798 <                AssertionFailedError afe =
760 <                    new AssertionFailedError(t.toString());
761 <                afe.initCause(t);
762 <                throw afe;
763 <            }
797 >            else
798 >                throw new AssertionError(t.toString(), t);
799          }
800  
801          if (Thread.interrupted())
# Line 794 | Line 829 | public class JSR166TestCase extends Test
829  
830      /**
831       * Just like fail(reason), but additionally recording (using
832 <     * threadRecordFailure) any AssertionFailedError thrown, so that
833 <     * the current testcase will fail.
832 >     * threadRecordFailure) any AssertionError thrown, so that the
833 >     * current testcase will fail.
834       */
835      public void threadFail(String reason) {
836          try {
837              fail(reason);
838 <        } catch (AssertionFailedError t) {
839 <            threadRecordFailure(t);
840 <            throw t;
838 >        } catch (AssertionError fail) {
839 >            threadRecordFailure(fail);
840 >            throw fail;
841          }
842      }
843  
844      /**
845       * Just like assertTrue(b), but additionally recording (using
846 <     * threadRecordFailure) any AssertionFailedError thrown, so that
847 <     * the current testcase will fail.
846 >     * threadRecordFailure) any AssertionError thrown, so that the
847 >     * current testcase will fail.
848       */
849      public void threadAssertTrue(boolean b) {
850          try {
851              assertTrue(b);
852 <        } catch (AssertionFailedError t) {
853 <            threadRecordFailure(t);
854 <            throw t;
852 >        } catch (AssertionError fail) {
853 >            threadRecordFailure(fail);
854 >            throw fail;
855          }
856      }
857  
858      /**
859       * Just like assertFalse(b), but additionally recording (using
860 <     * threadRecordFailure) any AssertionFailedError thrown, so that
861 <     * the current testcase will fail.
860 >     * threadRecordFailure) any AssertionError thrown, so that the
861 >     * current testcase will fail.
862       */
863      public void threadAssertFalse(boolean b) {
864          try {
865              assertFalse(b);
866 <        } catch (AssertionFailedError t) {
867 <            threadRecordFailure(t);
868 <            throw t;
866 >        } catch (AssertionError fail) {
867 >            threadRecordFailure(fail);
868 >            throw fail;
869          }
870      }
871  
872      /**
873       * Just like assertNull(x), but additionally recording (using
874 <     * threadRecordFailure) any AssertionFailedError thrown, so that
875 <     * the current testcase will fail.
874 >     * threadRecordFailure) any AssertionError thrown, so that the
875 >     * current testcase will fail.
876       */
877      public void threadAssertNull(Object x) {
878          try {
879              assertNull(x);
880 <        } catch (AssertionFailedError t) {
881 <            threadRecordFailure(t);
882 <            throw t;
880 >        } catch (AssertionError fail) {
881 >            threadRecordFailure(fail);
882 >            throw fail;
883          }
884      }
885  
886      /**
887       * Just like assertEquals(x, y), but additionally recording (using
888 <     * threadRecordFailure) any AssertionFailedError thrown, so that
889 <     * the current testcase will fail.
888 >     * threadRecordFailure) any AssertionError thrown, so that the
889 >     * current testcase will fail.
890       */
891      public void threadAssertEquals(long x, long y) {
892          try {
893              assertEquals(x, y);
894 <        } catch (AssertionFailedError t) {
895 <            threadRecordFailure(t);
896 <            throw t;
894 >        } catch (AssertionError fail) {
895 >            threadRecordFailure(fail);
896 >            throw fail;
897          }
898      }
899  
900      /**
901       * Just like assertEquals(x, y), but additionally recording (using
902 <     * threadRecordFailure) any AssertionFailedError thrown, so that
903 <     * the current testcase will fail.
902 >     * threadRecordFailure) any AssertionError thrown, so that the
903 >     * current testcase will fail.
904       */
905      public void threadAssertEquals(Object x, Object y) {
906          try {
907              assertEquals(x, y);
908 <        } catch (AssertionFailedError fail) {
908 >        } catch (AssertionError fail) {
909              threadRecordFailure(fail);
910              throw fail;
911          } catch (Throwable fail) {
# Line 880 | Line 915 | public class JSR166TestCase extends Test
915  
916      /**
917       * Just like assertSame(x, y), but additionally recording (using
918 <     * threadRecordFailure) any AssertionFailedError thrown, so that
919 <     * the current testcase will fail.
918 >     * threadRecordFailure) any AssertionError thrown, so that the
919 >     * current testcase will fail.
920       */
921      public void threadAssertSame(Object x, Object y) {
922          try {
923              assertSame(x, y);
924 <        } catch (AssertionFailedError fail) {
924 >        } catch (AssertionError fail) {
925              threadRecordFailure(fail);
926              throw fail;
927          }
# Line 908 | Line 943 | public class JSR166TestCase extends Test
943  
944      /**
945       * Records the given exception using {@link #threadRecordFailure},
946 <     * then rethrows the exception, wrapping it in an
947 <     * AssertionFailedError if necessary.
946 >     * then rethrows the exception, wrapping it in an AssertionError
947 >     * if necessary.
948       */
949      public void threadUnexpectedException(Throwable t) {
950          threadRecordFailure(t);
# Line 918 | Line 953 | public class JSR166TestCase extends Test
953              throw (RuntimeException) t;
954          else if (t instanceof Error)
955              throw (Error) t;
956 <        else {
957 <            AssertionFailedError afe =
923 <                new AssertionFailedError("unexpected exception: " + t);
924 <            afe.initCause(t);
925 <            throw afe;
926 <        }
956 >        else
957 >            throw new AssertionError("unexpected exception: " + t, t);
958      }
959  
960      /**
# Line 1099 | Line 1130 | public class JSR166TestCase extends Test
1130          for (long retries = LONG_DELAY_MS * 3 / 4; retries-->0; ) {
1131              try { delay(1); }
1132              catch (InterruptedException fail) {
1133 <                fail("Unexpected InterruptedException");
1133 >                throw new AssertionError("Unexpected InterruptedException", fail);
1134              }
1135              Thread.State s = thread.getState();
1136              if (s == expected)
# Line 1111 | Line 1142 | public class JSR166TestCase extends Test
1142      }
1143  
1144      /**
1114     * Checks that thread does not terminate within the default
1115     * millisecond delay of {@code timeoutMillis()}.
1116     * TODO: REMOVEME
1117     */
1118    void assertThreadStaysAlive(Thread thread) {
1119        assertThreadStaysAlive(thread, timeoutMillis());
1120    }
1121
1122    /**
1123     * Checks that thread does not terminate within the given millisecond delay.
1124     * TODO: REMOVEME
1125     */
1126    void assertThreadStaysAlive(Thread thread, long millis) {
1127        try {
1128            // No need to optimize the failing case via Thread.join.
1129            delay(millis);
1130            assertTrue(thread.isAlive());
1131        } catch (InterruptedException fail) {
1132            threadFail("Unexpected InterruptedException");
1133        }
1134    }
1135
1136    /**
1137     * Checks that the threads do not terminate within the default
1138     * millisecond delay of {@code timeoutMillis()}.
1139     * TODO: REMOVEME
1140     */
1141    void assertThreadsStayAlive(Thread... threads) {
1142        assertThreadsStayAlive(timeoutMillis(), threads);
1143    }
1144
1145    /**
1146     * Checks that the threads do not terminate within the given millisecond delay.
1147     * TODO: REMOVEME
1148     */
1149    void assertThreadsStayAlive(long millis, Thread... threads) {
1150        try {
1151            // No need to optimize the failing case via Thread.join.
1152            delay(millis);
1153            for (Thread thread : threads)
1154                assertTrue(thread.isAlive());
1155        } catch (InterruptedException fail) {
1156            threadFail("Unexpected InterruptedException");
1157        }
1158    }
1159
1160    /**
1145       * Checks that future.get times out, with the default timeout of
1146       * {@code timeoutMillis()}.
1147       */
# Line 1332 | Line 1316 | public class JSR166TestCase extends Test
1316  
1317      /**
1318       * Sleeps until the given time has elapsed.
1319 <     * Throws AssertionFailedError if interrupted.
1319 >     * Throws AssertionError if interrupted.
1320       */
1321      static void sleep(long millis) {
1322          try {
1323              delay(millis);
1324          } catch (InterruptedException fail) {
1325 <            AssertionFailedError afe =
1342 <                new AssertionFailedError("Unexpected InterruptedException");
1343 <            afe.initCause(fail);
1344 <            throw afe;
1325 >            throw new AssertionError("Unexpected InterruptedException", fail);
1326          }
1327      }
1328  
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 1371 | 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,
1375 <     * 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) {
1379 <        long startTime = 0L;
1380 <        for (;;) {
1381 <            Thread.State s = thread.getState();
1382 <            if (s == Thread.State.BLOCKED ||
1383 <                s == Thread.State.WAITING ||
1384 <                s == Thread.State.TIMED_WAITING) {
1385 <                try {
1386 <                    if (waitingForGodot.call())
1387 <                        return;
1388 <                } catch (Throwable fail) { threadUnexpectedException(fail); }
1389 <            }
1390 <            else if (s == Thread.State.TERMINATED)
1391 <                fail("Unexpected thread termination");
1392 <            else if (startTime == 0L)
1393 <                startTime = System.nanoTime();
1394 <            else if (millisElapsedSince(startTime) > timeoutMillis) {
1395 <                threadAssertTrue(thread.isAlive());
1396 <                fail("timed out waiting for thread to enter wait state");
1397 <            }
1398 <            Thread.yield();
1399 <        }
1368 >    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
1369 >        waitForThreadToEnterWaitState(thread, timeoutMillis, null);
1370      }
1371  
1372      /**
# Line 1404 | 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 1412 | 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 1426 | Line 1410 | public class JSR166TestCase extends Test
1410          return NANOSECONDS.toMillis(System.nanoTime() - startNanoTime);
1411      }
1412  
1429 //     void assertTerminatesPromptly(long timeoutMillis, Runnable r) {
1430 //         long startTime = System.nanoTime();
1431 //         try {
1432 //             r.run();
1433 //         } catch (Throwable fail) { threadUnexpectedException(fail); }
1434 //         if (millisElapsedSince(startTime) > timeoutMillis/2)
1435 //             throw new AssertionFailedError("did not return promptly");
1436 //     }
1437
1438 //     void assertTerminatesPromptly(Runnable r) {
1439 //         assertTerminatesPromptly(LONG_DELAY_MS/2, r);
1440 //     }
1441
1413      /**
1414       * Checks that timed f.get() returns the expected value, and does not
1415       * wait for the timeout to elapse before returning.
1416       */
1417      <T> void checkTimedGet(Future<T> f, T expectedValue, long timeoutMillis) {
1418          long startTime = System.nanoTime();
1419 +        T actual = null;
1420          try {
1421 <            assertEquals(expectedValue, f.get(timeoutMillis, MILLISECONDS));
1421 >            actual = f.get(timeoutMillis, MILLISECONDS);
1422          } catch (Throwable fail) { threadUnexpectedException(fail); }
1423 +        assertEquals(expectedValue, actual);
1424          if (millisElapsedSince(startTime) > timeoutMillis/2)
1425 <            throw new AssertionFailedError("timed get did not return promptly");
1425 >            throw new AssertionError("timed get did not return promptly");
1426      }
1427  
1428      <T> void checkTimedGet(Future<T> f, T expectedValue) {
# Line 1471 | Line 1444 | public class JSR166TestCase extends Test
1444       * to terminate (using {@link Thread#join(long)}), else interrupts
1445       * the thread (in the hope that it may terminate later) and fails.
1446       */
1447 <    void awaitTermination(Thread t, long timeoutMillis) {
1447 >    void awaitTermination(Thread thread, long timeoutMillis) {
1448          try {
1449 <            t.join(timeoutMillis);
1449 >            thread.join(timeoutMillis);
1450          } catch (InterruptedException fail) {
1451              threadUnexpectedException(fail);
1452 <        } finally {
1453 <            if (t.getState() != Thread.State.TERMINATED) {
1454 <                t.interrupt();
1455 <                threadFail("timed out waiting for thread to terminate");
1452 >        }
1453 >        if (thread.getState() != Thread.State.TERMINATED) {
1454 >            String detail = String.format(
1455 >                    "timed out waiting for thread to terminate, thread=%s, state=%s" ,
1456 >                    thread, thread.getState());
1457 >            try {
1458 >                threadFail(detail);
1459 >            } finally {
1460 >                // Interrupt thread __after__ having reported its stack trace
1461 >                thread.interrupt();
1462              }
1463          }
1464      }
# Line 1507 | Line 1486 | public class JSR166TestCase extends Test
1486          }
1487      }
1488  
1510    public abstract class RunnableShouldThrow implements Runnable {
1511        protected abstract void realRun() throws Throwable;
1512
1513        final Class<?> exceptionClass;
1514
1515        <T extends Throwable> RunnableShouldThrow(Class<T> exceptionClass) {
1516            this.exceptionClass = exceptionClass;
1517        }
1518
1519        public final void run() {
1520            try {
1521                realRun();
1522                threadShouldThrow(exceptionClass.getSimpleName());
1523            } catch (Throwable t) {
1524                if (! exceptionClass.isInstance(t))
1525                    threadUnexpectedException(t);
1526            }
1527        }
1528    }
1529
1489      public abstract class ThreadShouldThrow extends Thread {
1490          protected abstract void realRun() throws Throwable;
1491  
# Line 1539 | Line 1498 | public class JSR166TestCase extends Test
1498          public final void run() {
1499              try {
1500                  realRun();
1542                threadShouldThrow(exceptionClass.getSimpleName());
1501              } catch (Throwable t) {
1502                  if (! exceptionClass.isInstance(t))
1503                      threadUnexpectedException(t);
1504 +                return;
1505              }
1506 +            threadShouldThrow(exceptionClass.getSimpleName());
1507          }
1508      }
1509  
# Line 1553 | Line 1513 | public class JSR166TestCase extends Test
1513          public final void run() {
1514              try {
1515                  realRun();
1556                threadShouldThrow("InterruptedException");
1516              } catch (InterruptedException success) {
1517                  threadAssertFalse(Thread.interrupted());
1518 +                return;
1519              } catch (Throwable fail) {
1520                  threadUnexpectedException(fail);
1521              }
1522 +            threadShouldThrow("InterruptedException");
1523          }
1524      }
1525  
# Line 1570 | Line 1531 | public class JSR166TestCase extends Test
1531                  return realCall();
1532              } catch (Throwable fail) {
1533                  threadUnexpectedException(fail);
1573                return null;
1534              }
1535 <        }
1576 <    }
1577 <
1578 <    public abstract class CheckedInterruptedCallable<T>
1579 <        implements Callable<T> {
1580 <        protected abstract T realCall() throws Throwable;
1581 <
1582 <        public final T call() {
1583 <            try {
1584 <                T result = realCall();
1585 <                threadShouldThrow("InterruptedException");
1586 <                return result;
1587 <            } catch (InterruptedException success) {
1588 <                threadAssertFalse(Thread.interrupted());
1589 <            } catch (Throwable fail) {
1590 <                threadUnexpectedException(fail);
1591 <            }
1592 <            return null;
1535 >            throw new AssertionError("unreached");
1536          }
1537      }
1538  
# Line 1646 | Line 1589 | public class JSR166TestCase extends Test
1589      }
1590  
1591      public void await(CountDownLatch latch, long timeoutMillis) {
1592 +        boolean timedOut = false;
1593          try {
1594 <            if (!latch.await(timeoutMillis, MILLISECONDS))
1651 <                fail("timed out waiting for CountDownLatch for "
1652 <                     + (timeoutMillis/1000) + " sec");
1594 >            timedOut = !latch.await(timeoutMillis, MILLISECONDS);
1595          } catch (Throwable fail) {
1596              threadUnexpectedException(fail);
1597          }
1598 +        if (timedOut)
1599 +            fail("timed out waiting for CountDownLatch for "
1600 +                 + (timeoutMillis/1000) + " sec");
1601      }
1602  
1603      public void await(CountDownLatch latch) {
# Line 1660 | Line 1605 | public class JSR166TestCase extends Test
1605      }
1606  
1607      public void await(Semaphore semaphore) {
1608 +        boolean timedOut = false;
1609          try {
1610 <            if (!semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS))
1665 <                fail("timed out waiting for Semaphore for "
1666 <                     + (LONG_DELAY_MS/1000) + " sec");
1610 >            timedOut = !semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS);
1611          } catch (Throwable fail) {
1612              threadUnexpectedException(fail);
1613          }
1614 +        if (timedOut)
1615 +            fail("timed out waiting for Semaphore for "
1616 +                 + (LONG_DELAY_MS/1000) + " sec");
1617      }
1618  
1619      public void await(CyclicBarrier barrier) {
# Line 1691 | Line 1638 | public class JSR166TestCase extends Test
1638   //         long startTime = System.nanoTime();
1639   //         while (!flag.get()) {
1640   //             if (millisElapsedSince(startTime) > timeoutMillis)
1641 < //                 throw new AssertionFailedError("timed out");
1641 > //                 throw new AssertionError("timed out");
1642   //             Thread.yield();
1643   //         }
1644   //     }
# Line 1700 | Line 1647 | public class JSR166TestCase extends Test
1647          public String call() { throw new NullPointerException(); }
1648      }
1649  
1703    public class SmallPossiblyInterruptedRunnable extends CheckedRunnable {
1704        protected void realRun() {
1705            try {
1706                delay(SMALL_DELAY_MS);
1707            } catch (InterruptedException ok) {}
1708        }
1709    }
1710
1650      public Runnable possiblyInterruptedRunnable(final long timeoutMillis) {
1651          return new CheckedRunnable() {
1652              protected void realRun() {
# Line 1763 | Line 1702 | public class JSR166TestCase extends Test
1702                  return realCompute();
1703              } catch (Throwable fail) {
1704                  threadUnexpectedException(fail);
1766                return null;
1705              }
1706 +            throw new AssertionError("unreached");
1707          }
1708      }
1709  
# Line 1778 | Line 1717 | public class JSR166TestCase extends Test
1717  
1718      /**
1719       * A CyclicBarrier that uses timed await and fails with
1720 <     * AssertionFailedErrors instead of throwing checked exceptions.
1720 >     * AssertionErrors instead of throwing checked exceptions.
1721       */
1722      public static class CheckedBarrier extends CyclicBarrier {
1723          public CheckedBarrier(int parties) { super(parties); }
# Line 1787 | Line 1726 | public class JSR166TestCase extends Test
1726              try {
1727                  return super.await(2 * LONG_DELAY_MS, MILLISECONDS);
1728              } catch (TimeoutException timedOut) {
1729 <                throw new AssertionFailedError("timed out");
1729 >                throw new AssertionError("timed out");
1730              } catch (Exception fail) {
1731 <                AssertionFailedError afe =
1793 <                    new AssertionFailedError("Unexpected exception: " + fail);
1794 <                afe.initCause(fail);
1795 <                throw afe;
1731 >                throw new AssertionError("Unexpected exception: " + fail, fail);
1732              }
1733          }
1734      }
# Line 1844 | Line 1780 | public class JSR166TestCase extends Test
1780          }
1781      }
1782  
1783 <    void assertImmutable(final Object o) {
1783 >    void assertImmutable(Object o) {
1784          if (o instanceof Collection) {
1785              assertThrows(
1786                  UnsupportedOperationException.class,
1787 <                new Runnable() { public void run() {
1852 <                        ((Collection) o).add(null);}});
1787 >                () -> ((Collection) o).add(null));
1788          }
1789      }
1790  
1791      @SuppressWarnings("unchecked")
1792      <T> T serialClone(T o) {
1793 +        T clone = null;
1794          try {
1795              ObjectInputStream ois = new ObjectInputStream
1796                  (new ByteArrayInputStream(serialBytes(o)));
1797 <            T clone = (T) ois.readObject();
1862 <            if (o == clone) assertImmutable(o);
1863 <            assertSame(o.getClass(), clone.getClass());
1864 <            return clone;
1797 >            clone = (T) ois.readObject();
1798          } catch (Throwable fail) {
1799              threadUnexpectedException(fail);
1867            return null;
1800          }
1801 +        if (o == clone) assertImmutable(o);
1802 +        else assertSame(o.getClass(), clone.getClass());
1803 +        return clone;
1804      }
1805  
1806      /**
# Line 1884 | Line 1819 | public class JSR166TestCase extends Test
1819              (new ByteArrayInputStream(bos.toByteArray()));
1820          T clone = (T) ois.readObject();
1821          if (o == clone) assertImmutable(o);
1822 <        assertSame(o.getClass(), clone.getClass());
1822 >        else assertSame(o.getClass(), clone.getClass());
1823          return clone;
1824      }
1825  
# Line 1909 | Line 1844 | public class JSR166TestCase extends Test
1844      }
1845  
1846      public void assertThrows(Class<? extends Throwable> expectedExceptionClass,
1847 <                             Runnable... throwingActions) {
1848 <        for (Runnable throwingAction : throwingActions) {
1847 >                             Action... throwingActions) {
1848 >        for (Action throwingAction : throwingActions) {
1849              boolean threw = false;
1850              try { throwingAction.run(); }
1851              catch (Throwable t) {
1852                  threw = true;
1853 <                if (!expectedExceptionClass.isInstance(t)) {
1854 <                    AssertionFailedError afe =
1855 <                        new AssertionFailedError
1856 <                        ("Expected " + expectedExceptionClass.getName() +
1857 <                         ", got " + t.getClass().getName());
1923 <                    afe.initCause(t);
1924 <                    threadUnexpectedException(afe);
1925 <                }
1853 >                if (!expectedExceptionClass.isInstance(t))
1854 >                    throw new AssertionError(
1855 >                            "Expected " + expectedExceptionClass.getName() +
1856 >                            ", got " + t.getClass().getName(),
1857 >                            t);
1858              }
1859              if (!threw)
1860                  shouldThrow(expectedExceptionClass.getName());
# Line 1951 | Line 1883 | public class JSR166TestCase extends Test
1883                                 1000L, MILLISECONDS,
1884                                 new SynchronousQueue<Runnable>());
1885  
1886 +    static <T> void shuffle(T[] array) {
1887 +        Collections.shuffle(Arrays.asList(array), ThreadLocalRandom.current());
1888 +    }
1889 +
1890 +    /**
1891 +     * Returns the same String as would be returned by {@link
1892 +     * Object#toString}, whether or not the given object's class
1893 +     * overrides toString().
1894 +     *
1895 +     * @see System#identityHashCode
1896 +     */
1897 +    static String identityString(Object x) {
1898 +        return x.getClass().getName()
1899 +            + "@" + Integer.toHexString(System.identityHashCode(x));
1900 +    }
1901 +
1902 +    // --- Shared assertions for Executor tests ---
1903 +
1904      /**
1905       * Returns maximum number of tasks that can be submitted to given
1906       * pool (with bounded queue) before saturation (when submission
# Line 1961 | Line 1911 | public class JSR166TestCase extends Test
1911          return pool.getMaximumPoolSize() + q.size() + q.remainingCapacity();
1912      }
1913  
1914 <    static <T> void shuffle(T[] array) {
1915 <        Collections.shuffle(Arrays.asList(array), ThreadLocalRandom.current());
1914 >    @SuppressWarnings("FutureReturnValueIgnored")
1915 >    void assertNullTaskSubmissionThrowsNullPointerException(Executor e) {
1916 >        try {
1917 >            e.execute((Runnable) null);
1918 >            shouldThrow();
1919 >        } catch (NullPointerException success) {}
1920 >
1921 >        if (! (e instanceof ExecutorService)) return;
1922 >        ExecutorService es = (ExecutorService) e;
1923 >        try {
1924 >            es.submit((Runnable) null);
1925 >            shouldThrow();
1926 >        } catch (NullPointerException success) {}
1927 >        try {
1928 >            es.submit((Runnable) null, Boolean.TRUE);
1929 >            shouldThrow();
1930 >        } catch (NullPointerException success) {}
1931 >        try {
1932 >            es.submit((Callable) null);
1933 >            shouldThrow();
1934 >        } catch (NullPointerException success) {}
1935 >
1936 >        if (! (e instanceof ScheduledExecutorService)) return;
1937 >        ScheduledExecutorService ses = (ScheduledExecutorService) e;
1938 >        try {
1939 >            ses.schedule((Runnable) null,
1940 >                         randomTimeout(), randomTimeUnit());
1941 >            shouldThrow();
1942 >        } catch (NullPointerException success) {}
1943 >        try {
1944 >            ses.schedule((Callable) null,
1945 >                         randomTimeout(), randomTimeUnit());
1946 >            shouldThrow();
1947 >        } catch (NullPointerException success) {}
1948 >        try {
1949 >            ses.scheduleAtFixedRate((Runnable) null,
1950 >                                    randomTimeout(), LONG_DELAY_MS, MILLISECONDS);
1951 >            shouldThrow();
1952 >        } catch (NullPointerException success) {}
1953 >        try {
1954 >            ses.scheduleWithFixedDelay((Runnable) null,
1955 >                                       randomTimeout(), LONG_DELAY_MS, MILLISECONDS);
1956 >            shouldThrow();
1957 >        } catch (NullPointerException success) {}
1958 >    }
1959 >
1960 >    void setRejectedExecutionHandler(
1961 >        ThreadPoolExecutor p, RejectedExecutionHandler handler) {
1962 >        p.setRejectedExecutionHandler(handler);
1963 >        assertSame(handler, p.getRejectedExecutionHandler());
1964 >    }
1965 >
1966 >    void assertTaskSubmissionsAreRejected(ThreadPoolExecutor p) {
1967 >        final RejectedExecutionHandler savedHandler = p.getRejectedExecutionHandler();
1968 >        final long savedTaskCount = p.getTaskCount();
1969 >        final long savedCompletedTaskCount = p.getCompletedTaskCount();
1970 >        final int savedQueueSize = p.getQueue().size();
1971 >        final boolean stock = (p.getClass().getClassLoader() == null);
1972 >
1973 >        Runnable r = () -> {};
1974 >        Callable<Boolean> c = () -> Boolean.TRUE;
1975 >
1976 >        class Recorder implements RejectedExecutionHandler {
1977 >            public volatile Runnable r = null;
1978 >            public volatile ThreadPoolExecutor p = null;
1979 >            public void reset() { r = null; p = null; }
1980 >            public void rejectedExecution(Runnable r, ThreadPoolExecutor p) {
1981 >                assertNull(this.r);
1982 >                assertNull(this.p);
1983 >                this.r = r;
1984 >                this.p = p;
1985 >            }
1986 >        }
1987 >
1988 >        // check custom handler is invoked exactly once per task
1989 >        Recorder recorder = new Recorder();
1990 >        setRejectedExecutionHandler(p, recorder);
1991 >        for (int i = 2; i--> 0; ) {
1992 >            recorder.reset();
1993 >            p.execute(r);
1994 >            if (stock && p.getClass() == ThreadPoolExecutor.class)
1995 >                assertSame(r, recorder.r);
1996 >            assertSame(p, recorder.p);
1997 >
1998 >            recorder.reset();
1999 >            assertFalse(p.submit(r).isDone());
2000 >            if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
2001 >            assertSame(p, recorder.p);
2002 >
2003 >            recorder.reset();
2004 >            assertFalse(p.submit(r, Boolean.TRUE).isDone());
2005 >            if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
2006 >            assertSame(p, recorder.p);
2007 >
2008 >            recorder.reset();
2009 >            assertFalse(p.submit(c).isDone());
2010 >            if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
2011 >            assertSame(p, recorder.p);
2012 >
2013 >            if (p instanceof ScheduledExecutorService) {
2014 >                ScheduledExecutorService s = (ScheduledExecutorService) p;
2015 >                ScheduledFuture<?> future;
2016 >
2017 >                recorder.reset();
2018 >                future = s.schedule(r, randomTimeout(), randomTimeUnit());
2019 >                assertFalse(future.isDone());
2020 >                if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
2021 >                assertSame(p, recorder.p);
2022 >
2023 >                recorder.reset();
2024 >                future = s.schedule(c, randomTimeout(), randomTimeUnit());
2025 >                assertFalse(future.isDone());
2026 >                if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
2027 >                assertSame(p, recorder.p);
2028 >
2029 >                recorder.reset();
2030 >                future = s.scheduleAtFixedRate(r, randomTimeout(), LONG_DELAY_MS, MILLISECONDS);
2031 >                assertFalse(future.isDone());
2032 >                if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
2033 >                assertSame(p, recorder.p);
2034 >
2035 >                recorder.reset();
2036 >                future = s.scheduleWithFixedDelay(r, randomTimeout(), LONG_DELAY_MS, MILLISECONDS);
2037 >                assertFalse(future.isDone());
2038 >                if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
2039 >                assertSame(p, recorder.p);
2040 >            }
2041 >        }
2042 >
2043 >        // Checking our custom handler above should be sufficient, but
2044 >        // we add some integration tests of standard handlers.
2045 >        final AtomicReference<Thread> thread = new AtomicReference<>();
2046 >        final Runnable setThread = () -> thread.set(Thread.currentThread());
2047 >
2048 >        setRejectedExecutionHandler(p, new ThreadPoolExecutor.AbortPolicy());
2049 >        try {
2050 >            p.execute(setThread);
2051 >            shouldThrow();
2052 >        } catch (RejectedExecutionException success) {}
2053 >        assertNull(thread.get());
2054 >
2055 >        setRejectedExecutionHandler(p, new ThreadPoolExecutor.DiscardPolicy());
2056 >        p.execute(setThread);
2057 >        assertNull(thread.get());
2058 >
2059 >        setRejectedExecutionHandler(p, new ThreadPoolExecutor.CallerRunsPolicy());
2060 >        p.execute(setThread);
2061 >        if (p.isShutdown())
2062 >            assertNull(thread.get());
2063 >        else
2064 >            assertSame(Thread.currentThread(), thread.get());
2065 >
2066 >        setRejectedExecutionHandler(p, savedHandler);
2067 >
2068 >        // check that pool was not perturbed by handlers
2069 >        assertEquals(savedTaskCount, p.getTaskCount());
2070 >        assertEquals(savedCompletedTaskCount, p.getCompletedTaskCount());
2071 >        assertEquals(savedQueueSize, p.getQueue().size());
2072 >    }
2073 >
2074 >    void assertCollectionsEquals(Collection<?> x, Collection<?> y) {
2075 >        assertEquals(x, y);
2076 >        assertEquals(y, x);
2077 >        assertEquals(x.isEmpty(), y.isEmpty());
2078 >        assertEquals(x.size(), y.size());
2079 >        if (x instanceof List) {
2080 >            assertEquals(x.toString(), y.toString());
2081 >        }
2082 >        if (x instanceof List || x instanceof Set) {
2083 >            assertEquals(x.hashCode(), y.hashCode());
2084 >        }
2085 >        if (x instanceof List || x instanceof Deque) {
2086 >            assertTrue(Arrays.equals(x.toArray(), y.toArray()));
2087 >            assertTrue(Arrays.equals(x.toArray(new Object[0]),
2088 >                                     y.toArray(new Object[0])));
2089 >        }
2090 >    }
2091 >
2092 >    /**
2093 >     * A weaker form of assertCollectionsEquals which does not insist
2094 >     * that the two collections satisfy Object#equals(Object), since
2095 >     * they may use identity semantics as Deques do.
2096 >     */
2097 >    void assertCollectionsEquivalent(Collection<?> x, Collection<?> y) {
2098 >        if (x instanceof List || x instanceof Set)
2099 >            assertCollectionsEquals(x, y);
2100 >        else {
2101 >            assertEquals(x.isEmpty(), y.isEmpty());
2102 >            assertEquals(x.size(), y.size());
2103 >            assertEquals(new HashSet(x), new HashSet(y));
2104 >            if (x instanceof Deque) {
2105 >                assertTrue(Arrays.equals(x.toArray(), y.toArray()));
2106 >                assertTrue(Arrays.equals(x.toArray(new Object[0]),
2107 >                                         y.toArray(new Object[0])));
2108 >            }
2109 >        }
2110      }
2111   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines