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.183 by jsr166, Sat Jan 23 20:15:28 2016 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 + /*
10 + * @test
11 + * @summary JSR-166 tck tests
12 + * @build *
13 + * @run junit/othervm/timeout=1000 -Djsr166.testImplementationDetails=true JSR166TestCase
14 + */
15 +
16   import static java.util.concurrent.TimeUnit.MILLISECONDS;
17   import static java.util.concurrent.TimeUnit.MINUTES;
18   import static java.util.concurrent.TimeUnit.NANOSECONDS;
# Line 20 | Line 27 | import java.lang.management.ThreadMXBean
27   import java.lang.reflect.Constructor;
28   import java.lang.reflect.Method;
29   import java.lang.reflect.Modifier;
30 + import java.nio.file.Files;
31 + import java.nio.file.Paths;
32   import java.security.CodeSource;
33   import java.security.Permission;
34   import java.security.PermissionCollection;
# Line 52 | Line 61 | import java.util.concurrent.ThreadFactor
61   import java.util.concurrent.ThreadPoolExecutor;
62   import java.util.concurrent.TimeoutException;
63   import java.util.concurrent.atomic.AtomicReference;
64 + import java.util.regex.Matcher;
65   import java.util.regex.Pattern;
66  
67   import junit.framework.AssertionFailedError;
# Line 109 | Line 119 | import junit.framework.TestSuite;
119   * methods as there are exceptions the method can throw. Sometimes
120   * there are multiple tests per JSR166 method when the different
121   * "normal" behaviors differ significantly. And sometimes testcases
122 < * cover multiple methods when they cannot be tested in
113 < * isolation.
122 > * cover multiple methods when they cannot be tested in isolation.
123   *
124   * <li>The documentation style for testcases is to provide as javadoc
125   * a simple sentence or two describing the property that the testcase
# Line 173 | Line 182 | public class JSR166TestCase extends Test
182      private static final int suiteRuns =
183          Integer.getInteger("jsr166.suiteRuns", 1);
184  
185 +    /**
186 +     * The scaling factor to apply to standard delays used in tests.
187 +     */
188 +    private static final int delayFactor =
189 +        Integer.getInteger("jsr166.delay.factor", 1);
190 +
191      public JSR166TestCase() { super(); }
192      public JSR166TestCase(String name) { super(name); }
193  
# Line 188 | Line 203 | public class JSR166TestCase extends Test
203          return (regex == null) ? null : Pattern.compile(regex);
204      }
205  
206 +    // Instrumentation to debug very rare, but very annoying hung test runs.
207      static volatile TestCase currentTestCase;
208 +    // static volatile int currentRun = 0;
209      static {
210          Runnable checkForWedgedTest = new Runnable() { public void run() {
211 +            // Avoid spurious reports with enormous runsPerTest.
212 +            // A single test case run should never take more than 1 second.
213 +            // But let's cap it at the high end too ...
214 +            final int timeoutMinutes =
215 +                Math.min(15, Math.max(runsPerTest / 60, 1));
216              for (TestCase lastTestCase = currentTestCase;;) {
217 <                try { MINUTES.sleep(10); }
217 >                try { MINUTES.sleep(timeoutMinutes); }
218                  catch (InterruptedException unexpected) { break; }
219                  if (lastTestCase == currentTestCase) {
220 <                    System.err.println
221 <                        ("Looks like we're stuck running test: "
222 <                         + lastTestCase);
220 >                    System.err.printf(
221 >                        "Looks like we're stuck running test: %s%n",
222 >                        lastTestCase);
223 > //                     System.err.printf(
224 > //                         "Looks like we're stuck running test: %s (%d/%d)%n",
225 > //                         lastTestCase, currentRun, runsPerTest);
226 > //                     System.err.println("availableProcessors=" +
227 > //                         Runtime.getRuntime().availableProcessors());
228 > //                     System.err.printf("cpu model = %s%n", cpuModel());
229                      dumpTestThreads();
230 +                    // one stack dump is probably enough; more would be spam
231 +                    break;
232                  }
233                  lastTestCase = currentTestCase;
234              }}};
# Line 207 | Line 237 | public class JSR166TestCase extends Test
237          thread.start();
238      }
239  
240 + //     public static String cpuModel() {
241 + //         try {
242 + //             Matcher matcher = Pattern.compile("model name\\s*: (.*)")
243 + //                 .matcher(new String(
244 + //                      Files.readAllBytes(Paths.get("/proc/cpuinfo")), "UTF-8"));
245 + //             matcher.find();
246 + //             return matcher.group(1);
247 + //         } catch (Exception ex) { return null; }
248 + //     }
249 +
250      public void runBare() throws Throwable {
251          currentTestCase = this;
252          if (methodFilter == null
# Line 216 | Line 256 | public class JSR166TestCase extends Test
256  
257      protected void runTest() throws Throwable {
258          for (int i = 0; i < runsPerTest; i++) {
259 +            // currentRun = i;
260              if (profileTests)
261                  runTestProfiled();
262              else
# Line 244 | Line 285 | public class JSR166TestCase extends Test
285          main(suite(), args);
286      }
287  
288 +    static class PithyResultPrinter extends junit.textui.ResultPrinter {
289 +        PithyResultPrinter(java.io.PrintStream writer) { super(writer); }
290 +        long runTime;
291 +        public void startTest(Test test) {}
292 +        protected void printHeader(long runTime) {
293 +            this.runTime = runTime; // defer printing for later
294 +        }
295 +        protected void printFooter(TestResult result) {
296 +            if (result.wasSuccessful()) {
297 +                getWriter().println("OK (" + result.runCount() + " tests)"
298 +                    + "  Time: " + elapsedTimeAsString(runTime));
299 +            } else {
300 +                getWriter().println("Time: " + elapsedTimeAsString(runTime));
301 +                super.printFooter(result);
302 +            }
303 +        }
304 +    }
305 +
306 +    /**
307 +     * Returns a TestRunner that doesn't bother with unnecessary
308 +     * fluff, like printing a "." for each test case.
309 +     */
310 +    static junit.textui.TestRunner newPithyTestRunner() {
311 +        junit.textui.TestRunner runner = new junit.textui.TestRunner();
312 +        runner.setPrinter(new PithyResultPrinter(System.out));
313 +        return runner;
314 +    }
315 +
316      /**
317       * Runs all unit tests in the given test suite.
318       * Actual behavior influenced by jsr166.* system properties.
# Line 255 | Line 324 | public class JSR166TestCase extends Test
324              System.setSecurityManager(new SecurityManager());
325          }
326          for (int i = 0; i < suiteRuns; i++) {
327 <            TestResult result = junit.textui.TestRunner.run(suite);
327 >            TestResult result = newPithyTestRunner().doRun(suite);
328              if (!result.wasSuccessful())
329                  System.exit(1);
330              System.gc();
# Line 492 | Line 561 | public class JSR166TestCase extends Test
561      public static long LONG_DELAY_MS;
562  
563      /**
564 <     * Returns the shortest timed delay. This could
565 <     * be reimplemented to use for example a Property.
564 >     * Returns the shortest timed delay. This can be scaled up for
565 >     * slow machines using the jsr166.delay.factor system property.
566       */
567      protected long getShortDelay() {
568 <        return 50;
568 >        return 50 * delayFactor;
569      }
570  
571      /**
# Line 539 | Line 608 | public class JSR166TestCase extends Test
608       * the same test have no effect.
609       */
610      public void threadRecordFailure(Throwable t) {
611 +        System.err.println(t);
612          dumpTestThreads();
613          threadFailure.compareAndSet(null, t);
614      }
# Line 587 | Line 657 | public class JSR166TestCase extends Test
657      }
658  
659      /**
660 <     * Finds missing try { ... } finally { joinPool(e); }
660 >     * Finds missing PoolCleaners
661       */
662      void checkForkJoinPoolThreadLeaks() throws InterruptedException {
663          Thread[] survivors = new Thread[7];
# Line 746 | Line 816 | public class JSR166TestCase extends Test
816      /**
817       * Delays, via Thread.sleep, for the given millisecond delay, but
818       * if the sleep is shorter than specified, may re-sleep or yield
819 <     * until time elapses.
819 >     * until time elapses.  Ensures that the given time, as measured
820 >     * by System.nanoTime(), has elapsed.
821       */
822      static void delay(long millis) throws InterruptedException {
823 <        long startTime = System.nanoTime();
824 <        long ns = millis * 1000 * 1000;
825 <        for (;;) {
823 >        long nanos = millis * (1000 * 1000);
824 >        final long wakeupTime = System.nanoTime() + nanos;
825 >        do {
826              if (millis > 0L)
827                  Thread.sleep(millis);
828              else // too short to sleep
829                  Thread.yield();
830 <            long d = ns - (System.nanoTime() - startTime);
831 <            if (d > 0L)
832 <                millis = d / (1000 * 1000);
762 <            else
763 <                break;
764 <        }
830 >            nanos = wakeupTime - System.nanoTime();
831 >            millis = nanos / (1000 * 1000);
832 >        } while (nanos >= 0L);
833      }
834  
835      /**
836       * Allows use of try-with-resources with per-test thread pools.
837       */
838 <    static class PoolCloser<T extends ExecutorService>
839 <            implements AutoCloseable {
840 <        public final T pool;
773 <        public PoolCloser(T pool) { this.pool = pool; }
838 >    class PoolCleaner implements AutoCloseable {
839 >        private final ExecutorService pool;
840 >        public PoolCleaner(ExecutorService pool) { this.pool = pool; }
841          public void close() { joinPool(pool); }
842      }
843  
844      /**
845 +     * An extension of PoolCleaner that has an action to release the pool.
846 +     */
847 +    class PoolCleanerWithReleaser extends PoolCleaner {
848 +        private final Runnable releaser;
849 +        public PoolCleanerWithReleaser(ExecutorService pool, Runnable releaser) {
850 +            super(pool);
851 +            this.releaser = releaser;
852 +        }
853 +        public void close() {
854 +            try {
855 +                releaser.run();
856 +            } finally {
857 +                super.close();
858 +            }
859 +        }
860 +    }
861 +
862 +    PoolCleaner cleaner(ExecutorService pool) {
863 +        return new PoolCleaner(pool);
864 +    }
865 +
866 +    PoolCleaner cleaner(ExecutorService pool, Runnable releaser) {
867 +        return new PoolCleanerWithReleaser(pool, releaser);
868 +    }
869 +
870 +    PoolCleaner cleaner(ExecutorService pool, CountDownLatch latch) {
871 +        return new PoolCleanerWithReleaser(pool, releaser(latch));
872 +    }
873 +
874 +    Runnable releaser(final CountDownLatch latch) {
875 +        return new Runnable() { public void run() {
876 +            do { latch.countDown(); }
877 +            while (latch.getCount() > 0);
878 +        }};
879 +    }
880 +
881 +    /**
882       * Waits out termination of a thread pool or fails doing so.
883       */
884 <    static void joinPool(ExecutorService pool) {
884 >    void joinPool(ExecutorService pool) {
885          try {
886              pool.shutdown();
887 <            if (!pool.awaitTermination(2 * LONG_DELAY_MS, MILLISECONDS))
888 <                fail("ExecutorService " + pool +
889 <                     " did not terminate in a timely manner");
887 >            if (!pool.awaitTermination(2 * LONG_DELAY_MS, MILLISECONDS)) {
888 >                try {
889 >                    threadFail("ExecutorService " + pool +
890 >                               " did not terminate in a timely manner");
891 >                } finally {
892 >                    // last resort, for the benefit of subsequent tests
893 >                    pool.shutdownNow();
894 >                    pool.awaitTermination(MEDIUM_DELAY_MS, MILLISECONDS);
895 >                }
896 >            }
897          } catch (SecurityException ok) {
898              // Allowed in case test doesn't have privs
899          } catch (InterruptedException fail) {
900 <            fail("Unexpected InterruptedException");
900 >            threadFail("Unexpected InterruptedException");
901          }
902      }
903  
# Line 799 | Line 910 | public class JSR166TestCase extends Test
910       * necessarily individually slow because they must block.
911       */
912      void testInParallel(Action ... actions) {
913 <        try (PoolCloser<ExecutorService> poolCloser
914 <             = new PoolCloser<>(Executors.newCachedThreadPool())) {
804 <            ExecutorService pool = poolCloser.pool;
913 >        ExecutorService pool = Executors.newCachedThreadPool();
914 >        try (PoolCleaner cleaner = cleaner(pool)) {
915              ArrayList<Future<?>> futures = new ArrayList<>(actions.length);
916              for (final Action action : actions)
917                  futures.add(pool.submit(new CheckedRunnable() {
# Line 858 | Line 968 | public class JSR166TestCase extends Test
968              delay(millis);
969              assertTrue(thread.isAlive());
970          } catch (InterruptedException fail) {
971 <            fail("Unexpected InterruptedException");
971 >            threadFail("Unexpected InterruptedException");
972          }
973      }
974  
# Line 880 | Line 990 | public class JSR166TestCase extends Test
990              for (Thread thread : threads)
991                  assertTrue(thread.isAlive());
992          } catch (InterruptedException fail) {
993 <            fail("Unexpected InterruptedException");
993 >            threadFail("Unexpected InterruptedException");
994          }
995      }
996  
# Line 1158 | Line 1268 | public class JSR166TestCase extends Test
1268          } finally {
1269              if (t.getState() != Thread.State.TERMINATED) {
1270                  t.interrupt();
1271 <                fail("Test timed out");
1271 >                threadFail("timed out waiting for thread to terminate");
1272              }
1273          }
1274      }
# Line 1306 | Line 1416 | public class JSR166TestCase extends Test
1416              }};
1417      }
1418  
1419 <    public Runnable awaiter(final CountDownLatch latch) {
1420 <        return new CheckedRunnable() {
1421 <            public void realRun() throws InterruptedException {
1422 <                await(latch);
1423 <            }};
1419 >    class LatchAwaiter extends CheckedRunnable {
1420 >        static final int NEW = 0;
1421 >        static final int RUNNING = 1;
1422 >        static final int DONE = 2;
1423 >        final CountDownLatch latch;
1424 >        int state = NEW;
1425 >        LatchAwaiter(CountDownLatch latch) { this.latch = latch; }
1426 >        public void realRun() throws InterruptedException {
1427 >            state = 1;
1428 >            await(latch);
1429 >            state = 2;
1430 >        }
1431 >    }
1432 >
1433 >    public LatchAwaiter awaiter(CountDownLatch latch) {
1434 >        return new LatchAwaiter(latch);
1435      }
1436  
1437      public void await(CountDownLatch latch) {
1438          try {
1439 <            assertTrue(latch.await(LONG_DELAY_MS, MILLISECONDS));
1439 >            if (!latch.await(LONG_DELAY_MS, MILLISECONDS))
1440 >                fail("timed out waiting for CountDownLatch for "
1441 >                     + (LONG_DELAY_MS/1000) + " sec");
1442          } catch (Throwable fail) {
1443              threadUnexpectedException(fail);
1444          }
# Line 1323 | Line 1446 | public class JSR166TestCase extends Test
1446  
1447      public void await(Semaphore semaphore) {
1448          try {
1449 <            assertTrue(semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS));
1449 >            if (!semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS))
1450 >                fail("timed out waiting for Semaphore for "
1451 >                     + (LONG_DELAY_MS/1000) + " sec");
1452          } catch (Throwable fail) {
1453              threadUnexpectedException(fail);
1454          }

Diff Legend

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