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.144 by jsr166, Mon Sep 14 03:14:01 2015 UTC vs.
Revision 1.154 by jsr166, Sat Oct 3 19:39:16 2015 UTC

# Line 15 | Line 15 | import java.io.ObjectInputStream;
15   import java.io.ObjectOutputStream;
16   import java.lang.management.ManagementFactory;
17   import java.lang.management.ThreadInfo;
18 + import java.lang.management.ThreadMXBean;
19   import java.lang.reflect.Constructor;
20   import java.lang.reflect.Method;
21   import java.lang.reflect.Modifier;
# Line 40 | Line 41 | import java.util.concurrent.CyclicBarrie
41   import java.util.concurrent.ExecutionException;
42   import java.util.concurrent.Executors;
43   import java.util.concurrent.ExecutorService;
44 + import java.util.concurrent.ForkJoinPool;
45   import java.util.concurrent.Future;
46   import java.util.concurrent.RecursiveAction;
47   import java.util.concurrent.RecursiveTask;
# Line 185 | Line 187 | public class JSR166TestCase extends Test
187          return (regex == null) ? null : Pattern.compile(regex);
188      }
189  
190 <    protected void runTest() throws Throwable {
190 >    public void runBare() throws Throwable {
191          if (methodFilter == null
192 <            || methodFilter.matcher(toString()).find()) {
193 <            for (int i = 0; i < runsPerTest; i++) {
194 <                if (profileTests)
195 <                    runTestProfiled();
196 <                else
197 <                    super.runTest();
198 <            }
192 >            || methodFilter.matcher(toString()).find())
193 >            super.runBare();
194 >    }
195 >
196 >    protected void runTest() throws Throwable {
197 >        for (int i = 0; i < runsPerTest; i++) {
198 >            if (profileTests)
199 >                runTestProfiled();
200 >            else
201 >                super.runTest();
202          }
203      }
204  
205      protected void runTestProfiled() throws Throwable {
206 <        // Warmup run, notably to trigger all needed classloading.
207 <        super.runTest();
203 <        long t0 = System.nanoTime();
204 <        try {
206 >        for (int i = 0; i < 2; i++) {
207 >            long startTime = System.nanoTime();
208              super.runTest();
209 <        } finally {
210 <            long elapsedMillis = millisElapsedSince(t0);
211 <            if (elapsedMillis >= profileThreshold)
209 >            long elapsedMillis = millisElapsedSince(startTime);
210 >            if (elapsedMillis < profileThreshold)
211 >                break;
212 >            // Never report first run of any test; treat it as a
213 >            // warmup run, notably to trigger all needed classloading,
214 >            if (i > 0)
215                  System.out.printf("%n%s: %d%n", toString(), elapsedMillis);
216          }
217      }
# Line 513 | Line 519 | public class JSR166TestCase extends Test
519       * the same test have no effect.
520       */
521      public void threadRecordFailure(Throwable t) {
522 +        threadDump();
523          threadFailure.compareAndSet(null, t);
524      }
525  
# Line 520 | Line 527 | public class JSR166TestCase extends Test
527          setDelays();
528      }
529  
530 +    void tearDownFail(String format, Object... args) {
531 +        String msg = toString() + ": " + String.format(format, args);
532 +        System.err.println(msg);
533 +        threadDump();
534 +        throw new AssertionFailedError(msg);
535 +    }
536 +
537      /**
538       * Extra checks that get done for all test cases.
539       *
# Line 547 | Line 561 | public class JSR166TestCase extends Test
561          }
562  
563          if (Thread.interrupted())
564 <            throw new AssertionFailedError("interrupt status set in main thread");
564 >            tearDownFail("interrupt status set in main thread");
565  
566          checkForkJoinPoolThreadLeaks();
567      }
# Line 556 | Line 570 | public class JSR166TestCase extends Test
570       * Finds missing try { ... } finally { joinPool(e); }
571       */
572      void checkForkJoinPoolThreadLeaks() throws InterruptedException {
573 <        Thread[] survivors = new Thread[5];
573 >        Thread[] survivors = new Thread[7];
574          int count = Thread.enumerate(survivors);
575          for (int i = 0; i < count; i++) {
576              Thread thread = survivors[i];
# Line 564 | Line 578 | public class JSR166TestCase extends Test
578              if (name.startsWith("ForkJoinPool-")) {
579                  // give thread some time to terminate
580                  thread.join(LONG_DELAY_MS);
581 <                if (!thread.isAlive()) continue;
582 <                throw new AssertionFailedError
583 <                    (String.format("Found leaked ForkJoinPool thread test=%s thread=%s%n",
570 <                                   toString(), name));
581 >                if (thread.isAlive())
582 >                    tearDownFail("Found leaked ForkJoinPool thread thread=%s",
583 >                                 thread);
584              }
585          }
586 +
587 +        if (!ForkJoinPool.commonPool()
588 +            .awaitQuiescence(LONG_DELAY_MS, MILLISECONDS))
589 +            tearDownFail("ForkJoin common pool thread stuck");
590      }
591  
592      /**
# Line 582 | Line 599 | public class JSR166TestCase extends Test
599              fail(reason);
600          } catch (AssertionFailedError t) {
601              threadRecordFailure(t);
602 <            fail(reason);
602 >            throw t;
603          }
604      }
605  
# Line 728 | Line 745 | public class JSR166TestCase extends Test
745      }
746  
747      /**
748 +     * Allows use of try-with-resources with per-test thread pools.
749 +     */
750 +    static class PoolCloser<T extends ExecutorService>
751 +            implements AutoCloseable {
752 +        public final T pool;
753 +        public PoolCloser(T pool) { this.pool = pool; }
754 +        public void close() { joinPool(pool); }
755 +    }
756 +
757 +    /**
758       * Waits out termination of a thread pool or fails doing so.
759       */
760 <    void joinPool(ExecutorService pool) {
760 >    static void joinPool(ExecutorService pool) {
761          try {
762              pool.shutdown();
763              if (!pool.awaitTermination(2 * LONG_DELAY_MS, MILLISECONDS))
# Line 752 | Line 779 | public class JSR166TestCase extends Test
779       * necessarily individually slow because they must block.
780       */
781      void testInParallel(Action ... actions) {
782 <        ExecutorService pool = Executors.newCachedThreadPool();
783 <        try {
782 >        try (PoolCloser<ExecutorService> poolCloser
783 >             = new PoolCloser<>(Executors.newCachedThreadPool())) {
784 >            ExecutorService pool = poolCloser.pool;
785              ArrayList<Future<?>> futures = new ArrayList<>(actions.length);
786              for (final Action action : actions)
787                  futures.add(pool.submit(new CheckedRunnable() {
# Line 766 | Line 794 | public class JSR166TestCase extends Test
794                  } catch (Exception ex) {
795                      threadUnexpectedException(ex);
796                  }
769 –        } finally {
770 –            joinPool(pool);
797          }
798      }
799  
800      /**
801       * A debugging tool to print all stack traces, as jstack does.
802 +     * Uninteresting threads are filtered out.
803       */
804 <    static void printAllStackTraces() {
805 <        for (ThreadInfo info :
806 <                 ManagementFactory.getThreadMXBean()
807 <                 .dumpAllThreads(true, true))
804 >    static void threadDump() {
805 >        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
806 >        System.err.println("------ stacktrace dump start ------");
807 >        for (ThreadInfo info : threadMXBean.dumpAllThreads(true, true)) {
808 >            String name = info.getThreadName();
809 >            if ("Signal Dispatcher".equals(name))
810 >                continue;
811 >            if ("Reference Handler".equals(name)
812 >                && info.getLockName().startsWith("java.lang.ref.Reference$Lock"))
813 >                continue;
814 >            if ("Finalizer".equals(name)
815 >                && info.getLockName().startsWith("java.lang.ref.ReferenceQueue$Lock"))
816 >                continue;
817              System.err.print(info);
818 +        }
819 +        System.err.println("------ stacktrace dump end ------");
820      }
821  
822      /**
# Line 1239 | Line 1277 | public class JSR166TestCase extends Test
1277              }};
1278      }
1279  
1280 +    public Runnable countDowner(final CountDownLatch latch) {
1281 +        return new CheckedRunnable() {
1282 +            public void realRun() throws InterruptedException {
1283 +                latch.countDown();
1284 +            }};
1285 +    }
1286 +
1287      public Runnable awaiter(final CountDownLatch latch) {
1288          return new CheckedRunnable() {
1289              public void realRun() throws InterruptedException {

Diff Legend

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