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.156 by jsr166, Sat Oct 3 21:09:42 2015 UTC vs.
Revision 1.160 by jsr166, Sun Oct 4 00:59:09 2015 UTC

# Line 191 | Line 191 | public class JSR166TestCase extends Test
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(10); }
197 >                try { MINUTES.sleep(timeoutMinutes); }
198                  catch (InterruptedException unexpected) { break; }
199                  if (lastTestCase == currentTestCase) {
200                      System.err.println
# Line 539 | Line 541 | public class JSR166TestCase extends Test
541       * the same test have no effect.
542       */
543      public void threadRecordFailure(Throwable t) {
544 +        System.err.println(t);
545          dumpTestThreads();
546          threadFailure.compareAndSet(null, t);
547      }
# Line 767 | Line 770 | public class JSR166TestCase extends Test
770      /**
771       * Allows use of try-with-resources with per-test thread pools.
772       */
773 <    static class PoolCloser<T extends ExecutorService>
774 <            implements AutoCloseable {
775 <        public final T pool;
773 <        public PoolCloser(T pool) { this.pool = pool; }
773 >    class PoolCleaner implements AutoCloseable {
774 >        private final ExecutorService pool;
775 >        public PoolCleaner(ExecutorService pool) { this.pool = pool; }
776          public void close() { joinPool(pool); }
777      }
778  
779 +    PoolCleaner cleaner(ExecutorService pool) {
780 +        return new PoolCleaner(pool);
781 +    }
782 +
783      /**
784       * Waits out termination of a thread pool or fails doing so.
785       */
786 <    static void joinPool(ExecutorService pool) {
786 >    void joinPool(ExecutorService pool) {
787          try {
788              pool.shutdown();
789 <            if (!pool.awaitTermination(2 * LONG_DELAY_MS, MILLISECONDS))
790 <                fail("ExecutorService " + pool +
791 <                     " did not terminate in a timely manner");
789 >            if (!pool.awaitTermination(2 * LONG_DELAY_MS, MILLISECONDS)) {
790 >                try {
791 >                    threadFail("ExecutorService " + pool +
792 >                               " did not terminate in a timely manner");
793 >                } finally {
794 >                    // last resort, for the benefit of subsequent tests
795 >                    pool.shutdownNow();
796 >                    pool.awaitTermination(SMALL_DELAY_MS, MILLISECONDS);
797 >                }
798 >            }
799          } catch (SecurityException ok) {
800              // Allowed in case test doesn't have privs
801          } catch (InterruptedException fail) {
802 <            fail("Unexpected InterruptedException");
802 >            threadFail("Unexpected InterruptedException");
803          }
804      }
805  
# Line 799 | Line 812 | public class JSR166TestCase extends Test
812       * necessarily individually slow because they must block.
813       */
814      void testInParallel(Action ... actions) {
815 <        try (PoolCloser<ExecutorService> poolCloser
816 <             = new PoolCloser<>(Executors.newCachedThreadPool())) {
804 <            ExecutorService pool = poolCloser.pool;
815 >        ExecutorService pool = Executors.newCachedThreadPool();
816 >        try (PoolCleaner cleaner = cleaner(pool)) {
817              ArrayList<Future<?>> futures = new ArrayList<>(actions.length);
818              for (final Action action : actions)
819                  futures.add(pool.submit(new CheckedRunnable() {
# Line 858 | Line 870 | public class JSR166TestCase extends Test
870              delay(millis);
871              assertTrue(thread.isAlive());
872          } catch (InterruptedException fail) {
873 <            fail("Unexpected InterruptedException");
873 >            threadFail("Unexpected InterruptedException");
874          }
875      }
876  
# Line 880 | Line 892 | public class JSR166TestCase extends Test
892              for (Thread thread : threads)
893                  assertTrue(thread.isAlive());
894          } catch (InterruptedException fail) {
895 <            fail("Unexpected InterruptedException");
895 >            threadFail("Unexpected InterruptedException");
896          }
897      }
898  

Diff Legend

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