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.224 by jsr166, Sat May 13 21:43:50 2017 UTC vs.
Revision 1.255 by jsr166, Sun Jul 28 18:09:25 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;
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 272 | 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 413 | 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",
417 <                                                       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 439 | 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 502 | Line 518 | public class JSR166TestCase extends Test
518              ExecutorsTest.suite(),
519              ExecutorCompletionServiceTest.suite(),
520              FutureTaskTest.suite(),
521 +            HashtableTest.suite(),
522              LinkedBlockingDequeTest.suite(),
523              LinkedBlockingQueueTest.suite(),
524              LinkedListTest.suite(),
# Line 538 | 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 600 | 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 617 | 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 638 | Line 657 | public class JSR166TestCase extends Test
657      public static long MEDIUM_DELAY_MS;
658      public static long LONG_DELAY_MS;
659  
660 +    private static final long RANDOM_TIMEOUT;
661 +    private static final long RANDOM_EXPIRED_TIMEOUT;
662 +    private static final TimeUnit RANDOM_TIMEUNIT;
663 +    static {
664 +        ThreadLocalRandom rnd = ThreadLocalRandom.current();
665 +        long[] timeouts = { Long.MIN_VALUE, -1, 0, 1, Long.MAX_VALUE };
666 +        RANDOM_TIMEOUT = timeouts[rnd.nextInt(timeouts.length)];
667 +        RANDOM_EXPIRED_TIMEOUT = timeouts[rnd.nextInt(3)];
668 +        TimeUnit[] timeUnits = TimeUnit.values();
669 +        RANDOM_TIMEUNIT = timeUnits[rnd.nextInt(timeUnits.length)];
670 +    }
671 +
672 +    /**
673 +     * Returns a timeout for use when any value at all will do.
674 +     */
675 +    static long randomTimeout() { return RANDOM_TIMEOUT; }
676 +
677 +    /**
678 +     * Returns a timeout that means "no waiting", i.e. not positive.
679 +     */
680 +    static long randomExpiredTimeout() { return RANDOM_EXPIRED_TIMEOUT; }
681 +
682 +    /**
683 +     * Returns a random non-null TimeUnit.
684 +     */
685 +    static TimeUnit randomTimeUnit() { return RANDOM_TIMEUNIT; }
686 +
687      /**
688       * Returns the shortest timed delay. This can be scaled up for
689       * slow machines using the jsr166.delay.factor system property,
# Line 706 | Line 752 | public class JSR166TestCase extends Test
752          String msg = toString() + ": " + String.format(format, args);
753          System.err.println(msg);
754          dumpTestThreads();
755 <        throw new AssertionFailedError(msg);
755 >        throw new AssertionError(msg);
756      }
757  
758      /**
# Line 727 | Line 773 | public class JSR166TestCase extends Test
773                  throw (RuntimeException) t;
774              else if (t instanceof Exception)
775                  throw (Exception) t;
776 <            else {
777 <                AssertionFailedError afe =
732 <                    new AssertionFailedError(t.toString());
733 <                afe.initCause(t);
734 <                throw afe;
735 <            }
776 >            else
777 >                throw new AssertionError(t.toString(), t);
778          }
779  
780          if (Thread.interrupted())
# Line 766 | Line 808 | public class JSR166TestCase extends Test
808  
809      /**
810       * Just like fail(reason), but additionally recording (using
811 <     * threadRecordFailure) any AssertionFailedError thrown, so that
812 <     * the current testcase will fail.
811 >     * threadRecordFailure) any AssertionError thrown, so that the
812 >     * current testcase will fail.
813       */
814      public void threadFail(String reason) {
815          try {
816              fail(reason);
817 <        } catch (AssertionFailedError t) {
818 <            threadRecordFailure(t);
819 <            throw t;
817 >        } catch (AssertionError fail) {
818 >            threadRecordFailure(fail);
819 >            throw fail;
820          }
821      }
822  
823      /**
824       * Just like assertTrue(b), but additionally recording (using
825 <     * threadRecordFailure) any AssertionFailedError thrown, so that
826 <     * the current testcase will fail.
825 >     * threadRecordFailure) any AssertionError thrown, so that the
826 >     * current testcase will fail.
827       */
828      public void threadAssertTrue(boolean b) {
829          try {
830              assertTrue(b);
831 <        } catch (AssertionFailedError t) {
832 <            threadRecordFailure(t);
833 <            throw t;
831 >        } catch (AssertionError fail) {
832 >            threadRecordFailure(fail);
833 >            throw fail;
834          }
835      }
836  
837      /**
838       * Just like assertFalse(b), but additionally recording (using
839 <     * threadRecordFailure) any AssertionFailedError thrown, so that
840 <     * the current testcase will fail.
839 >     * threadRecordFailure) any AssertionError thrown, so that the
840 >     * current testcase will fail.
841       */
842      public void threadAssertFalse(boolean b) {
843          try {
844              assertFalse(b);
845 <        } catch (AssertionFailedError t) {
846 <            threadRecordFailure(t);
847 <            throw t;
845 >        } catch (AssertionError fail) {
846 >            threadRecordFailure(fail);
847 >            throw fail;
848          }
849      }
850  
851      /**
852       * Just like assertNull(x), but additionally recording (using
853 <     * threadRecordFailure) any AssertionFailedError thrown, so that
854 <     * the current testcase will fail.
853 >     * threadRecordFailure) any AssertionError thrown, so that the
854 >     * current testcase will fail.
855       */
856      public void threadAssertNull(Object x) {
857          try {
858              assertNull(x);
859 <        } catch (AssertionFailedError t) {
860 <            threadRecordFailure(t);
861 <            throw t;
859 >        } catch (AssertionError fail) {
860 >            threadRecordFailure(fail);
861 >            throw fail;
862          }
863      }
864  
865      /**
866       * Just like assertEquals(x, y), but additionally recording (using
867 <     * threadRecordFailure) any AssertionFailedError thrown, so that
868 <     * the current testcase will fail.
867 >     * threadRecordFailure) any AssertionError thrown, so that the
868 >     * current testcase will fail.
869       */
870      public void threadAssertEquals(long x, long y) {
871          try {
872              assertEquals(x, y);
873 <        } catch (AssertionFailedError t) {
874 <            threadRecordFailure(t);
875 <            throw t;
873 >        } catch (AssertionError fail) {
874 >            threadRecordFailure(fail);
875 >            throw fail;
876          }
877      }
878  
879      /**
880       * Just like assertEquals(x, y), but additionally recording (using
881 <     * threadRecordFailure) any AssertionFailedError thrown, so that
882 <     * the current testcase will fail.
881 >     * threadRecordFailure) any AssertionError thrown, so that the
882 >     * current testcase will fail.
883       */
884      public void threadAssertEquals(Object x, Object y) {
885          try {
886              assertEquals(x, y);
887 <        } catch (AssertionFailedError fail) {
887 >        } catch (AssertionError fail) {
888              threadRecordFailure(fail);
889              throw fail;
890          } catch (Throwable fail) {
# Line 852 | Line 894 | public class JSR166TestCase extends Test
894  
895      /**
896       * Just like assertSame(x, y), but additionally recording (using
897 <     * threadRecordFailure) any AssertionFailedError thrown, so that
898 <     * the current testcase will fail.
897 >     * threadRecordFailure) any AssertionError thrown, so that the
898 >     * current testcase will fail.
899       */
900      public void threadAssertSame(Object x, Object y) {
901          try {
902              assertSame(x, y);
903 <        } catch (AssertionFailedError fail) {
903 >        } catch (AssertionError fail) {
904              threadRecordFailure(fail);
905              throw fail;
906          }
# Line 880 | Line 922 | public class JSR166TestCase extends Test
922  
923      /**
924       * Records the given exception using {@link #threadRecordFailure},
925 <     * then rethrows the exception, wrapping it in an
926 <     * AssertionFailedError if necessary.
925 >     * then rethrows the exception, wrapping it in an AssertionError
926 >     * if necessary.
927       */
928      public void threadUnexpectedException(Throwable t) {
929          threadRecordFailure(t);
# Line 890 | Line 932 | public class JSR166TestCase extends Test
932              throw (RuntimeException) t;
933          else if (t instanceof Error)
934              throw (Error) t;
935 <        else {
936 <            AssertionFailedError afe =
895 <                new AssertionFailedError("unexpected exception: " + t);
896 <            afe.initCause(t);
897 <            throw afe;
898 <        }
935 >        else
936 >            throw new AssertionError("unexpected exception: " + t, t);
937      }
938  
939      /**
# Line 1066 | Line 1104 | public class JSR166TestCase extends Test
1104       * Checks that thread eventually enters the expected blocked thread state.
1105       */
1106      void assertThreadBlocks(Thread thread, Thread.State expected) {
1107 <        // always sleep at least 1 ms, avoiding transitional states
1108 <        // with high probability
1109 <        for (long retries = LONG_DELAY_MS; retries-->0; ) {
1107 >        // always sleep at least 1 ms, with high probability avoiding
1108 >        // transitory states
1109 >        for (long retries = LONG_DELAY_MS * 3 / 4; retries-->0; ) {
1110              try { delay(1); }
1111              catch (InterruptedException fail) {
1112 <                fail("Unexpected InterruptedException");
1112 >                throw new AssertionError("Unexpected InterruptedException", fail);
1113              }
1114              Thread.State s = thread.getState();
1115              if (s == expected)
# Line 1083 | Line 1121 | public class JSR166TestCase extends Test
1121      }
1122  
1123      /**
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    /**
1124       * Checks that future.get times out, with the default timeout of
1125       * {@code timeoutMillis()}.
1126       */
# Line 1300 | Line 1295 | public class JSR166TestCase extends Test
1295  
1296      /**
1297       * Sleeps until the given time has elapsed.
1298 <     * Throws AssertionFailedError if interrupted.
1298 >     * Throws AssertionError if interrupted.
1299       */
1300      static void sleep(long millis) {
1301          try {
1302              delay(millis);
1303          } catch (InterruptedException fail) {
1304 <            AssertionFailedError afe =
1310 <                new AssertionFailedError("Unexpected InterruptedException");
1311 <            afe.initCause(fail);
1312 <            throw afe;
1304 >            throw new AssertionError("Unexpected InterruptedException", fail);
1305          }
1306      }
1307  
1308      /**
1309       * Spin-waits up to the specified number of milliseconds for the given
1310       * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1311 +     * @param waitingForGodot if non-null, an additional condition to satisfy
1312       */
1313 <    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
1314 <        long startTime = 0L;
1315 <        for (;;) {
1316 <            Thread.State s = thread.getState();
1317 <            if (s == Thread.State.BLOCKED ||
1318 <                s == Thread.State.WAITING ||
1319 <                s == Thread.State.TIMED_WAITING)
1320 <                return;
1321 <            else if (s == Thread.State.TERMINATED)
1313 >    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis,
1314 >                                       Callable<Boolean> waitingForGodot) {
1315 >        for (long startTime = 0L;;) {
1316 >            switch (thread.getState()) {
1317 >            default: break;
1318 >            case BLOCKED: case WAITING: case TIMED_WAITING:
1319 >                try {
1320 >                    if (waitingForGodot == null || waitingForGodot.call())
1321 >                        return;
1322 >                } catch (Throwable fail) { threadUnexpectedException(fail); }
1323 >                break;
1324 >            case TERMINATED:
1325                  fail("Unexpected thread termination");
1326 <            else if (startTime == 0L)
1326 >            }
1327 >
1328 >            if (startTime == 0L)
1329                  startTime = System.nanoTime();
1330              else if (millisElapsedSince(startTime) > timeoutMillis) {
1331 <                threadAssertTrue(thread.isAlive());
1332 <                fail("timed out waiting for thread to enter wait state");
1331 >                assertTrue(thread.isAlive());
1332 >                if (waitingForGodot == null
1333 >                    || thread.getState() == Thread.State.RUNNABLE)
1334 >                    fail("timed out waiting for thread to enter wait state");
1335 >                else
1336 >                    fail("timed out waiting for condition, thread state="
1337 >                         + thread.getState());
1338              }
1339              Thread.yield();
1340          }
# Line 1339 | Line 1342 | public class JSR166TestCase extends Test
1342  
1343      /**
1344       * Spin-waits up to the specified number of milliseconds for the given
1345 <     * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING,
1343 <     * and additionally satisfy the given condition.
1345 >     * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1346       */
1347 <    void waitForThreadToEnterWaitState(
1348 <        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 <        }
1347 >    void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
1348 >        waitForThreadToEnterWaitState(thread, timeoutMillis, null);
1349      }
1350  
1351      /**
# Line 1372 | Line 1353 | public class JSR166TestCase extends Test
1353       * enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1354       */
1355      void waitForThreadToEnterWaitState(Thread thread) {
1356 <        waitForThreadToEnterWaitState(thread, LONG_DELAY_MS);
1356 >        waitForThreadToEnterWaitState(thread, LONG_DELAY_MS, null);
1357      }
1358  
1359      /**
# Line 1380 | Line 1361 | public class JSR166TestCase extends Test
1361       * enter a wait state: BLOCKED, WAITING, or TIMED_WAITING,
1362       * and additionally satisfy the given condition.
1363       */
1364 <    void waitForThreadToEnterWaitState(
1365 <        Thread thread, Callable<Boolean> waitingForGodot) {
1364 >    void waitForThreadToEnterWaitState(Thread thread,
1365 >                                       Callable<Boolean> waitingForGodot) {
1366          waitForThreadToEnterWaitState(thread, LONG_DELAY_MS, waitingForGodot);
1367      }
1368  
# Line 1400 | Line 1381 | public class JSR166TestCase extends Test
1381   //             r.run();
1382   //         } catch (Throwable fail) { threadUnexpectedException(fail); }
1383   //         if (millisElapsedSince(startTime) > timeoutMillis/2)
1384 < //             throw new AssertionFailedError("did not return promptly");
1384 > //             throw new AssertionError("did not return promptly");
1385   //     }
1386  
1387   //     void assertTerminatesPromptly(Runnable r) {
# Line 1413 | Line 1394 | public class JSR166TestCase extends Test
1394       */
1395      <T> void checkTimedGet(Future<T> f, T expectedValue, long timeoutMillis) {
1396          long startTime = System.nanoTime();
1397 +        T actual = null;
1398          try {
1399 <            assertEquals(expectedValue, f.get(timeoutMillis, MILLISECONDS));
1399 >            actual = f.get(timeoutMillis, MILLISECONDS);
1400          } catch (Throwable fail) { threadUnexpectedException(fail); }
1401 +        assertEquals(expectedValue, actual);
1402          if (millisElapsedSince(startTime) > timeoutMillis/2)
1403 <            throw new AssertionFailedError("timed get did not return promptly");
1403 >            throw new AssertionError("timed get did not return promptly");
1404      }
1405  
1406      <T> void checkTimedGet(Future<T> f, T expectedValue) {
# Line 1475 | Line 1458 | public class JSR166TestCase extends Test
1458          }
1459      }
1460  
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
1461      public abstract class ThreadShouldThrow extends Thread {
1462          protected abstract void realRun() throws Throwable;
1463  
# Line 1507 | Line 1470 | public class JSR166TestCase extends Test
1470          public final void run() {
1471              try {
1472                  realRun();
1510                threadShouldThrow(exceptionClass.getSimpleName());
1473              } catch (Throwable t) {
1474                  if (! exceptionClass.isInstance(t))
1475                      threadUnexpectedException(t);
1476 +                return;
1477              }
1478 +            threadShouldThrow(exceptionClass.getSimpleName());
1479          }
1480      }
1481  
# Line 1521 | Line 1485 | public class JSR166TestCase extends Test
1485          public final void run() {
1486              try {
1487                  realRun();
1524                threadShouldThrow("InterruptedException");
1488              } catch (InterruptedException success) {
1489                  threadAssertFalse(Thread.interrupted());
1490 +                return;
1491              } catch (Throwable fail) {
1492                  threadUnexpectedException(fail);
1493              }
1494 +            threadShouldThrow("InterruptedException");
1495          }
1496      }
1497  
# Line 1538 | Line 1503 | public class JSR166TestCase extends Test
1503                  return realCall();
1504              } catch (Throwable fail) {
1505                  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);
1506              }
1507 <            return null;
1507 >            throw new AssertionError("unreached");
1508          }
1509      }
1510  
# Line 1614 | Line 1561 | public class JSR166TestCase extends Test
1561      }
1562  
1563      public void await(CountDownLatch latch, long timeoutMillis) {
1564 +        boolean timedOut = false;
1565          try {
1566 <            if (!latch.await(timeoutMillis, MILLISECONDS))
1619 <                fail("timed out waiting for CountDownLatch for "
1620 <                     + (timeoutMillis/1000) + " sec");
1566 >            timedOut = !latch.await(timeoutMillis, MILLISECONDS);
1567          } catch (Throwable fail) {
1568              threadUnexpectedException(fail);
1569          }
1570 +        if (timedOut)
1571 +            fail("timed out waiting for CountDownLatch for "
1572 +                 + (timeoutMillis/1000) + " sec");
1573      }
1574  
1575      public void await(CountDownLatch latch) {
# Line 1628 | Line 1577 | public class JSR166TestCase extends Test
1577      }
1578  
1579      public void await(Semaphore semaphore) {
1580 +        boolean timedOut = false;
1581          try {
1582 <            if (!semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS))
1583 <                fail("timed out waiting for Semaphore for "
1584 <                     + (LONG_DELAY_MS/1000) + " sec");
1582 >            timedOut = !semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS);
1583 >        } catch (Throwable fail) {
1584 >            threadUnexpectedException(fail);
1585 >        }
1586 >        if (timedOut)
1587 >            fail("timed out waiting for Semaphore for "
1588 >                 + (LONG_DELAY_MS/1000) + " sec");
1589 >    }
1590 >
1591 >    public void await(CyclicBarrier barrier) {
1592 >        try {
1593 >            barrier.await(LONG_DELAY_MS, MILLISECONDS);
1594          } catch (Throwable fail) {
1595              threadUnexpectedException(fail);
1596          }
# Line 1651 | Line 1610 | public class JSR166TestCase extends Test
1610   //         long startTime = System.nanoTime();
1611   //         while (!flag.get()) {
1612   //             if (millisElapsedSince(startTime) > timeoutMillis)
1613 < //                 throw new AssertionFailedError("timed out");
1613 > //                 throw new AssertionError("timed out");
1614   //             Thread.yield();
1615   //         }
1616   //     }
# Line 1660 | Line 1619 | public class JSR166TestCase extends Test
1619          public String call() { throw new NullPointerException(); }
1620      }
1621  
1663    public static class CallableOne implements Callable<Integer> {
1664        public Integer call() { return one; }
1665    }
1666
1667    public class ShortRunnable extends CheckedRunnable {
1668        protected void realRun() throws Throwable {
1669            delay(SHORT_DELAY_MS);
1670        }
1671    }
1672
1673    public class ShortInterruptedRunnable extends CheckedInterruptedRunnable {
1674        protected void realRun() throws InterruptedException {
1675            delay(SHORT_DELAY_MS);
1676        }
1677    }
1678
1679    public class SmallRunnable extends CheckedRunnable {
1680        protected void realRun() throws Throwable {
1681            delay(SMALL_DELAY_MS);
1682        }
1683    }
1684
1685    public class SmallPossiblyInterruptedRunnable extends CheckedRunnable {
1686        protected void realRun() {
1687            try {
1688                delay(SMALL_DELAY_MS);
1689            } catch (InterruptedException ok) {}
1690        }
1691    }
1692
1693    public class SmallCallable extends CheckedCallable {
1694        protected Object realCall() throws InterruptedException {
1695            delay(SMALL_DELAY_MS);
1696            return Boolean.TRUE;
1697        }
1698    }
1699
1700    public class MediumRunnable extends CheckedRunnable {
1701        protected void realRun() throws Throwable {
1702            delay(MEDIUM_DELAY_MS);
1703        }
1704    }
1705
1706    public class MediumInterruptedRunnable extends CheckedInterruptedRunnable {
1707        protected void realRun() throws InterruptedException {
1708            delay(MEDIUM_DELAY_MS);
1709        }
1710    }
1711
1622      public Runnable possiblyInterruptedRunnable(final long timeoutMillis) {
1623          return new CheckedRunnable() {
1624              protected void realRun() {
# Line 1718 | Line 1628 | public class JSR166TestCase extends Test
1628              }};
1629      }
1630  
1721    public class MediumPossiblyInterruptedRunnable extends CheckedRunnable {
1722        protected void realRun() {
1723            try {
1724                delay(MEDIUM_DELAY_MS);
1725            } catch (InterruptedException ok) {}
1726        }
1727    }
1728
1729    public class LongPossiblyInterruptedRunnable extends CheckedRunnable {
1730        protected void realRun() {
1731            try {
1732                delay(LONG_DELAY_MS);
1733            } catch (InterruptedException ok) {}
1734        }
1735    }
1736
1631      /**
1632       * For use as ThreadFactory in constructors
1633       */
# Line 1747 | Line 1641 | public class JSR166TestCase extends Test
1641          boolean isDone();
1642      }
1643  
1750    public static TrackedRunnable trackedRunnable(final long timeoutMillis) {
1751        return new TrackedRunnable() {
1752                private volatile boolean done = false;
1753                public boolean isDone() { return done; }
1754                public void run() {
1755                    try {
1756                        delay(timeoutMillis);
1757                        done = true;
1758                    } catch (InterruptedException ok) {}
1759                }
1760            };
1761    }
1762
1763    public static class TrackedShortRunnable implements Runnable {
1764        public volatile boolean done = false;
1765        public void run() {
1766            try {
1767                delay(SHORT_DELAY_MS);
1768                done = true;
1769            } catch (InterruptedException ok) {}
1770        }
1771    }
1772
1773    public static class TrackedSmallRunnable implements Runnable {
1774        public volatile boolean done = false;
1775        public void run() {
1776            try {
1777                delay(SMALL_DELAY_MS);
1778                done = true;
1779            } catch (InterruptedException ok) {}
1780        }
1781    }
1782
1783    public static class TrackedMediumRunnable implements Runnable {
1784        public volatile boolean done = false;
1785        public void run() {
1786            try {
1787                delay(MEDIUM_DELAY_MS);
1788                done = true;
1789            } catch (InterruptedException ok) {}
1790        }
1791    }
1792
1793    public static class TrackedLongRunnable implements Runnable {
1794        public volatile boolean done = false;
1795        public void run() {
1796            try {
1797                delay(LONG_DELAY_MS);
1798                done = true;
1799            } catch (InterruptedException ok) {}
1800        }
1801    }
1802
1644      public static class TrackedNoOpRunnable implements Runnable {
1645          public volatile boolean done = false;
1646          public void run() {
# Line 1807 | Line 1648 | public class JSR166TestCase extends Test
1648          }
1649      }
1650  
1810    public static class TrackedCallable implements Callable {
1811        public volatile boolean done = false;
1812        public Object call() {
1813            try {
1814                delay(SMALL_DELAY_MS);
1815                done = true;
1816            } catch (InterruptedException ok) {}
1817            return Boolean.TRUE;
1818        }
1819    }
1820
1651      /**
1652       * Analog of CheckedRunnable for RecursiveAction
1653       */
# Line 1844 | Line 1674 | public class JSR166TestCase extends Test
1674                  return realCompute();
1675              } catch (Throwable fail) {
1676                  threadUnexpectedException(fail);
1847                return null;
1677              }
1678 +            throw new AssertionError("unreached");
1679          }
1680      }
1681  
# Line 1859 | Line 1689 | public class JSR166TestCase extends Test
1689  
1690      /**
1691       * A CyclicBarrier that uses timed await and fails with
1692 <     * AssertionFailedErrors instead of throwing checked exceptions.
1692 >     * AssertionErrors instead of throwing checked exceptions.
1693       */
1694      public static class CheckedBarrier extends CyclicBarrier {
1695          public CheckedBarrier(int parties) { super(parties); }
# Line 1868 | Line 1698 | public class JSR166TestCase extends Test
1698              try {
1699                  return super.await(2 * LONG_DELAY_MS, MILLISECONDS);
1700              } catch (TimeoutException timedOut) {
1701 <                throw new AssertionFailedError("timed out");
1701 >                throw new AssertionError("timed out");
1702              } catch (Exception fail) {
1703 <                AssertionFailedError afe =
1874 <                    new AssertionFailedError("Unexpected exception: " + fail);
1875 <                afe.initCause(fail);
1876 <                throw afe;
1703 >                throw new AssertionError("Unexpected exception: " + fail, fail);
1704              }
1705          }
1706      }
# Line 1884 | Line 1711 | public class JSR166TestCase extends Test
1711              assertEquals(0, q.size());
1712              assertNull(q.peek());
1713              assertNull(q.poll());
1714 <            assertNull(q.poll(0, MILLISECONDS));
1714 >            assertNull(q.poll(randomExpiredTimeout(), randomTimeUnit()));
1715              assertEquals(q.toString(), "[]");
1716              assertTrue(Arrays.equals(q.toArray(), new Object[0]));
1717              assertFalse(q.iterator().hasNext());
# Line 1925 | Line 1752 | public class JSR166TestCase extends Test
1752          }
1753      }
1754  
1755 <    void assertImmutable(final Object o) {
1755 >    void assertImmutable(Object o) {
1756          if (o instanceof Collection) {
1757              assertThrows(
1758                  UnsupportedOperationException.class,
1759 <                new Runnable() { public void run() {
1933 <                        ((Collection) o).add(null);}});
1759 >                () -> ((Collection) o).add(null));
1760          }
1761      }
1762  
1763      @SuppressWarnings("unchecked")
1764      <T> T serialClone(T o) {
1765 +        T clone = null;
1766          try {
1767              ObjectInputStream ois = new ObjectInputStream
1768                  (new ByteArrayInputStream(serialBytes(o)));
1769 <            T clone = (T) ois.readObject();
1943 <            if (o == clone) assertImmutable(o);
1944 <            assertSame(o.getClass(), clone.getClass());
1945 <            return clone;
1769 >            clone = (T) ois.readObject();
1770          } catch (Throwable fail) {
1771              threadUnexpectedException(fail);
1948            return null;
1772          }
1773 +        if (o == clone) assertImmutable(o);
1774 +        else assertSame(o.getClass(), clone.getClass());
1775 +        return clone;
1776      }
1777  
1778      /**
# Line 1965 | Line 1791 | public class JSR166TestCase extends Test
1791              (new ByteArrayInputStream(bos.toByteArray()));
1792          T clone = (T) ois.readObject();
1793          if (o == clone) assertImmutable(o);
1794 <        assertSame(o.getClass(), clone.getClass());
1794 >        else assertSame(o.getClass(), clone.getClass());
1795          return clone;
1796      }
1797  
# Line 1990 | Line 1816 | public class JSR166TestCase extends Test
1816      }
1817  
1818      public void assertThrows(Class<? extends Throwable> expectedExceptionClass,
1819 <                             Runnable... throwingActions) {
1820 <        for (Runnable throwingAction : throwingActions) {
1819 >                             Action... throwingActions) {
1820 >        for (Action throwingAction : throwingActions) {
1821              boolean threw = false;
1822              try { throwingAction.run(); }
1823              catch (Throwable t) {
1824                  threw = true;
1825 <                if (!expectedExceptionClass.isInstance(t)) {
1826 <                    AssertionFailedError afe =
1827 <                        new AssertionFailedError
1828 <                        ("Expected " + expectedExceptionClass.getName() +
1829 <                         ", got " + t.getClass().getName());
2004 <                    afe.initCause(t);
2005 <                    threadUnexpectedException(afe);
2006 <                }
1825 >                if (!expectedExceptionClass.isInstance(t))
1826 >                    throw new AssertionError(
1827 >                            "Expected " + expectedExceptionClass.getName() +
1828 >                            ", got " + t.getClass().getName(),
1829 >                            t);
1830              }
1831              if (!threw)
1832                  shouldThrow(expectedExceptionClass.getName());
# Line 2035 | Line 1858 | public class JSR166TestCase extends Test
1858      static <T> void shuffle(T[] array) {
1859          Collections.shuffle(Arrays.asList(array), ThreadLocalRandom.current());
1860      }
1861 +
1862 +    /**
1863 +     * Returns the same String as would be returned by {@link
1864 +     * Object#toString}, whether or not the given object's class
1865 +     * overrides toString().
1866 +     *
1867 +     * @see System#identityHashCode
1868 +     */
1869 +    static String identityString(Object x) {
1870 +        return x.getClass().getName()
1871 +            + "@" + Integer.toHexString(System.identityHashCode(x));
1872 +    }
1873 +
1874 +    // --- Shared assertions for Executor tests ---
1875 +
1876 +    /**
1877 +     * Returns maximum number of tasks that can be submitted to given
1878 +     * pool (with bounded queue) before saturation (when submission
1879 +     * throws RejectedExecutionException).
1880 +     */
1881 +    static final int saturatedSize(ThreadPoolExecutor pool) {
1882 +        BlockingQueue<Runnable> q = pool.getQueue();
1883 +        return pool.getMaximumPoolSize() + q.size() + q.remainingCapacity();
1884 +    }
1885 +
1886 +    @SuppressWarnings("FutureReturnValueIgnored")
1887 +    void assertNullTaskSubmissionThrowsNullPointerException(Executor e) {
1888 +        try {
1889 +            e.execute((Runnable) null);
1890 +            shouldThrow();
1891 +        } catch (NullPointerException success) {}
1892 +
1893 +        if (! (e instanceof ExecutorService)) return;
1894 +        ExecutorService es = (ExecutorService) e;
1895 +        try {
1896 +            es.submit((Runnable) null);
1897 +            shouldThrow();
1898 +        } catch (NullPointerException success) {}
1899 +        try {
1900 +            es.submit((Runnable) null, Boolean.TRUE);
1901 +            shouldThrow();
1902 +        } catch (NullPointerException success) {}
1903 +        try {
1904 +            es.submit((Callable) null);
1905 +            shouldThrow();
1906 +        } catch (NullPointerException success) {}
1907 +
1908 +        if (! (e instanceof ScheduledExecutorService)) return;
1909 +        ScheduledExecutorService ses = (ScheduledExecutorService) e;
1910 +        try {
1911 +            ses.schedule((Runnable) null,
1912 +                         randomTimeout(), randomTimeUnit());
1913 +            shouldThrow();
1914 +        } catch (NullPointerException success) {}
1915 +        try {
1916 +            ses.schedule((Callable) null,
1917 +                         randomTimeout(), randomTimeUnit());
1918 +            shouldThrow();
1919 +        } catch (NullPointerException success) {}
1920 +        try {
1921 +            ses.scheduleAtFixedRate((Runnable) null,
1922 +                                    randomTimeout(), LONG_DELAY_MS, MILLISECONDS);
1923 +            shouldThrow();
1924 +        } catch (NullPointerException success) {}
1925 +        try {
1926 +            ses.scheduleWithFixedDelay((Runnable) null,
1927 +                                       randomTimeout(), LONG_DELAY_MS, MILLISECONDS);
1928 +            shouldThrow();
1929 +        } catch (NullPointerException success) {}
1930 +    }
1931 +
1932 +    void setRejectedExecutionHandler(
1933 +        ThreadPoolExecutor p, RejectedExecutionHandler handler) {
1934 +        p.setRejectedExecutionHandler(handler);
1935 +        assertSame(handler, p.getRejectedExecutionHandler());
1936 +    }
1937 +
1938 +    void assertTaskSubmissionsAreRejected(ThreadPoolExecutor p) {
1939 +        final RejectedExecutionHandler savedHandler = p.getRejectedExecutionHandler();
1940 +        final long savedTaskCount = p.getTaskCount();
1941 +        final long savedCompletedTaskCount = p.getCompletedTaskCount();
1942 +        final int savedQueueSize = p.getQueue().size();
1943 +        final boolean stock = (p.getClass().getClassLoader() == null);
1944 +
1945 +        Runnable r = () -> {};
1946 +        Callable<Boolean> c = () -> Boolean.TRUE;
1947 +
1948 +        class Recorder implements RejectedExecutionHandler {
1949 +            public volatile Runnable r = null;
1950 +            public volatile ThreadPoolExecutor p = null;
1951 +            public void reset() { r = null; p = null; }
1952 +            public void rejectedExecution(Runnable r, ThreadPoolExecutor p) {
1953 +                assertNull(this.r);
1954 +                assertNull(this.p);
1955 +                this.r = r;
1956 +                this.p = p;
1957 +            }
1958 +        }
1959 +
1960 +        // check custom handler is invoked exactly once per task
1961 +        Recorder recorder = new Recorder();
1962 +        setRejectedExecutionHandler(p, recorder);
1963 +        for (int i = 2; i--> 0; ) {
1964 +            recorder.reset();
1965 +            p.execute(r);
1966 +            if (stock && p.getClass() == ThreadPoolExecutor.class)
1967 +                assertSame(r, recorder.r);
1968 +            assertSame(p, recorder.p);
1969 +
1970 +            recorder.reset();
1971 +            assertFalse(p.submit(r).isDone());
1972 +            if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
1973 +            assertSame(p, recorder.p);
1974 +
1975 +            recorder.reset();
1976 +            assertFalse(p.submit(r, Boolean.TRUE).isDone());
1977 +            if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
1978 +            assertSame(p, recorder.p);
1979 +
1980 +            recorder.reset();
1981 +            assertFalse(p.submit(c).isDone());
1982 +            if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
1983 +            assertSame(p, recorder.p);
1984 +
1985 +            if (p instanceof ScheduledExecutorService) {
1986 +                ScheduledExecutorService s = (ScheduledExecutorService) p;
1987 +                ScheduledFuture<?> future;
1988 +
1989 +                recorder.reset();
1990 +                future = s.schedule(r, randomTimeout(), randomTimeUnit());
1991 +                assertFalse(future.isDone());
1992 +                if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
1993 +                assertSame(p, recorder.p);
1994 +
1995 +                recorder.reset();
1996 +                future = s.schedule(c, randomTimeout(), randomTimeUnit());
1997 +                assertFalse(future.isDone());
1998 +                if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
1999 +                assertSame(p, recorder.p);
2000 +
2001 +                recorder.reset();
2002 +                future = s.scheduleAtFixedRate(r, randomTimeout(), LONG_DELAY_MS, MILLISECONDS);
2003 +                assertFalse(future.isDone());
2004 +                if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
2005 +                assertSame(p, recorder.p);
2006 +
2007 +                recorder.reset();
2008 +                future = s.scheduleWithFixedDelay(r, randomTimeout(), LONG_DELAY_MS, MILLISECONDS);
2009 +                assertFalse(future.isDone());
2010 +                if (stock) assertTrue(!((FutureTask) recorder.r).isDone());
2011 +                assertSame(p, recorder.p);
2012 +            }
2013 +        }
2014 +
2015 +        // Checking our custom handler above should be sufficient, but
2016 +        // we add some integration tests of standard handlers.
2017 +        final AtomicReference<Thread> thread = new AtomicReference<>();
2018 +        final Runnable setThread = () -> thread.set(Thread.currentThread());
2019 +
2020 +        setRejectedExecutionHandler(p, new ThreadPoolExecutor.AbortPolicy());
2021 +        try {
2022 +            p.execute(setThread);
2023 +            shouldThrow();
2024 +        } catch (RejectedExecutionException success) {}
2025 +        assertNull(thread.get());
2026 +
2027 +        setRejectedExecutionHandler(p, new ThreadPoolExecutor.DiscardPolicy());
2028 +        p.execute(setThread);
2029 +        assertNull(thread.get());
2030 +
2031 +        setRejectedExecutionHandler(p, new ThreadPoolExecutor.CallerRunsPolicy());
2032 +        p.execute(setThread);
2033 +        if (p.isShutdown())
2034 +            assertNull(thread.get());
2035 +        else
2036 +            assertSame(Thread.currentThread(), thread.get());
2037 +
2038 +        setRejectedExecutionHandler(p, savedHandler);
2039 +
2040 +        // check that pool was not perturbed by handlers
2041 +        assertEquals(savedTaskCount, p.getTaskCount());
2042 +        assertEquals(savedCompletedTaskCount, p.getCompletedTaskCount());
2043 +        assertEquals(savedQueueSize, p.getQueue().size());
2044 +    }
2045 +
2046 +    void assertCollectionsEquals(Collection<?> x, Collection<?> y) {
2047 +        assertEquals(x, y);
2048 +        assertEquals(y, x);
2049 +        assertEquals(x.isEmpty(), y.isEmpty());
2050 +        assertEquals(x.size(), y.size());
2051 +        if (x instanceof List) {
2052 +            assertEquals(x.toString(), y.toString());
2053 +        }
2054 +        if (x instanceof List || x instanceof Set) {
2055 +            assertEquals(x.hashCode(), y.hashCode());
2056 +        }
2057 +        if (x instanceof List || x instanceof Deque) {
2058 +            assertTrue(Arrays.equals(x.toArray(), y.toArray()));
2059 +            assertTrue(Arrays.equals(x.toArray(new Object[0]),
2060 +                                     y.toArray(new Object[0])));
2061 +        }
2062 +    }
2063 +
2064 +    /**
2065 +     * A weaker form of assertCollectionsEquals which does not insist
2066 +     * that the two collections satisfy Object#equals(Object), since
2067 +     * they may use identity semantics as Deques do.
2068 +     */
2069 +    void assertCollectionsEquivalent(Collection<?> x, Collection<?> y) {
2070 +        if (x instanceof List || x instanceof Set)
2071 +            assertCollectionsEquals(x, y);
2072 +        else {
2073 +            assertEquals(x.isEmpty(), y.isEmpty());
2074 +            assertEquals(x.size(), y.size());
2075 +            assertEquals(new HashSet(x), new HashSet(y));
2076 +            if (x instanceof Deque) {
2077 +                assertTrue(Arrays.equals(x.toArray(), y.toArray()));
2078 +                assertTrue(Arrays.equals(x.toArray(new Object[0]),
2079 +                                         y.toArray(new Object[0])));
2080 +            }
2081 +        }
2082 +    }
2083   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines