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.198 by jsr166, Wed Jul 27 17:16:23 2016 UTC vs.
Revision 1.218 by jsr166, Sun Jan 29 20:19:00 2017 UTC

# Line 8 | Line 8
8  
9   /*
10   * @test
11 < * @summary JSR-166 tck tests
11 > * @summary JSR-166 tck tests (conformance testing mode)
12 > * @build *
13   * @modules java.management
14 + * @run junit/othervm/timeout=1000 JSR166TestCase
15 + */
16 +
17 + /*
18 + * @test
19 + * @summary JSR-166 tck tests (whitebox tests allowed)
20   * @build *
21 < * @run junit/othervm/timeout=1000 -Djsr166.testImplementationDetails=true JSR166TestCase
22 < * @run junit/othervm/timeout=1000 -Djava.util.concurrent.ForkJoinPool.common.parallelism=0 -Djsr166.testImplementationDetails=true JSR166TestCase
23 < * @run junit/othervm/timeout=1000 -Djava.util.concurrent.ForkJoinPool.common.parallelism=1 -Djava.util.secureRandomSeed=true JSR166TestCase
21 > * @modules java.base/java.util.concurrent:open
22 > *          java.base/java.lang:open
23 > *          java.management
24 > * @run junit/othervm/timeout=1000
25 > *      -Djsr166.testImplementationDetails=true
26 > *      JSR166TestCase
27 > * @run junit/othervm/timeout=1000
28 > *      -Djsr166.testImplementationDetails=true
29 > *      -Djava.util.concurrent.ForkJoinPool.common.parallelism=0
30 > *      JSR166TestCase
31 > * @run junit/othervm/timeout=1000
32 > *      -Djsr166.testImplementationDetails=true
33 > *      -Djava.util.concurrent.ForkJoinPool.common.parallelism=1
34 > *      -Djava.util.secureRandomSeed=true
35 > *      JSR166TestCase
36 > * @run junit/othervm/timeout=1000/policy=tck.policy
37 > *      -Djsr166.testImplementationDetails=true
38 > *      JSR166TestCase
39   */
40  
41   import static java.util.concurrent.TimeUnit.MILLISECONDS;
# Line 41 | Line 63 | import java.security.ProtectionDomain;
63   import java.security.SecurityPermission;
64   import java.util.ArrayList;
65   import java.util.Arrays;
66 + import java.util.Collection;
67 + import java.util.Collections;
68   import java.util.Date;
69   import java.util.Enumeration;
70   import java.util.Iterator;
# Line 62 | Line 86 | import java.util.concurrent.RejectedExec
86   import java.util.concurrent.Semaphore;
87   import java.util.concurrent.SynchronousQueue;
88   import java.util.concurrent.ThreadFactory;
89 + import java.util.concurrent.ThreadLocalRandom;
90   import java.util.concurrent.ThreadPoolExecutor;
91   import java.util.concurrent.TimeoutException;
92   import java.util.concurrent.atomic.AtomicBoolean;
# Line 445 | Line 470 | public class JSR166TestCase extends Test
470              AbstractQueuedLongSynchronizerTest.suite(),
471              ArrayBlockingQueueTest.suite(),
472              ArrayDequeTest.suite(),
473 +            ArrayListTest.suite(),
474              AtomicBooleanTest.suite(),
475              AtomicIntegerArrayTest.suite(),
476              AtomicIntegerFieldUpdaterTest.suite(),
# Line 467 | Line 493 | public class JSR166TestCase extends Test
493              CopyOnWriteArrayListTest.suite(),
494              CopyOnWriteArraySetTest.suite(),
495              CountDownLatchTest.suite(),
496 +            CountedCompleterTest.suite(),
497              CyclicBarrierTest.suite(),
498              DelayQueueTest.suite(),
499              EntryTest.suite(),
# Line 495 | Line 522 | public class JSR166TestCase extends Test
522              TreeMapTest.suite(),
523              TreeSetTest.suite(),
524              TreeSubMapTest.suite(),
525 <            TreeSubSetTest.suite());
525 >            TreeSubSetTest.suite(),
526 >            VectorTest.suite());
527  
528          // Java8+ test classes
529          if (atLeastJava8()) {
530              String[] java8TestClassNames = {
531 +                "ArrayDeque8Test",
532                  "Atomic8Test",
533                  "CompletableFutureTest",
534                  "ConcurrentHashMap8Test",
535 <                "CountedCompleterTest",
535 >                "CountedCompleter8Test",
536                  "DoubleAccumulatorTest",
537                  "DoubleAdderTest",
538                  "ForkJoinPool8Test",
539                  "ForkJoinTask8Test",
540 +                "LinkedBlockingDeque8Test",
541 +                "LinkedBlockingQueue8Test",
542                  "LongAccumulatorTest",
543                  "LongAdderTest",
544                  "SplittableRandomTest",
# Line 530 | Line 561 | public class JSR166TestCase extends Test
561                  "AtomicReference9Test",
562                  "AtomicReferenceArray9Test",
563                  "ExecutorCompletionService9Test",
564 +                "ForkJoinPool9Test",
565              };
566              addNamedTestClasses(suite, java9TestClassNames);
567          }
# Line 540 | Line 572 | public class JSR166TestCase extends Test
572      /** Returns list of junit-style test method names in given class. */
573      public static ArrayList<String> testMethodNames(Class<?> testClass) {
574          Method[] methods = testClass.getDeclaredMethods();
575 <        ArrayList<String> names = new ArrayList<String>(methods.length);
575 >        ArrayList<String> names = new ArrayList<>(methods.length);
576          for (Method method : methods) {
577              if (method.getName().startsWith("test")
578                  && Modifier.isPublic(method.getModifiers())
# Line 646 | Line 678 | public class JSR166TestCase extends Test
678       * The first exception encountered if any threadAssertXXX method fails.
679       */
680      private final AtomicReference<Throwable> threadFailure
681 <        = new AtomicReference<Throwable>(null);
681 >        = new AtomicReference<>(null);
682  
683      /**
684       * Records an exception so that it can be rethrown later in the test
# Line 1003 | Line 1035 | public class JSR166TestCase extends Test
1035          ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
1036          System.err.println("------ stacktrace dump start ------");
1037          for (ThreadInfo info : threadMXBean.dumpAllThreads(true, true)) {
1038 <            String name = info.getThreadName();
1038 >            final String name = info.getThreadName();
1039 >            String lockName;
1040              if ("Signal Dispatcher".equals(name))
1041                  continue;
1042              if ("Reference Handler".equals(name)
1043 <                && info.getLockName().startsWith("java.lang.ref.Reference$Lock"))
1043 >                && (lockName = info.getLockName()) != null
1044 >                && lockName.startsWith("java.lang.ref.Reference$Lock"))
1045                  continue;
1046              if ("Finalizer".equals(name)
1047 <                && info.getLockName().startsWith("java.lang.ref.ReferenceQueue$Lock"))
1047 >                && (lockName = info.getLockName()) != null
1048 >                && lockName.startsWith("java.lang.ref.ReferenceQueue$Lock"))
1049                  continue;
1050              if ("checkForWedgedTest".equals(name))
1051                  continue;
# Line 1205 | Line 1240 | public class JSR166TestCase extends Test
1240          }
1241          public void refresh() {}
1242          public String toString() {
1243 <            List<Permission> ps = new ArrayList<Permission>();
1243 >            List<Permission> ps = new ArrayList<>();
1244              for (Enumeration<Permission> e = perms.elements(); e.hasMoreElements();)
1245                  ps.add(e.nextElement());
1246              return "AdjustablePolicy with permissions " + ps;
# Line 1235 | Line 1270 | public class JSR166TestCase extends Test
1270       * Sleeps until the given time has elapsed.
1271       * Throws AssertionFailedError if interrupted.
1272       */
1273 <    void sleep(long millis) {
1273 >    static void sleep(long millis) {
1274          try {
1275              delay(millis);
1276          } catch (InterruptedException fail) {
# Line 1251 | Line 1286 | public class JSR166TestCase extends Test
1286       * thread to enter a wait state: BLOCKED, WAITING, or TIMED_WAITING.
1287       */
1288      void waitForThreadToEnterWaitState(Thread thread, long timeoutMillis) {
1289 <        long startTime = System.nanoTime();
1289 >        long startTime = 0L;
1290          for (;;) {
1291              Thread.State s = thread.getState();
1292              if (s == Thread.State.BLOCKED ||
# Line 1260 | Line 1295 | public class JSR166TestCase extends Test
1295                  return;
1296              else if (s == Thread.State.TERMINATED)
1297                  fail("Unexpected thread termination");
1298 +            else if (startTime == 0L)
1299 +                startTime = System.nanoTime();
1300              else if (millisElapsedSince(startTime) > timeoutMillis) {
1301                  threadAssertTrue(thread.isAlive());
1302                  return;
# Line 1752 | Line 1789 | public class JSR166TestCase extends Test
1789       * A CyclicBarrier that uses timed await and fails with
1790       * AssertionFailedErrors instead of throwing checked exceptions.
1791       */
1792 <    public class CheckedBarrier extends CyclicBarrier {
1792 >    public static class CheckedBarrier extends CyclicBarrier {
1793          public CheckedBarrier(int parties) { super(parties); }
1794  
1795          public int await() {
# Line 1816 | Line 1853 | public class JSR166TestCase extends Test
1853          }
1854      }
1855  
1856 +    void assertImmutable(final Object o) {
1857 +        if (o instanceof Collection) {
1858 +            assertThrows(
1859 +                UnsupportedOperationException.class,
1860 +                new Runnable() { public void run() {
1861 +                        ((Collection) o).add(null);}});
1862 +        }
1863 +    }
1864 +
1865      @SuppressWarnings("unchecked")
1866      <T> T serialClone(T o) {
1867          try {
1868              ObjectInputStream ois = new ObjectInputStream
1869                  (new ByteArrayInputStream(serialBytes(o)));
1870              T clone = (T) ois.readObject();
1871 +            if (o == clone) assertImmutable(o);
1872              assertSame(o.getClass(), clone.getClass());
1873              return clone;
1874          } catch (Throwable fail) {
# Line 1830 | Line 1877 | public class JSR166TestCase extends Test
1877          }
1878      }
1879  
1880 +    /**
1881 +     * A version of serialClone that leaves error handling (for
1882 +     * e.g. NotSerializableException) up to the caller.
1883 +     */
1884 +    @SuppressWarnings("unchecked")
1885 +    <T> T serialClonePossiblyFailing(T o)
1886 +        throws ReflectiveOperationException, java.io.IOException {
1887 +        ByteArrayOutputStream bos = new ByteArrayOutputStream();
1888 +        ObjectOutputStream oos = new ObjectOutputStream(bos);
1889 +        oos.writeObject(o);
1890 +        oos.flush();
1891 +        oos.close();
1892 +        ObjectInputStream ois = new ObjectInputStream
1893 +            (new ByteArrayInputStream(bos.toByteArray()));
1894 +        T clone = (T) ois.readObject();
1895 +        if (o == clone) assertImmutable(o);
1896 +        assertSame(o.getClass(), clone.getClass());
1897 +        return clone;
1898 +    }
1899 +
1900 +    /**
1901 +     * If o implements Cloneable and has a public clone method,
1902 +     * returns a clone of o, else null.
1903 +     */
1904 +    @SuppressWarnings("unchecked")
1905 +    <T> T cloneableClone(T o) {
1906 +        if (!(o instanceof Cloneable)) return null;
1907 +        final T clone;
1908 +        try {
1909 +            clone = (T) o.getClass().getMethod("clone").invoke(o);
1910 +        } catch (NoSuchMethodException ok) {
1911 +            return null;
1912 +        } catch (ReflectiveOperationException unexpected) {
1913 +            throw new Error(unexpected);
1914 +        }
1915 +        assertNotSame(o, clone); // not 100% guaranteed by spec
1916 +        assertSame(o.getClass(), clone.getClass());
1917 +        return clone;
1918 +    }
1919 +
1920      public void assertThrows(Class<? extends Throwable> expectedExceptionClass,
1921                               Runnable... throwingActions) {
1922          for (Runnable throwingAction : throwingActions) {
# Line 1873 | Line 1960 | public class JSR166TestCase extends Test
1960                                 1000L, MILLISECONDS,
1961                                 new SynchronousQueue<Runnable>());
1962  
1963 +    static <T> void shuffle(T[] array) {
1964 +        Collections.shuffle(Arrays.asList(array), ThreadLocalRandom.current());
1965 +    }
1966   }

Diff Legend

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