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.183 by jsr166, Sat Jan 23 20:15:28 2016 UTC vs.
Revision 1.198 by jsr166, Wed Jul 27 17:16:23 2016 UTC

# Line 9 | Line 9
9   /*
10   * @test
11   * @summary JSR-166 tck tests
12 + * @modules java.management
13   * @build *
14   * @run junit/othervm/timeout=1000 -Djsr166.testImplementationDetails=true JSR166TestCase
15 + * @run junit/othervm/timeout=1000 -Djava.util.concurrent.ForkJoinPool.common.parallelism=0 -Djsr166.testImplementationDetails=true JSR166TestCase
16 + * @run junit/othervm/timeout=1000 -Djava.util.concurrent.ForkJoinPool.common.parallelism=1 -Djava.util.secureRandomSeed=true JSR166TestCase
17   */
18  
19   import static java.util.concurrent.TimeUnit.MILLISECONDS;
# Line 57 | Line 60 | import java.util.concurrent.RecursiveAct
60   import java.util.concurrent.RecursiveTask;
61   import java.util.concurrent.RejectedExecutionHandler;
62   import java.util.concurrent.Semaphore;
63 + import java.util.concurrent.SynchronousQueue;
64   import java.util.concurrent.ThreadFactory;
65   import java.util.concurrent.ThreadPoolExecutor;
66   import java.util.concurrent.TimeoutException;
67 + import java.util.concurrent.atomic.AtomicBoolean;
68   import java.util.concurrent.atomic.AtomicReference;
69   import java.util.regex.Matcher;
70   import java.util.regex.Pattern;
# Line 183 | Line 188 | public class JSR166TestCase extends Test
188          Integer.getInteger("jsr166.suiteRuns", 1);
189  
190      /**
191 <     * The scaling factor to apply to standard delays used in tests.
191 >     * Returns the value of the system property, or NaN if not defined.
192       */
193 <    private static final int delayFactor =
194 <        Integer.getInteger("jsr166.delay.factor", 1);
193 >    private static float systemPropertyValue(String name) {
194 >        String floatString = System.getProperty(name);
195 >        if (floatString == null)
196 >            return Float.NaN;
197 >        try {
198 >            return Float.parseFloat(floatString);
199 >        } catch (NumberFormatException ex) {
200 >            throw new IllegalArgumentException(
201 >                String.format("Bad float value in system property %s=%s",
202 >                              name, floatString));
203 >        }
204 >    }
205 >
206 >    /**
207 >     * The scaling factor to apply to standard delays used in tests.
208 >     * May be initialized from any of:
209 >     * - the "jsr166.delay.factor" system property
210 >     * - the "test.timeout.factor" system property (as used by jtreg)
211 >     *   See: http://openjdk.java.net/jtreg/tag-spec.html
212 >     * - hard-coded fuzz factor when using a known slowpoke VM
213 >     */
214 >    private static final float delayFactor = delayFactor();
215 >
216 >    private static float delayFactor() {
217 >        float x;
218 >        if (!Float.isNaN(x = systemPropertyValue("jsr166.delay.factor")))
219 >            return x;
220 >        if (!Float.isNaN(x = systemPropertyValue("test.timeout.factor")))
221 >            return x;
222 >        String prop = System.getProperty("java.vm.version");
223 >        if (prop != null && prop.matches(".*debug.*"))
224 >            return 4.0f; // How much slower is fastdebug than product?!
225 >        return 1.0f;
226 >    }
227  
228      public JSR166TestCase() { super(); }
229      public JSR166TestCase(String name) { super(name); }
# Line 477 | Line 514 | public class JSR166TestCase extends Test
514                  "StampedLockTest",
515                  "SubmissionPublisherTest",
516                  "ThreadLocalRandom8Test",
517 +                "TimeUnit8Test",
518              };
519              addNamedTestClasses(suite, java8TestClassNames);
520          }
# Line 484 | Line 522 | public class JSR166TestCase extends Test
522          // Java9+ test classes
523          if (atLeastJava9()) {
524              String[] java9TestClassNames = {
525 <                // Currently empty, but expecting varhandle tests
525 >                "AtomicBoolean9Test",
526 >                "AtomicInteger9Test",
527 >                "AtomicIntegerArray9Test",
528 >                "AtomicLong9Test",
529 >                "AtomicLongArray9Test",
530 >                "AtomicReference9Test",
531 >                "AtomicReferenceArray9Test",
532 >                "ExecutorCompletionService9Test",
533              };
534              addNamedTestClasses(suite, java9TestClassNames);
535          }
# Line 562 | Line 607 | public class JSR166TestCase extends Test
607  
608      /**
609       * Returns the shortest timed delay. This can be scaled up for
610 <     * slow machines using the jsr166.delay.factor system property.
610 >     * slow machines using the jsr166.delay.factor system property,
611 >     * or via jtreg's -timeoutFactor: flag.
612 >     * http://openjdk.java.net/jtreg/command-help.html
613       */
614      protected long getShortDelay() {
615 <        return 50 * delayFactor;
615 >        return (long) (50 * delayFactor);
616      }
617  
618      /**
# Line 878 | Line 925 | public class JSR166TestCase extends Test
925          }};
926      }
927  
928 +    PoolCleaner cleaner(ExecutorService pool, AtomicBoolean flag) {
929 +        return new PoolCleanerWithReleaser(pool, releaser(flag));
930 +    }
931 +
932 +    Runnable releaser(final AtomicBoolean flag) {
933 +        return new Runnable() { public void run() { flag.set(true); }};
934 +    }
935 +
936      /**
937       * Waits out termination of a thread pool or fails doing so.
938       */
# Line 901 | Line 956 | public class JSR166TestCase extends Test
956          }
957      }
958  
959 <    /** Like Runnable, but with the freedom to throw anything */
959 >    /**
960 >     * Like Runnable, but with the freedom to throw anything.
961 >     * junit folks had the same idea:
962 >     * http://junit.org/junit5/docs/snapshot/api/org/junit/gen5/api/Executable.html
963 >     */
964      interface Action { public void run() throws Throwable; }
965  
966      /**
# Line 932 | Line 991 | public class JSR166TestCase extends Test
991       * Uninteresting threads are filtered out.
992       */
993      static void dumpTestThreads() {
994 +        SecurityManager sm = System.getSecurityManager();
995 +        if (sm != null) {
996 +            try {
997 +                System.setSecurityManager(null);
998 +            } catch (SecurityException giveUp) {
999 +                return;
1000 +            }
1001 +        }
1002 +
1003          ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
1004          System.err.println("------ stacktrace dump start ------");
1005          for (ThreadInfo info : threadMXBean.dumpAllThreads(true, true)) {
# Line 949 | Line 1017 | public class JSR166TestCase extends Test
1017              System.err.print(info);
1018          }
1019          System.err.println("------ stacktrace dump end ------");
1020 +
1021 +        if (sm != null) System.setSecurityManager(sm);
1022      }
1023  
1024      /**
# Line 1434 | Line 1504 | public class JSR166TestCase extends Test
1504          return new LatchAwaiter(latch);
1505      }
1506  
1507 <    public void await(CountDownLatch latch) {
1507 >    public void await(CountDownLatch latch, long timeoutMillis) {
1508          try {
1509 <            if (!latch.await(LONG_DELAY_MS, MILLISECONDS))
1509 >            if (!latch.await(timeoutMillis, MILLISECONDS))
1510                  fail("timed out waiting for CountDownLatch for "
1511 <                     + (LONG_DELAY_MS/1000) + " sec");
1511 >                     + (timeoutMillis/1000) + " sec");
1512          } catch (Throwable fail) {
1513              threadUnexpectedException(fail);
1514          }
1515      }
1516  
1517 +    public void await(CountDownLatch latch) {
1518 +        await(latch, LONG_DELAY_MS);
1519 +    }
1520 +
1521      public void await(Semaphore semaphore) {
1522          try {
1523              if (!semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS))
# Line 1784 | Line 1858 | public class JSR166TestCase extends Test
1858          } catch (NoSuchElementException success) {}
1859          assertFalse(it.hasNext());
1860      }
1861 +
1862 +    public <T> Callable<T> callableThrowing(final Exception ex) {
1863 +        return new Callable<T>() { public T call() throws Exception { throw ex; }};
1864 +    }
1865 +
1866 +    public Runnable runnableThrowing(final RuntimeException ex) {
1867 +        return new Runnable() { public void run() { throw ex; }};
1868 +    }
1869 +
1870 +    /** A reusable thread pool to be shared by tests. */
1871 +    static final ExecutorService cachedThreadPool =
1872 +        new ThreadPoolExecutor(0, Integer.MAX_VALUE,
1873 +                               1000L, MILLISECONDS,
1874 +                               new SynchronousQueue<Runnable>());
1875 +
1876   }

Diff Legend

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