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.226 by jsr166, Sun May 14 00:37:42 2017 UTC vs.
Revision 1.248 by jsr166, Sat Nov 24 21:14:51 2018 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;
98   import java.util.concurrent.ThreadPoolExecutor;
99 + import java.util.concurrent.TimeUnit;
100   import java.util.concurrent.TimeoutException;
101   import java.util.concurrent.atomic.AtomicBoolean;
102   import java.util.concurrent.atomic.AtomicReference;
103   import java.util.regex.Pattern;
104  
96 import junit.framework.AssertionFailedError;
105   import junit.framework.Test;
106   import junit.framework.TestCase;
107   import junit.framework.TestResult;
# Line 109 | 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 413 | Line 429 | public class JSR166TestCase extends Test
429          for (String testClassName : testClassNames) {
430              try {
431                  Class<?> testClass = Class.forName(testClassName);
432 <                Method m = testClass.getDeclaredMethod("suite",
417 <                                                       new Class<?>[0]);
432 >                Method m = testClass.getDeclaredMethod("suite");
433                  suite.addTest(newTestSuite((Test)m.invoke(null)));
434 <            } catch (Exception e) {
435 <                throw new Error("Missing test class", e);
434 >            } catch (ReflectiveOperationException e) {
435 >                throw new AssertionError("Missing test class", e);
436              }
437          }
438      }
# Line 439 | Line 454 | public class JSR166TestCase extends Test
454          }
455      }
456  
457 <    public static boolean atLeastJava6() { return JAVA_CLASS_VERSION >= 50.0; }
458 <    public static boolean atLeastJava7() { return JAVA_CLASS_VERSION >= 51.0; }
459 <    public static boolean atLeastJava8() { return JAVA_CLASS_VERSION >= 52.0; }
460 <    public static boolean atLeastJava9() {
461 <        return JAVA_CLASS_VERSION >= 53.0
462 <            // As of 2015-09, java9 still uses 52.0 class file version
448 <            || JAVA_SPECIFICATION_VERSION.matches("^(1\\.)?(9|[0-9][0-9])$");
449 <    }
450 <    public static boolean atLeastJava10() {
451 <        return JAVA_CLASS_VERSION >= 54.0
452 <            || JAVA_SPECIFICATION_VERSION.matches("^(1\\.)?[0-9][0-9]$");
453 <    }
457 >    public static boolean atLeastJava6()  { return JAVA_CLASS_VERSION >= 50.0; }
458 >    public static boolean atLeastJava7()  { return JAVA_CLASS_VERSION >= 51.0; }
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  
464      /**
465       * Collects all JSR166 unit tests as one suite.
# Line 538 | Line 547 | public class JSR166TestCase extends Test
547                  "DoubleAdderTest",
548                  "ForkJoinPool8Test",
549                  "ForkJoinTask8Test",
550 +                "HashMapTest",
551                  "LinkedBlockingDeque8Test",
552                  "LinkedBlockingQueue8Test",
553                  "LongAccumulatorTest",
# Line 600 | Line 610 | public class JSR166TestCase extends Test
610              for (String methodName : testMethodNames(testClass))
611                  suite.addTest((Test) c.newInstance(data, methodName));
612              return suite;
613 <        } catch (Exception e) {
614 <            throw new Error(e);
613 >        } catch (ReflectiveOperationException e) {
614 >            throw new AssertionError(e);
615          }
616      }
617  
# Line 617 | Line 627 | public class JSR166TestCase extends Test
627          if (atLeastJava8()) {
628              String name = testClass.getName();
629              String name8 = name.replaceAll("Test$", "8Test");
630 <            if (name.equals(name8)) throw new Error(name);
630 >            if (name.equals(name8)) throw new AssertionError(name);
631              try {
632                  return (Test)
633                      Class.forName(name8)
634 <                    .getMethod("testSuite", new Class[] { dataClass })
634 >                    .getMethod("testSuite", dataClass)
635                      .invoke(null, data);
636 <            } catch (Exception e) {
637 <                throw new Error(e);
636 >            } catch (ReflectiveOperationException e) {
637 >                throw new AssertionError(e);
638              }
639          } else {
640              return new TestSuite();
# Line 638 | Line 648 | public class JSR166TestCase extends Test
648      public static long MEDIUM_DELAY_MS;
649      public static long LONG_DELAY_MS;
650  
651 +    private static final long RANDOM_TIMEOUT;
652 +    private static final long RANDOM_EXPIRED_TIMEOUT;
653 +    private static final TimeUnit RANDOM_TIMEUNIT;
654 +    static {
655 +        ThreadLocalRandom rnd = ThreadLocalRandom.current();
656 +        long[] timeouts = { Long.MIN_VALUE, -1, 0, 1, Long.MAX_VALUE };
657 +        RANDOM_TIMEOUT = timeouts[rnd.nextInt(timeouts.length)];
658 +        RANDOM_EXPIRED_TIMEOUT = timeouts[rnd.nextInt(3)];
659 +        TimeUnit[] timeUnits = TimeUnit.values();
660 +        RANDOM_TIMEUNIT = timeUnits[rnd.nextInt(timeUnits.length)];
661 +    }
662 +
663 +    /**
664 +     * Returns a timeout for use when any value at all will do.
665 +     */
666 +    static long randomTimeout() { return RANDOM_TIMEOUT; }
667 +
668 +    /**
669 +     * Returns a timeout that means "no waiting", i.e. not positive.
670 +     */
671 +    static long randomExpiredTimeout() { return RANDOM_EXPIRED_TIMEOUT; }
672 +
673 +    /**
674 +     * Returns a random non-null TimeUnit.
675 +     */
676 +    static TimeUnit randomTimeUnit() { return RANDOM_TIMEUNIT; }
677 +
678      /**
679       * Returns the shortest timed delay. This can be scaled up for
680       * slow machines using the jsr166.delay.factor system property,
# Line 706 | Line 743 | public class JSR166TestCase extends Test
743          String msg = toString() + ": " + String.format(format, args);
744          System.err.println(msg);
745          dumpTestThreads();
746 <        throw new AssertionFailedError(msg);
746 >        throw new AssertionError(msg);
747      }
748  
749      /**
# Line 727 | Line 764 | public class JSR166TestCase extends Test
764                  throw (RuntimeException) t;
765              else if (t instanceof Exception)
766                  throw (Exception) t;
767 <            else {
768 <                AssertionFailedError afe =
732 <                    new AssertionFailedError(t.toString());
733 <                afe.initCause(t);
734 <                throw afe;
735 <            }
767 >            else
768 >                throw new AssertionError(t.toString(), t);
769          }
770  
771          if (Thread.interrupted())
# Line 766 | Line 799 | public class JSR166TestCase extends Test
799  
800      /**
801       * Just like fail(reason), but additionally recording (using
802 <     * threadRecordFailure) any AssertionFailedError thrown, so that
803 <     * the current testcase will fail.
802 >     * threadRecordFailure) any AssertionError thrown, so that the
803 >     * current testcase will fail.
804       */
805      public void threadFail(String reason) {
806          try {
807              fail(reason);
808 <        } catch (AssertionFailedError t) {
809 <            threadRecordFailure(t);
810 <            throw t;
808 >        } catch (AssertionError fail) {
809 >            threadRecordFailure(fail);
810 >            throw fail;
811          }
812      }
813  
814      /**
815       * Just like assertTrue(b), but additionally recording (using
816 <     * threadRecordFailure) any AssertionFailedError thrown, so that
817 <     * the current testcase will fail.
816 >     * threadRecordFailure) any AssertionError thrown, so that the
817 >     * current testcase will fail.
818       */
819      public void threadAssertTrue(boolean b) {
820          try {
821              assertTrue(b);
822 <        } catch (AssertionFailedError t) {
823 <            threadRecordFailure(t);
824 <            throw t;
822 >        } catch (AssertionError fail) {
823 >            threadRecordFailure(fail);
824 >            throw fail;
825          }
826      }
827  
828      /**
829       * Just like assertFalse(b), but additionally recording (using
830 <     * threadRecordFailure) any AssertionFailedError thrown, so that
831 <     * the current testcase will fail.
830 >     * threadRecordFailure) any AssertionError thrown, so that the
831 >     * current testcase will fail.
832       */
833      public void threadAssertFalse(boolean b) {
834          try {
835              assertFalse(b);
836 <        } catch (AssertionFailedError t) {
837 <            threadRecordFailure(t);
838 <            throw t;
836 >        } catch (AssertionError fail) {
837 >            threadRecordFailure(fail);
838 >            throw fail;
839          }
840      }
841  
842      /**
843       * Just like assertNull(x), but additionally recording (using
844 <     * threadRecordFailure) any AssertionFailedError thrown, so that
845 <     * the current testcase will fail.
844 >     * threadRecordFailure) any AssertionError thrown, so that the
845 >     * current testcase will fail.
846       */
847      public void threadAssertNull(Object x) {
848          try {
849              assertNull(x);
850 <        } catch (AssertionFailedError t) {
851 <            threadRecordFailure(t);
852 <            throw t;
850 >        } catch (AssertionError fail) {
851 >            threadRecordFailure(fail);
852 >            throw fail;
853          }
854      }
855  
856      /**
857       * Just like assertEquals(x, y), but additionally recording (using
858 <     * threadRecordFailure) any AssertionFailedError thrown, so that
859 <     * the current testcase will fail.
858 >     * threadRecordFailure) any AssertionError thrown, so that the
859 >     * current testcase will fail.
860       */
861      public void threadAssertEquals(long x, long y) {
862          try {
863              assertEquals(x, y);
864 <        } catch (AssertionFailedError t) {
865 <            threadRecordFailure(t);
866 <            throw t;
864 >        } catch (AssertionError fail) {
865 >            threadRecordFailure(fail);
866 >            throw fail;
867          }
868      }
869  
870      /**
871       * Just like assertEquals(x, y), but additionally recording (using
872 <     * threadRecordFailure) any AssertionFailedError thrown, so that
873 <     * the current testcase will fail.
872 >     * threadRecordFailure) any AssertionError thrown, so that the
873 >     * current testcase will fail.
874       */
875      public void threadAssertEquals(Object x, Object y) {
876          try {
877              assertEquals(x, y);
878 <        } catch (AssertionFailedError fail) {
878 >        } catch (AssertionError fail) {
879              threadRecordFailure(fail);
880              throw fail;
881          } catch (Throwable fail) {
# Line 852 | Line 885 | public class JSR166TestCase extends Test
885  
886      /**
887       * Just like assertSame(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 threadAssertSame(Object x, Object y) {
892          try {
893              assertSame(x, y);
894 <        } catch (AssertionFailedError fail) {
894 >        } catch (AssertionError fail) {
895              threadRecordFailure(fail);
896              throw fail;
897          }
# Line 880 | Line 913 | public class JSR166TestCase extends Test
913  
914      /**
915       * Records the given exception using {@link #threadRecordFailure},
916 <     * then rethrows the exception, wrapping it in an
917 <     * AssertionFailedError if necessary.
916 >     * then rethrows the exception, wrapping it in an AssertionError
917 >     * if necessary.
918       */
919      public void threadUnexpectedException(Throwable t) {
920          threadRecordFailure(t);
# Line 890 | Line 923 | public class JSR166TestCase extends Test
923              throw (RuntimeException) t;
924          else if (t instanceof Error)
925              throw (Error) t;
926 <        else {
927 <            AssertionFailedError afe =
895 <                new AssertionFailedError("unexpected exception: " + t);
896 <            afe.initCause(t);
897 <            throw afe;
898 <        }
926 >        else
927 >            throw new AssertionError("unexpected exception: " + t, t);
928      }
929  
930      /**
# Line 1066 | Line 1095 | public class JSR166TestCase extends Test
1095       * Checks that thread eventually enters the expected blocked thread state.
1096       */
1097      void assertThreadBlocks(Thread thread, Thread.State expected) {
1098 <        // always sleep at least 1 ms, avoiding transitional states
1099 <        // with high probability
1098 >        // always sleep at least 1 ms, with high probability avoiding
1099 >        // transitory states
1100          for (long retries = LONG_DELAY_MS * 3 / 4; retries-->0; ) {
1101              try { delay(1); }
1102              catch (InterruptedException fail) {
1103 <                fail("Unexpected InterruptedException");
1103 >                throw new AssertionError("Unexpected InterruptedException", fail);
1104              }
1105              Thread.State s = thread.getState();
1106              if (s == expected)
# Line 1083 | Line 1112 | public class JSR166TestCase extends Test
1112      }
1113  
1114      /**
1086     * Checks that thread does not terminate within the default
1087     * millisecond delay of {@code timeoutMillis()}.
1088     */
1089    void assertThreadStaysAlive(Thread thread) {
1090        assertThreadStaysAlive(thread, timeoutMillis());
1091    }
1092
1093    /**
1094     * Checks that thread does not terminate within the given millisecond delay.
1095     */
1096    void assertThreadStaysAlive(Thread thread, long millis) {
1097        try {
1098            // No need to optimize the failing case via Thread.join.
1099            delay(millis);
1100            assertTrue(thread.isAlive());
1101        } catch (InterruptedException fail) {
1102            threadFail("Unexpected InterruptedException");
1103        }
1104    }
1105
1106    /**
1107     * Checks that the threads do not terminate within the default
1108     * millisecond delay of {@code timeoutMillis()}.
1109     */
1110    void assertThreadsStayAlive(Thread... threads) {
1111        assertThreadsStayAlive(timeoutMillis(), threads);
1112    }
1113
1114    /**
1115     * Checks that the threads do not terminate within the given millisecond delay.
1116     */
1117    void assertThreadsStayAlive(long millis, Thread... threads) {
1118        try {
1119            // No need to optimize the failing case via Thread.join.
1120            delay(millis);
1121            for (Thread thread : threads)
1122                assertTrue(thread.isAlive());
1123        } catch (InterruptedException fail) {
1124            threadFail("Unexpected InterruptedException");
1125        }
1126    }
1127
1128    /**
1115       * Checks that future.get times out, with the default timeout of
1116       * {@code timeoutMillis()}.
1117       */
# Line 1300 | Line 1286 | public class JSR166TestCase extends Test
1286  
1287      /**
1288       * Sleeps until the given time has elapsed.
1289 <     * Throws AssertionFailedError if interrupted.
1289 >     * Throws AssertionError if interrupted.
1290       */
1291      static void sleep(long millis) {
1292          try {
1293              delay(millis);
1294          } catch (InterruptedException fail) {
1295 <            AssertionFailedError afe =
1310 <                new AssertionFailedError("Unexpected InterruptedException");
1311 <            afe.initCause(fail);
1312 <            throw afe;
1295 >            throw new AssertionError("Unexpected InterruptedException", fail);
1296          }
1297      }
1298  
1299      /**
1300       * Spin-waits up to the specified number of milliseconds for the given
1301       * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1302 +     * @param waitingForGodot if non-null, an additional condition to satisfy
1303       */
1304 <    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
1305 <        long startTime = 0L;
1306 <        for (;;) {
1307 <            Thread.State s = thread.getState();
1308 <            if (s == Thread.State.BLOCKED ||
1309 <                s == Thread.State.WAITING ||
1310 <                s == Thread.State.TIMED_WAITING)
1311 <                return;
1312 <            else if (s == Thread.State.TERMINATED)
1304 >    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis,
1305 >                                       Callable<Boolean> waitingForGodot) {
1306 >        for (long startTime = 0L;;) {
1307 >            switch (thread.getState()) {
1308 >            case BLOCKED: case WAITING: case TIMED_WAITING:
1309 >                try {
1310 >                    if (waitingForGodot == null || waitingForGodot.call())
1311 >                        return;
1312 >                } catch (Throwable fail) { threadUnexpectedException(fail); }
1313 >                break;
1314 >            case TERMINATED:
1315                  fail("Unexpected thread termination");
1316 <            else if (startTime == 0L)
1316 >            }
1317 >
1318 >            if (startTime == 0L)
1319                  startTime = System.nanoTime();
1320              else if (millisElapsedSince(startTime) > timeoutMillis) {
1321 <                threadAssertTrue(thread.isAlive());
1322 <                fail("timed out waiting for thread to enter wait state");
1321 >                assertTrue(thread.isAlive());
1322 >                if (waitingForGodot == null
1323 >                    || thread.getState() == Thread.State.RUNNABLE)
1324 >                    fail("timed out waiting for thread to enter wait state");
1325 >                else
1326 >                    fail("timed out waiting for condition, thread state="
1327 >                         + thread.getState());
1328              }
1329              Thread.yield();
1330          }
# Line 1339 | Line 1332 | public class JSR166TestCase extends Test
1332  
1333      /**
1334       * Spin-waits up to the specified number of milliseconds for the given
1335 <     * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING,
1343 <     * and additionally satisfy the given condition.
1335 >     * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1336       */
1337 <    void waitForThreadToEnterWaitState(
1338 <        Thread thread, long timeoutMillis, Callable<Boolean> waitingForGodot) {
1347 <        long startTime = 0L;
1348 <        for (;;) {
1349 <            Thread.State s = thread.getState();
1350 <            if (s == Thread.State.BLOCKED ||
1351 <                s == Thread.State.WAITING ||
1352 <                s == Thread.State.TIMED_WAITING) {
1353 <                try {
1354 <                    if (waitingForGodot.call())
1355 <                        return;
1356 <                } catch (Throwable fail) { threadUnexpectedException(fail); }
1357 <            }
1358 <            else if (s == Thread.State.TERMINATED)
1359 <                fail("Unexpected thread termination");
1360 <            else if (startTime == 0L)
1361 <                startTime = System.nanoTime();
1362 <            else if (millisElapsedSince(startTime) > timeoutMillis) {
1363 <                threadAssertTrue(thread.isAlive());
1364 <                fail("timed out waiting for thread to enter wait state");
1365 <            }
1366 <            Thread.yield();
1367 <        }
1337 >    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
1338 >        waitForThreadToEnterWaitState(thread, timeoutMillis, null);
1339      }
1340  
1341      /**
# Line 1372 | Line 1343 | public class JSR166TestCase extends Test
1343       * enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1344       */
1345      void waitForThreadToEnterWaitState(Thread thread) {
1346 <        waitForThreadToEnterWaitState(thread, LONG_DELAY_MS);
1346 >        waitForThreadToEnterWaitState(thread, LONG_DELAY_MS, null);
1347      }
1348  
1349      /**
# Line 1380 | Line 1351 | public class JSR166TestCase extends Test
1351       * enter a wait state: BLOCKED, WAITING, or TIMED_WAITING,
1352       * and additionally satisfy the given condition.
1353       */
1354 <    void waitForThreadToEnterWaitState(
1355 <        Thread thread, Callable<Boolean> waitingForGodot) {
1354 >    void waitForThreadToEnterWaitState(Thread thread,
1355 >                                       Callable<Boolean> waitingForGodot) {
1356          waitForThreadToEnterWaitState(thread, LONG_DELAY_MS, waitingForGodot);
1357      }
1358  
# Line 1400 | Line 1371 | public class JSR166TestCase extends Test
1371   //             r.run();
1372   //         } catch (Throwable fail) { threadUnexpectedException(fail); }
1373   //         if (millisElapsedSince(startTime) > timeoutMillis/2)
1374 < //             throw new AssertionFailedError("did not return promptly");
1374 > //             throw new AssertionError("did not return promptly");
1375   //     }
1376  
1377   //     void assertTerminatesPromptly(Runnable r) {
# Line 1413 | Line 1384 | public class JSR166TestCase extends Test
1384       */
1385      <T> void checkTimedGet(Future<T> f, T expectedValue, long timeoutMillis) {
1386          long startTime = System.nanoTime();
1387 +        T actual = null;
1388          try {
1389 <            assertEquals(expectedValue, f.get(timeoutMillis, MILLISECONDS));
1389 >            actual = f.get(timeoutMillis, MILLISECONDS);
1390          } catch (Throwable fail) { threadUnexpectedException(fail); }
1391 +        assertEquals(expectedValue, actual);
1392          if (millisElapsedSince(startTime) > timeoutMillis/2)
1393 <            throw new AssertionFailedError("timed get did not return promptly");
1393 >            throw new AssertionError("timed get did not return promptly");
1394      }
1395  
1396      <T> void checkTimedGet(Future<T> f, T expectedValue) {
# Line 1475 | Line 1448 | public class JSR166TestCase extends Test
1448          }
1449      }
1450  
1478    public abstract class RunnableShouldThrow implements Runnable {
1479        protected abstract void realRun() throws Throwable;
1480
1481        final Class<?> exceptionClass;
1482
1483        <T extends Throwable> RunnableShouldThrow(Class<T> exceptionClass) {
1484            this.exceptionClass = exceptionClass;
1485        }
1486
1487        public final void run() {
1488            try {
1489                realRun();
1490                threadShouldThrow(exceptionClass.getSimpleName());
1491            } catch (Throwable t) {
1492                if (! exceptionClass.isInstance(t))
1493                    threadUnexpectedException(t);
1494            }
1495        }
1496    }
1497
1451      public abstract class ThreadShouldThrow extends Thread {
1452          protected abstract void realRun() throws Throwable;
1453  
# Line 1507 | Line 1460 | public class JSR166TestCase extends Test
1460          public final void run() {
1461              try {
1462                  realRun();
1510                threadShouldThrow(exceptionClass.getSimpleName());
1463              } catch (Throwable t) {
1464                  if (! exceptionClass.isInstance(t))
1465                      threadUnexpectedException(t);
1466 +                return;
1467              }
1468 +            threadShouldThrow(exceptionClass.getSimpleName());
1469          }
1470      }
1471  
# Line 1521 | Line 1475 | public class JSR166TestCase extends Test
1475          public final void run() {
1476              try {
1477                  realRun();
1524                threadShouldThrow("InterruptedException");
1478              } catch (InterruptedException success) {
1479                  threadAssertFalse(Thread.interrupted());
1480 +                return;
1481              } catch (Throwable fail) {
1482                  threadUnexpectedException(fail);
1483              }
1484 +            threadShouldThrow("InterruptedException");
1485          }
1486      }
1487  
# Line 1538 | Line 1493 | public class JSR166TestCase extends Test
1493                  return realCall();
1494              } catch (Throwable fail) {
1495                  threadUnexpectedException(fail);
1541                return null;
1542            }
1543        }
1544    }
1545
1546    public abstract class CheckedInterruptedCallable<T>
1547        implements Callable<T> {
1548        protected abstract T realCall() throws Throwable;
1549
1550        public final T call() {
1551            try {
1552                T result = realCall();
1553                threadShouldThrow("InterruptedException");
1554                return result;
1555            } catch (InterruptedException success) {
1556                threadAssertFalse(Thread.interrupted());
1557            } catch (Throwable fail) {
1558                threadUnexpectedException(fail);
1496              }
1497 <            return null;
1497 >            throw new AssertionError("unreached");
1498          }
1499      }
1500  
# Line 1614 | Line 1551 | public class JSR166TestCase extends Test
1551      }
1552  
1553      public void await(CountDownLatch latch, long timeoutMillis) {
1554 +        boolean timedOut = false;
1555          try {
1556 <            if (!latch.await(timeoutMillis, MILLISECONDS))
1619 <                fail("timed out waiting for CountDownLatch for "
1620 <                     + (timeoutMillis/1000) + " sec");
1556 >            timedOut = !latch.await(timeoutMillis, MILLISECONDS);
1557          } catch (Throwable fail) {
1558              threadUnexpectedException(fail);
1559          }
1560 +        if (timedOut)
1561 +            fail("timed out waiting for CountDownLatch for "
1562 +                 + (timeoutMillis/1000) + " sec");
1563      }
1564  
1565      public void await(CountDownLatch latch) {
# Line 1628 | Line 1567 | public class JSR166TestCase extends Test
1567      }
1568  
1569      public void await(Semaphore semaphore) {
1570 +        boolean timedOut = false;
1571          try {
1572 <            if (!semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS))
1633 <                fail("timed out waiting for Semaphore for "
1634 <                     + (LONG_DELAY_MS/1000) + " sec");
1572 >            timedOut = !semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS);
1573          } catch (Throwable fail) {
1574              threadUnexpectedException(fail);
1575          }
1576 +        if (timedOut)
1577 +            fail("timed out waiting for Semaphore for "
1578 +                 + (LONG_DELAY_MS/1000) + " sec");
1579      }
1580  
1581      public void await(CyclicBarrier barrier) {
# Line 1659 | Line 1600 | public class JSR166TestCase extends Test
1600   //         long startTime = System.nanoTime();
1601   //         while (!flag.get()) {
1602   //             if (millisElapsedSince(startTime) > timeoutMillis)
1603 < //                 throw new AssertionFailedError("timed out");
1603 > //                 throw new AssertionError("timed out");
1604   //             Thread.yield();
1605   //         }
1606   //     }
# Line 1668 | Line 1609 | public class JSR166TestCase extends Test
1609          public String call() { throw new NullPointerException(); }
1610      }
1611  
1671    public static class CallableOne implements Callable<Integer> {
1672        public Integer call() { return one; }
1673    }
1674
1675    public class ShortRunnable extends CheckedRunnable {
1676        protected void realRun() throws Throwable {
1677            delay(SHORT_DELAY_MS);
1678        }
1679    }
1680
1681    public class ShortInterruptedRunnable extends CheckedInterruptedRunnable {
1682        protected void realRun() throws InterruptedException {
1683            delay(SHORT_DELAY_MS);
1684        }
1685    }
1686
1687    public class SmallRunnable extends CheckedRunnable {
1688        protected void realRun() throws Throwable {
1689            delay(SMALL_DELAY_MS);
1690        }
1691    }
1692
1612      public class SmallPossiblyInterruptedRunnable extends CheckedRunnable {
1613          protected void realRun() {
1614              try {
# Line 1698 | Line 1617 | public class JSR166TestCase extends Test
1617          }
1618      }
1619  
1701    public class SmallCallable extends CheckedCallable {
1702        protected Object realCall() throws InterruptedException {
1703            delay(SMALL_DELAY_MS);
1704            return Boolean.TRUE;
1705        }
1706    }
1707
1708    public class MediumRunnable extends CheckedRunnable {
1709        protected void realRun() throws Throwable {
1710            delay(MEDIUM_DELAY_MS);
1711        }
1712    }
1713
1714    public class MediumInterruptedRunnable extends CheckedInterruptedRunnable {
1715        protected void realRun() throws InterruptedException {
1716            delay(MEDIUM_DELAY_MS);
1717        }
1718    }
1719
1620      public Runnable possiblyInterruptedRunnable(final long timeoutMillis) {
1621          return new CheckedRunnable() {
1622              protected void realRun() {
# Line 1726 | Line 1626 | public class JSR166TestCase extends Test
1626              }};
1627      }
1628  
1729    public class MediumPossiblyInterruptedRunnable extends CheckedRunnable {
1730        protected void realRun() {
1731            try {
1732                delay(MEDIUM_DELAY_MS);
1733            } catch (InterruptedException ok) {}
1734        }
1735    }
1736
1737    public class LongPossiblyInterruptedRunnable extends CheckedRunnable {
1738        protected void realRun() {
1739            try {
1740                delay(LONG_DELAY_MS);
1741            } catch (InterruptedException ok) {}
1742        }
1743    }
1744
1629      /**
1630       * For use as ThreadFactory in constructors
1631       */
# Line 1755 | Line 1639 | public class JSR166TestCase extends Test
1639          boolean isDone();
1640      }
1641  
1758    public static TrackedRunnable trackedRunnable(final long timeoutMillis) {
1759        return new TrackedRunnable() {
1760                private volatile boolean done = false;
1761                public boolean isDone() { return done; }
1762                public void run() {
1763                    try {
1764                        delay(timeoutMillis);
1765                        done = true;
1766                    } catch (InterruptedException ok) {}
1767                }
1768            };
1769    }
1770
1771    public static class TrackedShortRunnable implements Runnable {
1772        public volatile boolean done = false;
1773        public void run() {
1774            try {
1775                delay(SHORT_DELAY_MS);
1776                done = true;
1777            } catch (InterruptedException ok) {}
1778        }
1779    }
1780
1781    public static class TrackedSmallRunnable implements Runnable {
1782        public volatile boolean done = false;
1783        public void run() {
1784            try {
1785                delay(SMALL_DELAY_MS);
1786                done = true;
1787            } catch (InterruptedException ok) {}
1788        }
1789    }
1790
1791    public static class TrackedMediumRunnable implements Runnable {
1792        public volatile boolean done = false;
1793        public void run() {
1794            try {
1795                delay(MEDIUM_DELAY_MS);
1796                done = true;
1797            } catch (InterruptedException ok) {}
1798        }
1799    }
1800
1801    public static class TrackedLongRunnable implements Runnable {
1802        public volatile boolean done = false;
1803        public void run() {
1804            try {
1805                delay(LONG_DELAY_MS);
1806                done = true;
1807            } catch (InterruptedException ok) {}
1808        }
1809    }
1810
1642      public static class TrackedNoOpRunnable implements Runnable {
1643          public volatile boolean done = false;
1644          public void run() {
# Line 1815 | Line 1646 | public class JSR166TestCase extends Test
1646          }
1647      }
1648  
1818    public static class TrackedCallable implements Callable {
1819        public volatile boolean done = false;
1820        public Object call() {
1821            try {
1822                delay(SMALL_DELAY_MS);
1823                done = true;
1824            } catch (InterruptedException ok) {}
1825            return Boolean.TRUE;
1826        }
1827    }
1828
1649      /**
1650       * Analog of CheckedRunnable for RecursiveAction
1651       */
# Line 1852 | Line 1672 | public class JSR166TestCase extends Test
1672                  return realCompute();
1673              } catch (Throwable fail) {
1674                  threadUnexpectedException(fail);
1855                return null;
1675              }
1676 +            throw new AssertionError("unreached");
1677          }
1678      }
1679  
# Line 1867 | Line 1687 | public class JSR166TestCase extends Test
1687  
1688      /**
1689       * A CyclicBarrier that uses timed await and fails with
1690 <     * AssertionFailedErrors instead of throwing checked exceptions.
1690 >     * AssertionErrors instead of throwing checked exceptions.
1691       */
1692      public static class CheckedBarrier extends CyclicBarrier {
1693          public CheckedBarrier(int parties) { super(parties); }
# Line 1876 | Line 1696 | public class JSR166TestCase extends Test
1696              try {
1697                  return super.await(2 * LONG_DELAY_MS, MILLISECONDS);
1698              } catch (TimeoutException timedOut) {
1699 <                throw new AssertionFailedError("timed out");
1699 >                throw new AssertionError("timed out");
1700              } catch (Exception fail) {
1701 <                AssertionFailedError afe =
1882 <                    new AssertionFailedError("Unexpected exception: " + fail);
1883 <                afe.initCause(fail);
1884 <                throw afe;
1701 >                throw new AssertionError("Unexpected exception: " + fail, fail);
1702              }
1703          }
1704      }
# Line 1892 | Line 1709 | public class JSR166TestCase extends Test
1709              assertEquals(0, q.size());
1710              assertNull(q.peek());
1711              assertNull(q.poll());
1712 <            assertNull(q.poll(0, MILLISECONDS));
1712 >            assertNull(q.poll(randomExpiredTimeout(), randomTimeUnit()));
1713              assertEquals(q.toString(), "[]");
1714              assertTrue(Arrays.equals(q.toArray(), new Object[0]));
1715              assertFalse(q.iterator().hasNext());
# Line 1944 | Line 1761 | public class JSR166TestCase extends Test
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();
1951 <            if (o == clone) assertImmutable(o);
1952 <            assertSame(o.getClass(), clone.getClass());
1953 <            return clone;
1768 >            clone = (T) ois.readObject();
1769          } catch (Throwable fail) {
1770              threadUnexpectedException(fail);
1956            return null;
1771          }
1772 +        if (o == clone) assertImmutable(o);
1773 +        else assertSame(o.getClass(), clone.getClass());
1774 +        return clone;
1775      }
1776  
1777      /**
# Line 1973 | 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 2004 | Line 1821 | public class JSR166TestCase extends Test
1821              try { throwingAction.run(); }
1822              catch (Throwable t) {
1823                  threw = true;
1824 <                if (!expectedExceptionClass.isInstance(t)) {
1825 <                    AssertionFailedError afe =
1826 <                        new AssertionFailedError
1827 <                        ("Expected " + expectedExceptionClass.getName() +
1828 <                         ", got " + t.getClass().getName());
2012 <                    afe.initCause(t);
2013 <                    threadUnexpectedException(afe);
2014 <                }
1824 >                if (!expectedExceptionClass.isInstance(t))
1825 >                    throw new AssertionError(
1826 >                            "Expected " + expectedExceptionClass.getName() +
1827 >                            ", got " + t.getClass().getName(),
1828 >                            t);
1829              }
1830              if (!threw)
1831                  shouldThrow(expectedExceptionClass.getName());
# Line 2043 | Line 1857 | public class JSR166TestCase extends Test
1857      static <T> void shuffle(T[] array) {
1858          Collections.shuffle(Arrays.asList(array), ThreadLocalRandom.current());
1859      }
1860 +
1861 +    /**
1862 +     * Returns the same String as would be returned by {@link
1863 +     * Object#toString}, whether or not the given object's class
1864 +     * overrides toString().
1865 +     *
1866 +     * @see System#identityHashCode
1867 +     */
1868 +    static String identityString(Object x) {
1869 +        return x.getClass().getName()
1870 +            + "@" + Integer.toHexString(System.identityHashCode(x));
1871 +    }
1872 +
1873 +    // --- Shared assertions for Executor tests ---
1874 +
1875 +    /**
1876 +     * Returns maximum number of tasks that can be submitted to given
1877 +     * pool (with bounded queue) before saturation (when submission
1878 +     * throws RejectedExecutionException).
1879 +     */
1880 +    static final int saturatedSize(ThreadPoolExecutor pool) {
1881 +        BlockingQueue<Runnable> q = pool.getQueue();
1882 +        return pool.getMaximumPoolSize() + q.size() + q.remainingCapacity();
1883 +    }
1884 +
1885 +    @SuppressWarnings("FutureReturnValueIgnored")
1886 +    void assertNullTaskSubmissionThrowsNullPointerException(Executor e) {
1887 +        try {
1888 +            e.execute((Runnable) null);
1889 +            shouldThrow();
1890 +        } catch (NullPointerException success) {}
1891 +
1892 +        if (! (e instanceof ExecutorService)) return;
1893 +        ExecutorService es = (ExecutorService) e;
1894 +        try {
1895 +            es.submit((Runnable) null);
1896 +            shouldThrow();
1897 +        } catch (NullPointerException success) {}
1898 +        try {
1899 +            es.submit((Runnable) null, Boolean.TRUE);
1900 +            shouldThrow();
1901 +        } catch (NullPointerException success) {}
1902 +        try {
1903 +            es.submit((Callable) null);
1904 +            shouldThrow();
1905 +        } catch (NullPointerException success) {}
1906 +
1907 +        if (! (e instanceof ScheduledExecutorService)) return;
1908 +        ScheduledExecutorService ses = (ScheduledExecutorService) e;
1909 +        try {
1910 +            ses.schedule((Runnable) null,
1911 +                         randomTimeout(), randomTimeUnit());
1912 +            shouldThrow();
1913 +        } catch (NullPointerException success) {}
1914 +        try {
1915 +            ses.schedule((Callable) null,
1916 +                         randomTimeout(), randomTimeUnit());
1917 +            shouldThrow();
1918 +        } catch (NullPointerException success) {}
1919 +        try {
1920 +            ses.scheduleAtFixedRate((Runnable) null,
1921 +                                    randomTimeout(), LONG_DELAY_MS, MILLISECONDS);
1922 +            shouldThrow();
1923 +        } catch (NullPointerException success) {}
1924 +        try {
1925 +            ses.scheduleWithFixedDelay((Runnable) null,
1926 +                                       randomTimeout(), LONG_DELAY_MS, MILLISECONDS);
1927 +            shouldThrow();
1928 +        } catch (NullPointerException success) {}
1929 +    }
1930 +
1931 +    void setRejectedExecutionHandler(
1932 +        ThreadPoolExecutor p, RejectedExecutionHandler handler) {
1933 +        p.setRejectedExecutionHandler(handler);
1934 +        assertSame(handler, p.getRejectedExecutionHandler());
1935 +    }
1936 +
1937 +    void assertTaskSubmissionsAreRejected(ThreadPoolExecutor p) {
1938 +        final RejectedExecutionHandler savedHandler = p.getRejectedExecutionHandler();
1939 +        final long savedTaskCount = p.getTaskCount();
1940 +        final long savedCompletedTaskCount = p.getCompletedTaskCount();
1941 +        final int savedQueueSize = p.getQueue().size();
1942 +        final boolean stock = (p.getClass().getClassLoader() == null);
1943 +
1944 +        Runnable r = () -> {};
1945 +        Callable<Boolean> c = () -> Boolean.TRUE;
1946 +
1947 +        class Recorder implements RejectedExecutionHandler {
1948 +            public volatile Runnable r = null;
1949 +            public volatile ThreadPoolExecutor p = null;
1950 +            public void reset() { r = null; p = null; }
1951 +            public void rejectedExecution(Runnable r, ThreadPoolExecutor p) {
1952 +                assertNull(this.r);
1953 +                assertNull(this.p);
1954 +                this.r = r;
1955 +                this.p = p;
1956 +            }
1957 +        }
1958 +
1959 +        // check custom handler is invoked exactly once per task
1960 +        Recorder recorder = new Recorder();
1961 +        setRejectedExecutionHandler(p, recorder);
1962 +        for (int i = 2; i--> 0; ) {
1963 +            recorder.reset();
1964 +            p.execute(r);
1965 +            if (stock && p.getClass() == ThreadPoolExecutor.class)
1966 +                assertSame(r, recorder.r);
1967 +            assertSame(p, recorder.p);
1968 +
1969 +            recorder.reset();
1970 +            assertFalse(p.submit(r).isDone());
1971 +            if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
1972 +            assertSame(p, recorder.p);
1973 +
1974 +            recorder.reset();
1975 +            assertFalse(p.submit(r, Boolean.TRUE).isDone());
1976 +            if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
1977 +            assertSame(p, recorder.p);
1978 +
1979 +            recorder.reset();
1980 +            assertFalse(p.submit(c).isDone());
1981 +            if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
1982 +            assertSame(p, recorder.p);
1983 +
1984 +            if (p instanceof ScheduledExecutorService) {
1985 +                ScheduledExecutorService s = (ScheduledExecutorService) p;
1986 +                ScheduledFuture<?> future;
1987 +
1988 +                recorder.reset();
1989 +                future = s.schedule(r, randomTimeout(), randomTimeUnit());
1990 +                assertFalse(future.isDone());
1991 +                if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
1992 +                assertSame(p, recorder.p);
1993 +
1994 +                recorder.reset();
1995 +                future = s.schedule(c, randomTimeout(), randomTimeUnit());
1996 +                assertFalse(future.isDone());
1997 +                if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
1998 +                assertSame(p, recorder.p);
1999 +
2000 +                recorder.reset();
2001 +                future = s.scheduleAtFixedRate(r, randomTimeout(), LONG_DELAY_MS, MILLISECONDS);
2002 +                assertFalse(future.isDone());
2003 +                if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
2004 +                assertSame(p, recorder.p);
2005 +
2006 +                recorder.reset();
2007 +                future = s.scheduleWithFixedDelay(r, randomTimeout(), LONG_DELAY_MS, MILLISECONDS);
2008 +                assertFalse(future.isDone());
2009 +                if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
2010 +                assertSame(p, recorder.p);
2011 +            }
2012 +        }
2013 +
2014 +        // Checking our custom handler above should be sufficient, but
2015 +        // we add some integration tests of standard handlers.
2016 +        final AtomicReference<Thread> thread = new AtomicReference<>();
2017 +        final Runnable setThread = () -> thread.set(Thread.currentThread());
2018 +
2019 +        setRejectedExecutionHandler(p, new ThreadPoolExecutor.AbortPolicy());
2020 +        try {
2021 +            p.execute(setThread);
2022 +            shouldThrow();
2023 +        } catch (RejectedExecutionException success) {}
2024 +        assertNull(thread.get());
2025 +
2026 +        setRejectedExecutionHandler(p, new ThreadPoolExecutor.DiscardPolicy());
2027 +        p.execute(setThread);
2028 +        assertNull(thread.get());
2029 +
2030 +        setRejectedExecutionHandler(p, new ThreadPoolExecutor.CallerRunsPolicy());
2031 +        p.execute(setThread);
2032 +        if (p.isShutdown())
2033 +            assertNull(thread.get());
2034 +        else
2035 +            assertSame(Thread.currentThread(), thread.get());
2036 +
2037 +        setRejectedExecutionHandler(p, savedHandler);
2038 +
2039 +        // check that pool was not perturbed by handlers
2040 +        assertEquals(savedTaskCount, p.getTaskCount());
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