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.124 by jsr166, Wed Dec 31 21:06:32 2014 UTC vs.
Revision 1.169 by jsr166, Thu Oct 8 21:50:26 2015 UTC

# Line 7 | Line 7
7   */
8  
9   import static java.util.concurrent.TimeUnit.MILLISECONDS;
10 + import static java.util.concurrent.TimeUnit.MINUTES;
11   import static java.util.concurrent.TimeUnit.NANOSECONDS;
12  
13   import java.io.ByteArrayInputStream;
# Line 15 | Line 16 | import java.io.ObjectInputStream;
16   import java.io.ObjectOutputStream;
17   import java.lang.management.ManagementFactory;
18   import java.lang.management.ThreadInfo;
19 + import java.lang.management.ThreadMXBean;
20 + import java.lang.reflect.Constructor;
21   import java.lang.reflect.Method;
22 + import java.lang.reflect.Modifier;
23   import java.security.CodeSource;
24   import java.security.Permission;
25   import java.security.PermissionCollection;
# Line 27 | Line 31 | import java.util.ArrayList;
31   import java.util.Arrays;
32   import java.util.Date;
33   import java.util.Enumeration;
34 + import java.util.Iterator;
35   import java.util.List;
36   import java.util.NoSuchElementException;
37   import java.util.PropertyPermission;
# Line 34 | Line 39 | import java.util.concurrent.BlockingQueu
39   import java.util.concurrent.Callable;
40   import java.util.concurrent.CountDownLatch;
41   import java.util.concurrent.CyclicBarrier;
42 + import java.util.concurrent.ExecutionException;
43 + import java.util.concurrent.Executors;
44   import java.util.concurrent.ExecutorService;
45 + import java.util.concurrent.ForkJoinPool;
46   import java.util.concurrent.Future;
47   import java.util.concurrent.RecursiveAction;
48   import java.util.concurrent.RecursiveTask;
# Line 49 | Line 57 | import java.util.regex.Pattern;
57   import junit.framework.AssertionFailedError;
58   import junit.framework.Test;
59   import junit.framework.TestCase;
60 + import junit.framework.TestResult;
61   import junit.framework.TestSuite;
62  
63   /**
# Line 61 | Line 70 | import junit.framework.TestSuite;
70   *
71   * <ol>
72   *
73 < * <li> All assertions in code running in generated threads must use
73 > * <li>All assertions in code running in generated threads must use
74   * the forms {@link #threadFail}, {@link #threadAssertTrue}, {@link
75   * #threadAssertEquals}, or {@link #threadAssertNull}, (not
76   * {@code fail}, {@code assertTrue}, etc.) It is OK (but not
77   * particularly recommended) for other code to use these forms too.
78   * Only the most typically used JUnit assertion methods are defined
79 < * this way, but enough to live with.</li>
79 > * this way, but enough to live with.
80   *
81 < * <li> If you override {@link #setUp} or {@link #tearDown}, make sure
81 > * <li>If you override {@link #setUp} or {@link #tearDown}, make sure
82   * to invoke {@code super.setUp} and {@code super.tearDown} within
83   * them. These methods are used to clear and check for thread
84 < * assertion failures.</li>
84 > * assertion failures.
85   *
86   * <li>All delays and timeouts must use one of the constants {@code
87   * SHORT_DELAY_MS}, {@code SMALL_DELAY_MS}, {@code MEDIUM_DELAY_MS},
# Line 83 | Line 92 | import junit.framework.TestSuite;
92   * is always discriminable as larger than SHORT and smaller than
93   * MEDIUM.  And so on. These constants are set to conservative values,
94   * but even so, if there is ever any doubt, they can all be increased
95 < * in one spot to rerun tests on slower platforms.</li>
95 > * in one spot to rerun tests on slower platforms.
96   *
97 < * <li> All threads generated must be joined inside each test case
97 > * <li>All threads generated must be joined inside each test case
98   * method (or {@code fail} to do so) before returning from the
99   * method. The {@code joinPool} method can be used to do this when
100 < * using Executors.</li>
100 > * using Executors.
101   *
102   * </ol>
103   *
104   * <p><b>Other notes</b>
105   * <ul>
106   *
107 < * <li> Usually, there is one testcase method per JSR166 method
107 > * <li>Usually, there is one testcase method per JSR166 method
108   * covering "normal" operation, and then as many exception-testing
109   * methods as there are exceptions the method can throw. Sometimes
110   * there are multiple tests per JSR166 method when the different
111   * "normal" behaviors differ significantly. And sometimes testcases
112   * cover multiple methods when they cannot be tested in
113 < * isolation.</li>
113 > * isolation.
114   *
115 < * <li> The documentation style for testcases is to provide as javadoc
115 > * <li>The documentation style for testcases is to provide as javadoc
116   * a simple sentence or two describing the property that the testcase
117   * method purports to test. The javadocs do not say anything about how
118 < * the property is tested. To find out, read the code.</li>
118 > * the property is tested. To find out, read the code.
119   *
120 < * <li> These tests are "conformance tests", and do not attempt to
120 > * <li>These tests are "conformance tests", and do not attempt to
121   * test throughput, latency, scalability or other performance factors
122   * (see the separate "jtreg" tests for a set intended to check these
123   * for the most central aspects of functionality.) So, most tests use
124   * the smallest sensible numbers of threads, collection sizes, etc
125 < * needed to check basic conformance.</li>
125 > * needed to check basic conformance.
126   *
127   * <li>The test classes currently do not declare inclusion in
128   * any particular package to simplify things for people integrating
129 < * them in TCK test suites.</li>
129 > * them in TCK test suites.
130   *
131 < * <li> As a convenience, the {@code main} of this class (JSR166TestCase)
132 < * runs all JSR166 unit tests.</li>
131 > * <li>As a convenience, the {@code main} of this class (JSR166TestCase)
132 > * runs all JSR166 unit tests.
133   *
134   * </ul>
135   */
# Line 159 | Line 168 | public class JSR166TestCase extends Test
168          Integer.getInteger("jsr166.runsPerTest", 1);
169  
170      /**
171 +     * The number of repetitions of the test suite (for finding leaks?).
172 +     */
173 +    private static final int suiteRuns =
174 +        Integer.getInteger("jsr166.suiteRuns", 1);
175 +
176 +    public JSR166TestCase() { super(); }
177 +    public JSR166TestCase(String name) { super(name); }
178 +
179 +    /**
180       * A filter for tests to run, matching strings of the form
181       * methodName(className), e.g. "testInvokeAll5(ForkJoinPoolTest)"
182       * Usefully combined with jsr166.runsPerTest.
# Line 170 | Line 188 | public class JSR166TestCase extends Test
188          return (regex == null) ? null : Pattern.compile(regex);
189      }
190  
191 <    protected void runTest() throws Throwable {
191 >    static volatile TestCase currentTestCase;
192 >    static {
193 >        Runnable checkForWedgedTest = new Runnable() { public void run() {
194 >            // avoid spurious reports with enormous runsPerTest
195 >            final int timeoutMinutes = Math.max(runsPerTest / 10, 1);
196 >            for (TestCase lastTestCase = currentTestCase;;) {
197 >                try { MINUTES.sleep(timeoutMinutes); }
198 >                catch (InterruptedException unexpected) { break; }
199 >                if (lastTestCase == currentTestCase) {
200 >                    System.err.println
201 >                        ("Looks like we're stuck running test: "
202 >                         + lastTestCase);
203 >                    System.err.println("availableProcessors=" +
204 >                        Runtime.getRuntime().availableProcessors());
205 >                    dumpTestThreads();
206 >                    // one stack dump is probably enough; more would be spam
207 >                    break;
208 >                }
209 >                lastTestCase = currentTestCase;
210 >            }}};
211 >        Thread thread = new Thread(checkForWedgedTest, "checkForWedgedTest");
212 >        thread.setDaemon(true);
213 >        thread.start();
214 >    }
215 >
216 >    public void runBare() throws Throwable {
217 >        currentTestCase = this;
218          if (methodFilter == null
219 <            || methodFilter.matcher(toString()).find()) {
220 <            for (int i = 0; i < runsPerTest; i++) {
221 <                if (profileTests)
222 <                    runTestProfiled();
223 <                else
224 <                    super.runTest();
225 <            }
219 >            || methodFilter.matcher(toString()).find())
220 >            super.runBare();
221 >    }
222 >
223 >    protected void runTest() throws Throwable {
224 >        for (int i = 0; i < runsPerTest; i++) {
225 >            if (profileTests)
226 >                runTestProfiled();
227 >            else
228 >                super.runTest();
229          }
230      }
231  
232      protected void runTestProfiled() throws Throwable {
233 <        // Warmup run, notably to trigger all needed classloading.
234 <        super.runTest();
188 <        long t0 = System.nanoTime();
189 <        try {
233 >        for (int i = 0; i < 2; i++) {
234 >            long startTime = System.nanoTime();
235              super.runTest();
236 <        } finally {
237 <            long elapsedMillis = millisElapsedSince(t0);
238 <            if (elapsedMillis >= profileThreshold)
236 >            long elapsedMillis = millisElapsedSince(startTime);
237 >            if (elapsedMillis < profileThreshold)
238 >                break;
239 >            // Never report first run of any test; treat it as a
240 >            // warmup run, notably to trigger all needed classloading,
241 >            if (i > 0)
242                  System.out.printf("%n%s: %d%n", toString(), elapsedMillis);
243          }
244      }
245  
246      /**
247       * Runs all JSR166 unit tests using junit.textui.TestRunner.
200     * Optional command line arg provides the number of iterations to
201     * repeat running the tests.
248       */
249      public static void main(String[] args) {
250 +        main(suite(), args);
251 +    }
252 +
253 +    /**
254 +     * Runs all unit tests in the given test suite.
255 +     * Actual behavior influenced by jsr166.* system properties.
256 +     */
257 +    static void main(Test suite, String[] args) {
258          if (useSecurityManager) {
259              System.err.println("Setting a permissive security manager");
260              Policy.setPolicy(permissivePolicy());
261              System.setSecurityManager(new SecurityManager());
262          }
263 <        int iters = (args.length == 0) ? 1 : Integer.parseInt(args[0]);
264 <
265 <        Test s = suite();
266 <        for (int i = 0; i < iters; ++i) {
213 <            junit.textui.TestRunner.run(s);
263 >        for (int i = 0; i < suiteRuns; i++) {
264 >            TestResult result = junit.textui.TestRunner.run(suite);
265 >            if (!result.wasSuccessful())
266 >                System.exit(1);
267              System.gc();
268              System.runFinalization();
269          }
217        System.exit(0);
270      }
271  
272      public static TestSuite newTestSuite(Object... suiteOrClasses) {
# Line 265 | Line 317 | public class JSR166TestCase extends Test
317      public static boolean atLeastJava7() { return JAVA_CLASS_VERSION >= 51.0; }
318      public static boolean atLeastJava8() { return JAVA_CLASS_VERSION >= 52.0; }
319      public static boolean atLeastJava9() {
320 <        // As of 2014-05, java9 still uses 52.0 class file version
321 <        return JAVA_SPECIFICATION_VERSION.startsWith("1.9");
320 >        return JAVA_CLASS_VERSION >= 53.0
321 >            // As of 2015-09, java9 still uses 52.0 class file version
322 >            || JAVA_SPECIFICATION_VERSION.matches("^(1\\.)?(9|[0-9][0-9])$");
323 >    }
324 >    public static boolean atLeastJava10() {
325 >        return JAVA_CLASS_VERSION >= 54.0
326 >            || JAVA_SPECIFICATION_VERSION.matches("^(1\\.)?[0-9][0-9]$");
327      }
328  
329      /**
# Line 355 | Line 412 | public class JSR166TestCase extends Test
412                  "LongAdderTest",
413                  "SplittableRandomTest",
414                  "StampedLockTest",
415 +                "SubmissionPublisherTest",
416                  "ThreadLocalRandom8Test",
417              };
418              addNamedTestClasses(suite, java8TestClassNames);
# Line 363 | Line 421 | public class JSR166TestCase extends Test
421          // Java9+ test classes
422          if (atLeastJava9()) {
423              String[] java9TestClassNames = {
424 <                "ThreadPoolExecutor9Test",
424 >                // Currently empty, but expecting varhandle tests
425              };
426              addNamedTestClasses(suite, java9TestClassNames);
427          }
# Line 371 | Line 429 | public class JSR166TestCase extends Test
429          return suite;
430      }
431  
432 +    /** Returns list of junit-style test method names in given class. */
433 +    public static ArrayList<String> testMethodNames(Class<?> testClass) {
434 +        Method[] methods = testClass.getDeclaredMethods();
435 +        ArrayList<String> names = new ArrayList<String>(methods.length);
436 +        for (Method method : methods) {
437 +            if (method.getName().startsWith("test")
438 +                && Modifier.isPublic(method.getModifiers())
439 +                // method.getParameterCount() requires jdk8+
440 +                && method.getParameterTypes().length == 0) {
441 +                names.add(method.getName());
442 +            }
443 +        }
444 +        return names;
445 +    }
446 +
447 +    /**
448 +     * Returns junit-style testSuite for the given test class, but
449 +     * parameterized by passing extra data to each test.
450 +     */
451 +    public static <ExtraData> Test parameterizedTestSuite
452 +        (Class<? extends JSR166TestCase> testClass,
453 +         Class<ExtraData> dataClass,
454 +         ExtraData data) {
455 +        try {
456 +            TestSuite suite = new TestSuite();
457 +            Constructor c =
458 +                testClass.getDeclaredConstructor(dataClass, String.class);
459 +            for (String methodName : testMethodNames(testClass))
460 +                suite.addTest((Test) c.newInstance(data, methodName));
461 +            return suite;
462 +        } catch (Exception e) {
463 +            throw new Error(e);
464 +        }
465 +    }
466 +
467 +    /**
468 +     * Returns junit-style testSuite for the jdk8 extension of the
469 +     * given test class, but parameterized by passing extra data to
470 +     * each test.  Uses reflection to allow compilation in jdk7.
471 +     */
472 +    public static <ExtraData> Test jdk8ParameterizedTestSuite
473 +        (Class<? extends JSR166TestCase> testClass,
474 +         Class<ExtraData> dataClass,
475 +         ExtraData data) {
476 +        if (atLeastJava8()) {
477 +            String name = testClass.getName();
478 +            String name8 = name.replaceAll("Test$", "8Test");
479 +            if (name.equals(name8)) throw new Error(name);
480 +            try {
481 +                return (Test)
482 +                    Class.forName(name8)
483 +                    .getMethod("testSuite", new Class[] { dataClass })
484 +                    .invoke(null, data);
485 +            } catch (Exception e) {
486 +                throw new Error(e);
487 +            }
488 +        } else {
489 +            return new TestSuite();
490 +        }
491 +    }
492 +
493      // Delays for timing-dependent tests, in milliseconds.
494  
495      public static long SHORT_DELAY_MS;
# Line 405 | Line 524 | public class JSR166TestCase extends Test
524      }
525  
526      /**
527 <     * Returns a new Date instance representing a time delayMillis
528 <     * milliseconds in the future.
527 >     * Returns a new Date instance representing a time at least
528 >     * delayMillis milliseconds in the future.
529       */
530      Date delayedDate(long delayMillis) {
531 <        return new Date(System.currentTimeMillis() + delayMillis);
531 >        // Add 1 because currentTimeMillis is known to round into the past.
532 >        return new Date(System.currentTimeMillis() + delayMillis + 1);
533      }
534  
535      /**
# Line 425 | Line 545 | public class JSR166TestCase extends Test
545       * the same test have no effect.
546       */
547      public void threadRecordFailure(Throwable t) {
548 +        System.err.println(t);
549 +        dumpTestThreads();
550          threadFailure.compareAndSet(null, t);
551      }
552  
# Line 432 | Line 554 | public class JSR166TestCase extends Test
554          setDelays();
555      }
556  
557 +    void tearDownFail(String format, Object... args) {
558 +        String msg = toString() + ": " + String.format(format, args);
559 +        System.err.println(msg);
560 +        dumpTestThreads();
561 +        throw new AssertionFailedError(msg);
562 +    }
563 +
564      /**
565       * Extra checks that get done for all test cases.
566       *
# Line 459 | Line 588 | public class JSR166TestCase extends Test
588          }
589  
590          if (Thread.interrupted())
591 <            throw new AssertionFailedError("interrupt status set in main thread");
591 >            tearDownFail("interrupt status set in main thread");
592  
593          checkForkJoinPoolThreadLeaks();
594      }
595  
596      /**
597 <     * Find missing try { ... } finally { joinPool(e); }
597 >     * Finds missing PoolCleaners
598       */
599      void checkForkJoinPoolThreadLeaks() throws InterruptedException {
600 <        Thread[] survivors = new Thread[5];
600 >        Thread[] survivors = new Thread[7];
601          int count = Thread.enumerate(survivors);
602          for (int i = 0; i < count; i++) {
603              Thread thread = survivors[i];
# Line 476 | Line 605 | public class JSR166TestCase extends Test
605              if (name.startsWith("ForkJoinPool-")) {
606                  // give thread some time to terminate
607                  thread.join(LONG_DELAY_MS);
608 <                if (!thread.isAlive()) continue;
609 <                thread.stop();
610 <                throw new AssertionFailedError
482 <                    (String.format("Found leaked ForkJoinPool thread test=%s thread=%s%n",
483 <                                   toString(), name));
608 >                if (thread.isAlive())
609 >                    tearDownFail("Found leaked ForkJoinPool thread thread=%s",
610 >                                 thread);
611              }
612          }
613 +
614 +        if (!ForkJoinPool.commonPool()
615 +            .awaitQuiescence(LONG_DELAY_MS, MILLISECONDS))
616 +            tearDownFail("ForkJoin common pool thread stuck");
617      }
618  
619      /**
# Line 495 | Line 626 | public class JSR166TestCase extends Test
626              fail(reason);
627          } catch (AssertionFailedError t) {
628              threadRecordFailure(t);
629 <            fail(reason);
629 >            throw t;
630          }
631      }
632  
# Line 563 | Line 694 | public class JSR166TestCase extends Test
694      public void threadAssertEquals(Object x, Object y) {
695          try {
696              assertEquals(x, y);
697 <        } catch (AssertionFailedError t) {
698 <            threadRecordFailure(t);
699 <            throw t;
700 <        } catch (Throwable t) {
701 <            threadUnexpectedException(t);
697 >        } catch (AssertionFailedError fail) {
698 >            threadRecordFailure(fail);
699 >            throw fail;
700 >        } catch (Throwable fail) {
701 >            threadUnexpectedException(fail);
702          }
703      }
704  
# Line 579 | Line 710 | public class JSR166TestCase extends Test
710      public void threadAssertSame(Object x, Object y) {
711          try {
712              assertSame(x, y);
713 <        } catch (AssertionFailedError t) {
714 <            threadRecordFailure(t);
715 <            throw t;
713 >        } catch (AssertionFailedError fail) {
714 >            threadRecordFailure(fail);
715 >            throw fail;
716          }
717      }
718  
# Line 622 | Line 753 | public class JSR166TestCase extends Test
753      /**
754       * Delays, via Thread.sleep, for the given millisecond delay, but
755       * if the sleep is shorter than specified, may re-sleep or yield
756 <     * until time elapses.
756 >     * until time elapses.  Ensures that the given time, as measured
757 >     * by System.nanoTime(), has elapsed.
758       */
759      static void delay(long millis) throws InterruptedException {
760 <        long startTime = System.nanoTime();
761 <        long ns = millis * 1000 * 1000;
762 <        for (;;) {
760 >        long nanos = millis * (1000 * 1000);
761 >        final long wakeupTime = System.nanoTime() + nanos;
762 >        do {
763              if (millis > 0L)
764                  Thread.sleep(millis);
765              else // too short to sleep
766                  Thread.yield();
767 <            long d = ns - (System.nanoTime() - startTime);
768 <            if (d > 0L)
769 <                millis = d / (1000 * 1000);
770 <            else
771 <                break;
767 >            nanos = wakeupTime - System.nanoTime();
768 >            millis = nanos / (1000 * 1000);
769 >        } while (nanos >= 0L);
770 >    }
771 >
772 >    /**
773 >     * Allows use of try-with-resources with per-test thread pools.
774 >     */
775 >    class PoolCleaner implements AutoCloseable {
776 >        private final ExecutorService pool;
777 >        public PoolCleaner(ExecutorService pool) { this.pool = pool; }
778 >        public void close() { joinPool(pool); }
779 >    }
780 >
781 >    /**
782 >     * An extension of PoolCleaner that has an action to release the pool.
783 >     */
784 >    class PoolCleanerWithReleaser extends PoolCleaner {
785 >        private final Runnable releaser;
786 >        public PoolCleanerWithReleaser(ExecutorService pool, Runnable releaser) {
787 >            super(pool);
788 >            this.releaser = releaser;
789 >        }
790 >        public void close() {
791 >            try {
792 >                releaser.run();
793 >            } finally {
794 >                super.close();
795 >            }
796          }
797      }
798  
799 +    PoolCleaner cleaner(ExecutorService pool) {
800 +        return new PoolCleaner(pool);
801 +    }
802 +
803 +    PoolCleaner cleaner(ExecutorService pool, Runnable releaser) {
804 +        return new PoolCleanerWithReleaser(pool, releaser);
805 +    }
806 +
807 +    PoolCleaner cleaner(ExecutorService pool, CountDownLatch latch) {
808 +        return new PoolCleanerWithReleaser(pool, releaser(latch));
809 +    }
810 +
811 +    Runnable releaser(final CountDownLatch latch) {
812 +        return new Runnable() { public void run() {
813 +            do { latch.countDown(); }
814 +            while (latch.getCount() > 0);
815 +        }};
816 +    }
817 +
818      /**
819       * Waits out termination of a thread pool or fails doing so.
820       */
821 <    void joinPool(ExecutorService exec) {
821 >    void joinPool(ExecutorService pool) {
822          try {
823 <            exec.shutdown();
824 <            if (!exec.awaitTermination(2 * LONG_DELAY_MS, MILLISECONDS))
825 <                fail("ExecutorService " + exec +
826 <                     " did not terminate in a timely manner");
823 >            pool.shutdown();
824 >            if (!pool.awaitTermination(2 * LONG_DELAY_MS, MILLISECONDS)) {
825 >                try {
826 >                    threadFail("ExecutorService " + pool +
827 >                               " did not terminate in a timely manner");
828 >                } finally {
829 >                    // last resort, for the benefit of subsequent tests
830 >                    pool.shutdownNow();
831 >                    pool.awaitTermination(MEDIUM_DELAY_MS, MILLISECONDS);
832 >                }
833 >            }
834          } catch (SecurityException ok) {
835              // Allowed in case test doesn't have privs
836 <        } catch (InterruptedException ie) {
837 <            fail("Unexpected InterruptedException");
836 >        } catch (InterruptedException fail) {
837 >            threadFail("Unexpected InterruptedException");
838 >        }
839 >    }
840 >
841 >    /** Like Runnable, but with the freedom to throw anything */
842 >    interface Action { public void run() throws Throwable; }
843 >
844 >    /**
845 >     * Runs all the given actions in parallel, failing if any fail.
846 >     * Useful for running multiple variants of tests that are
847 >     * necessarily individually slow because they must block.
848 >     */
849 >    void testInParallel(Action ... actions) {
850 >        ExecutorService pool = Executors.newCachedThreadPool();
851 >        try (PoolCleaner cleaner = cleaner(pool)) {
852 >            ArrayList<Future<?>> futures = new ArrayList<>(actions.length);
853 >            for (final Action action : actions)
854 >                futures.add(pool.submit(new CheckedRunnable() {
855 >                    public void realRun() throws Throwable { action.run();}}));
856 >            for (Future<?> future : futures)
857 >                try {
858 >                    assertNull(future.get(LONG_DELAY_MS, MILLISECONDS));
859 >                } catch (ExecutionException ex) {
860 >                    threadUnexpectedException(ex.getCause());
861 >                } catch (Exception ex) {
862 >                    threadUnexpectedException(ex);
863 >                }
864          }
865      }
866  
867      /**
868 <     * A debugging tool to print all stack traces, as jstack does.
868 >     * A debugging tool to print stack traces of most threads, as jstack does.
869 >     * Uninteresting threads are filtered out.
870       */
871 <    static void printAllStackTraces() {
872 <        for (ThreadInfo info :
873 <                 ManagementFactory.getThreadMXBean()
874 <                 .dumpAllThreads(true, true))
871 >    static void dumpTestThreads() {
872 >        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
873 >        System.err.println("------ stacktrace dump start ------");
874 >        for (ThreadInfo info : threadMXBean.dumpAllThreads(true, true)) {
875 >            String name = info.getThreadName();
876 >            if ("Signal Dispatcher".equals(name))
877 >                continue;
878 >            if ("Reference Handler".equals(name)
879 >                && info.getLockName().startsWith("java.lang.ref.Reference$Lock"))
880 >                continue;
881 >            if ("Finalizer".equals(name)
882 >                && info.getLockName().startsWith("java.lang.ref.ReferenceQueue$Lock"))
883 >                continue;
884 >            if ("checkForWedgedTest".equals(name))
885 >                continue;
886              System.err.print(info);
887 +        }
888 +        System.err.println("------ stacktrace dump end ------");
889      }
890  
891      /**
# Line 682 | Line 904 | public class JSR166TestCase extends Test
904              // No need to optimize the failing case via Thread.join.
905              delay(millis);
906              assertTrue(thread.isAlive());
907 <        } catch (InterruptedException ie) {
908 <            fail("Unexpected InterruptedException");
907 >        } catch (InterruptedException fail) {
908 >            threadFail("Unexpected InterruptedException");
909          }
910      }
911  
# Line 704 | Line 926 | public class JSR166TestCase extends Test
926              delay(millis);
927              for (Thread thread : threads)
928                  assertTrue(thread.isAlive());
929 <        } catch (InterruptedException ie) {
930 <            fail("Unexpected InterruptedException");
929 >        } catch (InterruptedException fail) {
930 >            threadFail("Unexpected InterruptedException");
931          }
932      }
933  
# Line 726 | Line 948 | public class JSR166TestCase extends Test
948              future.get(timeoutMillis, MILLISECONDS);
949              shouldThrow();
950          } catch (TimeoutException success) {
951 <        } catch (Exception e) {
952 <            threadUnexpectedException(e);
951 >        } catch (Exception fail) {
952 >            threadUnexpectedException(fail);
953          } finally { future.cancel(true); }
954          assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
955      }
# Line 883 | Line 1105 | public class JSR166TestCase extends Test
1105      void sleep(long millis) {
1106          try {
1107              delay(millis);
1108 <        } catch (InterruptedException ie) {
1108 >        } catch (InterruptedException fail) {
1109              AssertionFailedError afe =
1110                  new AssertionFailedError("Unexpected InterruptedException");
1111 <            afe.initCause(ie);
1111 >            afe.initCause(fail);
1112              throw afe;
1113          }
1114      }
# Line 978 | Line 1200 | public class JSR166TestCase extends Test
1200      void awaitTermination(Thread t, long timeoutMillis) {
1201          try {
1202              t.join(timeoutMillis);
1203 <        } catch (InterruptedException ie) {
1204 <            threadUnexpectedException(ie);
1203 >        } catch (InterruptedException fail) {
1204 >            threadUnexpectedException(fail);
1205          } finally {
1206              if (t.getState() != Thread.State.TERMINATED) {
1207                  t.interrupt();
1208 <                fail("Test timed out");
1208 >                threadFail("Test timed out");
1209              }
1210          }
1211      }
# Line 1005 | Line 1227 | public class JSR166TestCase extends Test
1227          public final void run() {
1228              try {
1229                  realRun();
1230 <            } catch (Throwable t) {
1231 <                threadUnexpectedException(t);
1230 >            } catch (Throwable fail) {
1231 >                threadUnexpectedException(fail);
1232              }
1233          }
1234      }
# Line 1060 | Line 1282 | public class JSR166TestCase extends Test
1282                  threadShouldThrow("InterruptedException");
1283              } catch (InterruptedException success) {
1284                  threadAssertFalse(Thread.interrupted());
1285 <            } catch (Throwable t) {
1286 <                threadUnexpectedException(t);
1285 >            } catch (Throwable fail) {
1286 >                threadUnexpectedException(fail);
1287              }
1288          }
1289      }
# Line 1072 | Line 1294 | public class JSR166TestCase extends Test
1294          public final T call() {
1295              try {
1296                  return realCall();
1297 <            } catch (Throwable t) {
1298 <                threadUnexpectedException(t);
1297 >            } catch (Throwable fail) {
1298 >                threadUnexpectedException(fail);
1299                  return null;
1300              }
1301          }
# Line 1090 | Line 1312 | public class JSR166TestCase extends Test
1312                  return result;
1313              } catch (InterruptedException success) {
1314                  threadAssertFalse(Thread.interrupted());
1315 <            } catch (Throwable t) {
1316 <                threadUnexpectedException(t);
1315 >            } catch (Throwable fail) {
1316 >                threadUnexpectedException(fail);
1317              }
1318              return null;
1319          }
# Line 1108 | Line 1330 | public class JSR166TestCase extends Test
1330      public static final String TEST_STRING = "a test string";
1331  
1332      public static class StringTask implements Callable<String> {
1333 <        public String call() { return TEST_STRING; }
1333 >        final String value;
1334 >        public StringTask() { this(TEST_STRING); }
1335 >        public StringTask(String value) { this.value = value; }
1336 >        public String call() { return value; }
1337      }
1338  
1339      public Callable<String> latchAwaitingStringTask(final CountDownLatch latch) {
# Line 1121 | Line 1346 | public class JSR166TestCase extends Test
1346              }};
1347      }
1348  
1349 <    public Runnable awaiter(final CountDownLatch latch) {
1349 >    public Runnable countDowner(final CountDownLatch latch) {
1350          return new CheckedRunnable() {
1351              public void realRun() throws InterruptedException {
1352 <                await(latch);
1352 >                latch.countDown();
1353              }};
1354      }
1355  
1356 +    class LatchAwaiter extends CheckedRunnable {
1357 +        static final int NEW = 0;
1358 +        static final int RUNNING = 1;
1359 +        static final int DONE = 2;
1360 +        final CountDownLatch latch;
1361 +        int state = NEW;
1362 +        LatchAwaiter(CountDownLatch latch) { this.latch = latch; }
1363 +        public void realRun() throws InterruptedException {
1364 +            state = 1;
1365 +            await(latch);
1366 +            state = 2;
1367 +        }
1368 +    }
1369 +
1370 +    public LatchAwaiter awaiter(CountDownLatch latch) {
1371 +        return new LatchAwaiter(latch);
1372 +    }
1373 +
1374      public void await(CountDownLatch latch) {
1375          try {
1376              assertTrue(latch.await(LONG_DELAY_MS, MILLISECONDS));
1377 <        } catch (Throwable t) {
1378 <            threadUnexpectedException(t);
1377 >        } catch (Throwable fail) {
1378 >            threadUnexpectedException(fail);
1379          }
1380      }
1381  
1382      public void await(Semaphore semaphore) {
1383          try {
1384              assertTrue(semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS));
1385 <        } catch (Throwable t) {
1386 <            threadUnexpectedException(t);
1385 >        } catch (Throwable fail) {
1386 >            threadUnexpectedException(fail);
1387          }
1388      }
1389  
# Line 1334 | Line 1577 | public class JSR166TestCase extends Test
1577          @Override protected final void compute() {
1578              try {
1579                  realCompute();
1580 <            } catch (Throwable t) {
1581 <                threadUnexpectedException(t);
1580 >            } catch (Throwable fail) {
1581 >                threadUnexpectedException(fail);
1582              }
1583          }
1584      }
# Line 1349 | Line 1592 | public class JSR166TestCase extends Test
1592          @Override protected final T compute() {
1593              try {
1594                  return realCompute();
1595 <            } catch (Throwable t) {
1596 <                threadUnexpectedException(t);
1595 >            } catch (Throwable fail) {
1596 >                threadUnexpectedException(fail);
1597                  return null;
1598              }
1599          }
# Line 1374 | Line 1617 | public class JSR166TestCase extends Test
1617          public int await() {
1618              try {
1619                  return super.await(2 * LONG_DELAY_MS, MILLISECONDS);
1620 <            } catch (TimeoutException e) {
1620 >            } catch (TimeoutException timedOut) {
1621                  throw new AssertionFailedError("timed out");
1622 <            } catch (Exception e) {
1622 >            } catch (Exception fail) {
1623                  AssertionFailedError afe =
1624 <                    new AssertionFailedError("Unexpected exception: " + e);
1625 <                afe.initCause(e);
1624 >                    new AssertionFailedError("Unexpected exception: " + fail);
1625 >                afe.initCause(fail);
1626                  throw afe;
1627              }
1628          }
# Line 1407 | Line 1650 | public class JSR166TestCase extends Test
1650                  q.remove();
1651                  shouldThrow();
1652              } catch (NoSuchElementException success) {}
1653 <        } catch (InterruptedException ie) {
1411 <            threadUnexpectedException(ie);
1412 <        }
1653 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
1654      }
1655  
1656      void assertSerialEquals(Object x, Object y) {
# Line 1428 | Line 1669 | public class JSR166TestCase extends Test
1669              oos.flush();
1670              oos.close();
1671              return bos.toByteArray();
1672 <        } catch (Throwable t) {
1673 <            threadUnexpectedException(t);
1672 >        } catch (Throwable fail) {
1673 >            threadUnexpectedException(fail);
1674              return new byte[0];
1675          }
1676      }
# Line 1442 | Line 1683 | public class JSR166TestCase extends Test
1683              T clone = (T) ois.readObject();
1684              assertSame(o.getClass(), clone.getClass());
1685              return clone;
1686 <        } catch (Throwable t) {
1687 <            threadUnexpectedException(t);
1686 >        } catch (Throwable fail) {
1687 >            threadUnexpectedException(fail);
1688              return null;
1689          }
1690      }
# Line 1468 | Line 1709 | public class JSR166TestCase extends Test
1709                  shouldThrow(expectedExceptionClass.getName());
1710          }
1711      }
1712 +
1713 +    public void assertIteratorExhausted(Iterator<?> it) {
1714 +        try {
1715 +            it.next();
1716 +            shouldThrow();
1717 +        } catch (NoSuchElementException success) {}
1718 +        assertFalse(it.hasNext());
1719 +    }
1720   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines