--- jsr166/src/test/tck/JSR166TestCase.java	2009/11/21 10:25:05	1.43
+++ jsr166/src/test/tck/JSR166TestCase.java	2010/09/01 06:41:55	1.51
@@ -26,19 +26,19 @@ import java.security.*;
  * <li> All assertions in code running in generated threads must use
  * the forms {@link #threadFail}, {@link #threadAssertTrue}, {@link
  * #threadAssertEquals}, or {@link #threadAssertNull}, (not
- * <tt>fail</tt>, <tt>assertTrue</tt>, etc.) It is OK (but not
+ * {@code fail}, {@code assertTrue}, etc.) It is OK (but not
  * particularly recommended) for other code to use these forms too.
  * Only the most typically used JUnit assertion methods are defined
  * this way, but enough to live with.</li>
  *
  * <li> If you override {@link #setUp} or {@link #tearDown}, make sure
- * to invoke <tt>super.setUp</tt> and <tt>super.tearDown</tt> within
+ * to invoke {@code super.setUp} and {@code super.tearDown} within
  * them. These methods are used to clear and check for thread
  * assertion failures.</li>
  *
- * <li>All delays and timeouts must use one of the constants <tt>
- * SHORT_DELAY_MS</tt>, <tt> SMALL_DELAY_MS</tt>, <tt> MEDIUM_DELAY_MS</tt>,
- * <tt> LONG_DELAY_MS</tt>. The idea here is that a SHORT is always
+ * <li>All delays and timeouts must use one of the constants {@code
+ * SHORT_DELAY_MS}, {@code SMALL_DELAY_MS}, {@code MEDIUM_DELAY_MS},
+ * {@code LONG_DELAY_MS}. The idea here is that a SHORT is always
  * discriminable from zero time, and always allows enough time for the
  * small amounts of computation (creating a thread, calling a few
  * methods, etc) needed to reach a timeout point. Similarly, a SMALL
@@ -48,8 +48,8 @@ import java.security.*;
  * in one spot to rerun tests on slower platforms.</li>
  *
  * <li> All threads generated must be joined inside each test case
- * method (or <tt>fail</tt> to do so) before returning from the
- * method. The <tt> joinPool</tt> method can be used to do this when
+ * method (or {@code fail} to do so) before returning from the
+ * method. The {@code joinPool} method can be used to do this when
  * using Executors.</li>
  *
  * </ol>
@@ -81,16 +81,24 @@ import java.security.*;
  * any particular package to simplify things for people integrating
  * them in TCK test suites.</li>
  *
- * <li> As a convenience, the <tt>main</tt> of this class (JSR166TestCase)
+ * <li> As a convenience, the {@code main} of this class (JSR166TestCase)
  * runs all JSR166 unit tests.</li>
  *
  * </ul>
  */
 public class JSR166TestCase extends TestCase {
+    private static final boolean useSecurityManager =
+        Boolean.getBoolean("jsr166.useSecurityManager");
+
     /**
      * Runs all JSR166 unit tests using junit.textui.TestRunner
      */
     public static void main(String[] args) {
+        if (useSecurityManager) {
+            System.err.println("Setting a permissive security manager");
+            Policy.setPolicy(permissivePolicy());
+            System.setSecurityManager(new SecurityManager());
+        }
         int iters = 1;
         if (args.length > 0)
             iters = Integer.parseInt(args[0]);
@@ -135,6 +143,7 @@ public class JSR166TestCase extends Test
         suite.addTest(new TestSuite(AtomicReferenceTest.class));
         suite.addTest(new TestSuite(AtomicStampedReferenceTest.class));
         suite.addTest(new TestSuite(ConcurrentHashMapTest.class));
+        suite.addTest(new TestSuite(ConcurrentLinkedDequeTest.class));
         suite.addTest(new TestSuite(ConcurrentLinkedQueueTest.class));
         suite.addTest(new TestSuite(ConcurrentSkipListMapTest.class));
         suite.addTest(new TestSuite(ConcurrentSkipListSubMapTest.class));
@@ -328,7 +337,7 @@ public class JSR166TestCase extends Test
         } catch (SecurityException ok) {
             // Allowed in case test doesn't have privs
         } catch (InterruptedException ie) {
-            fail("Unexpected exception");
+            fail("Unexpected InterruptedException");
         }
     }
 
@@ -366,36 +375,80 @@ public class JSR166TestCase extends Test
     /**
      * The number of elements to place in collections, arrays, etc.
      */
-    static final int SIZE = 20;
+    public static final int SIZE = 20;
 
     // Some convenient Integer constants
 
-    static final Integer zero = new Integer(0);
-    static final Integer one = new Integer(1);
-    static final Integer two = new Integer(2);
-    static final Integer three  = new Integer(3);
-    static final Integer four  = new Integer(4);
-    static final Integer five  = new Integer(5);
-    static final Integer six = new Integer(6);
-    static final Integer seven = new Integer(7);
-    static final Integer eight = new Integer(8);
-    static final Integer nine = new Integer(9);
-    static final Integer m1  = new Integer(-1);
-    static final Integer m2  = new Integer(-2);
-    static final Integer m3  = new Integer(-3);
-    static final Integer m4 = new Integer(-4);
-    static final Integer m5 = new Integer(-5);
-    static final Integer m6 = new Integer(-6);
-    static final Integer m10 = new Integer(-10);
+    public static final Integer zero  = new Integer(0);
+    public static final Integer one   = new Integer(1);
+    public static final Integer two   = new Integer(2);
+    public static final Integer three = new Integer(3);
+    public static final Integer four  = new Integer(4);
+    public static final Integer five  = new Integer(5);
+    public static final Integer six   = new Integer(6);
+    public static final Integer seven = new Integer(7);
+    public static final Integer eight = new Integer(8);
+    public static final Integer nine  = new Integer(9);
+    public static final Integer m1  = new Integer(-1);
+    public static final Integer m2  = new Integer(-2);
+    public static final Integer m3  = new Integer(-3);
+    public static final Integer m4  = new Integer(-4);
+    public static final Integer m5  = new Integer(-5);
+    public static final Integer m6  = new Integer(-6);
+    public static final Integer m10 = new Integer(-10);
+
+
+    /**
+     * Runs Runnable r with a security policy that permits precisely
+     * the specified permissions.  If there is no current security
+     * manager, the runnable is run twice, both with and without a
+     * security manager.  We require that any security manager permit
+     * getPolicy/setPolicy.
+     */
+    public void runWithPermissions(Runnable r, Permission... permissions) {
+        SecurityManager sm = System.getSecurityManager();
+        if (sm == null) {
+            r.run();
+            Policy savedPolicy = Policy.getPolicy();
+            try {
+                Policy.setPolicy(permissivePolicy());
+                System.setSecurityManager(new SecurityManager());
+                runWithPermissions(r, permissions);
+            } finally {
+                System.setSecurityManager(null);
+                Policy.setPolicy(savedPolicy);
+            }
+        } else {
+            Policy savedPolicy = Policy.getPolicy();
+            AdjustablePolicy policy = new AdjustablePolicy(permissions);
+            Policy.setPolicy(policy);
+
+            try {
+                r.run();
+            } finally {
+                policy.addPermission(new SecurityPermission("setPolicy"));
+                Policy.setPolicy(savedPolicy);
+            }
+        }
+    }
 
+    /**
+     * Runs a runnable without any permissions.
+     */
+    public void runWithoutPermissions(Runnable r) {
+        runWithPermissions(r);
+    }
 
     /**
      * A security policy where new permissions can be dynamically added
      * or all cleared.
      */
-    static class AdjustablePolicy extends java.security.Policy {
+    public static class AdjustablePolicy extends java.security.Policy {
         Permissions perms = new Permissions();
-        AdjustablePolicy() { }
+        AdjustablePolicy(Permission... permissions) {
+            for (Permission permission : permissions)
+                perms.add(permission);
+        }
         void addPermission(Permission perm) { perms.add(perm); }
         void clearPermissions() { perms = new Permissions(); }
         public PermissionCollection getPermissions(CodeSource cs) {
@@ -411,14 +464,32 @@ public class JSR166TestCase extends Test
     }
 
     /**
+     * Returns a policy containing all the permissions we ever need.
+     */
+    public static Policy permissivePolicy() {
+        return new AdjustablePolicy
+            // Permissions j.u.c. needs directly
+            (new RuntimePermission("modifyThread"),
+             new RuntimePermission("getClassLoader"),
+             new RuntimePermission("setContextClassLoader"),
+             // Permissions needed to change permissions!
+             new SecurityPermission("getPolicy"),
+             new SecurityPermission("setPolicy"),
+             new RuntimePermission("setSecurityManager"),
+             // Permissions needed by the junit test harness
+             new RuntimePermission("accessDeclaredMembers"),
+             new PropertyPermission("*", "read"),
+             new java.io.FilePermission("<<ALL FILES>>", "read"));
+    }
+
+    /**
      * Sleep until the timeout has elapsed, or interrupted.
      * Does <em>NOT</em> throw InterruptedException.
      */
     void sleepTillInterrupted(long timeoutMillis) {
         try {
             Thread.sleep(timeoutMillis);
-        } catch (InterruptedException wakeup) {
-        }
+        } catch (InterruptedException wakeup) {}
     }
 
     /**
@@ -432,8 +503,8 @@ public class JSR166TestCase extends Test
 
     // Some convenient Runnable classes
 
-    abstract class CheckedRunnable implements Runnable {
-        abstract void realRun() throws Throwable;
+    public abstract class CheckedRunnable implements Runnable {
+        protected abstract void realRun() throws Throwable;
 
         public final void run() {
             try {
@@ -444,8 +515,8 @@ public class JSR166TestCase extends Test
         }
     }
 
-    abstract class RunnableShouldThrow implements Runnable {
-        abstract void realRun() throws Throwable;
+    public abstract class RunnableShouldThrow implements Runnable {
+        protected abstract void realRun() throws Throwable;
 
         final Class<?> exceptionClass;
 
@@ -457,7 +528,6 @@ public class JSR166TestCase extends Test
             try {
                 realRun();
                 threadShouldThrow(exceptionClass.getSimpleName());
-            } catch (InterruptedException success) {
             } catch (Throwable t) {
                 if (! exceptionClass.isInstance(t))
                     threadUnexpectedException(t);
@@ -465,8 +535,8 @@ public class JSR166TestCase extends Test
         }
     }
 
-    abstract class ThreadShouldThrow extends Thread {
-        abstract void realRun() throws Throwable;
+    public abstract class ThreadShouldThrow extends Thread {
+        protected abstract void realRun() throws Throwable;
 
         final Class<?> exceptionClass;
 
@@ -478,7 +548,6 @@ public class JSR166TestCase extends Test
             try {
                 realRun();
                 threadShouldThrow(exceptionClass.getSimpleName());
-            } catch (InterruptedException success) {
             } catch (Throwable t) {
                 if (! exceptionClass.isInstance(t))
                     threadUnexpectedException(t);
@@ -486,8 +555,8 @@ public class JSR166TestCase extends Test
         }
     }
 
-    abstract class CheckedInterruptedRunnable implements Runnable {
-        abstract void realRun() throws Throwable;
+    public abstract class CheckedInterruptedRunnable implements Runnable {
+        protected abstract void realRun() throws Throwable;
 
         public final void run() {
             try {
@@ -500,8 +569,8 @@ public class JSR166TestCase extends Test
         }
     }
 
-    abstract class CheckedCallable<T> implements Callable<T> {
-        abstract T realCall() throws Throwable;
+    public abstract class CheckedCallable<T> implements Callable<T> {
+        protected abstract T realCall() throws Throwable;
 
         public final T call() {
             try {
@@ -513,8 +582,8 @@ public class JSR166TestCase extends Test
         }
     }
 
-    abstract class CheckedInterruptedCallable<T> implements Callable<T> {
-        abstract T realCall() throws Throwable;
+    public abstract class CheckedInterruptedCallable<T> implements Callable<T> {
+        protected abstract T realCall() throws Throwable;
 
         public final T call() {
             try {
@@ -529,158 +598,158 @@ public class JSR166TestCase extends Test
         }
     }
 
-    static class NoOpRunnable implements Runnable {
+    public static class NoOpRunnable implements Runnable {
         public void run() {}
     }
 
-    static class NoOpCallable implements Callable {
+    public static class NoOpCallable implements Callable {
         public Object call() { return Boolean.TRUE; }
     }
 
-    static final String TEST_STRING = "a test string";
+    public static final String TEST_STRING = "a test string";
 
-    static class StringTask implements Callable<String> {
+    public static class StringTask implements Callable<String> {
         public String call() { return TEST_STRING; }
     }
 
-    static class NPETask implements Callable<String> {
+    public Callable<String> latchAwaitingStringTask(final CountDownLatch latch) {
+        return new CheckedCallable<String>() {
+            public String realCall() {
+                try {
+                    latch.await();
+                } catch (InterruptedException quittingTime) {}
+                return TEST_STRING;
+            }};
+    }
+
+    public static class NPETask implements Callable<String> {
         public String call() { throw new NullPointerException(); }
     }
 
-    static class CallableOne implements Callable<Integer> {
+    public static class CallableOne implements Callable<Integer> {
         public Integer call() { return one; }
     }
 
-    class ShortRunnable extends CheckedRunnable {
-        void realRun() throws Throwable {
+    public class ShortRunnable extends CheckedRunnable {
+        protected void realRun() throws Throwable {
             Thread.sleep(SHORT_DELAY_MS);
         }
     }
 
-    class ShortInterruptedRunnable extends CheckedInterruptedRunnable {
-        void realRun() throws InterruptedException {
+    public class ShortInterruptedRunnable extends CheckedInterruptedRunnable {
+        protected void realRun() throws InterruptedException {
             Thread.sleep(SHORT_DELAY_MS);
         }
     }
 
-    class SmallRunnable extends CheckedRunnable {
-        void realRun() throws Throwable {
+    public class SmallRunnable extends CheckedRunnable {
+        protected void realRun() throws Throwable {
             Thread.sleep(SMALL_DELAY_MS);
         }
     }
 
-    class SmallPossiblyInterruptedRunnable extends CheckedRunnable {
-        void realRun() {
+    public class SmallPossiblyInterruptedRunnable extends CheckedRunnable {
+        protected void realRun() {
             try {
                 Thread.sleep(SMALL_DELAY_MS);
-            }
-            catch (InterruptedException ok) {
-            }
+            } catch (InterruptedException ok) {}
         }
     }
 
-    class SmallCallable extends CheckedCallable {
-        Object realCall() throws Throwable {
+    public class SmallCallable extends CheckedCallable {
+        protected Object realCall() throws InterruptedException {
             Thread.sleep(SMALL_DELAY_MS);
             return Boolean.TRUE;
         }
     }
 
-    class SmallInterruptedRunnable extends CheckedInterruptedRunnable {
-        void realRun() throws InterruptedException {
+    public class SmallInterruptedRunnable extends CheckedInterruptedRunnable {
+        protected void realRun() throws InterruptedException {
             Thread.sleep(SMALL_DELAY_MS);
         }
     }
 
-    class MediumRunnable extends CheckedRunnable {
-        void realRun() throws Throwable {
+    public class MediumRunnable extends CheckedRunnable {
+        protected void realRun() throws Throwable {
             Thread.sleep(MEDIUM_DELAY_MS);
         }
     }
 
-    class MediumInterruptedRunnable extends CheckedInterruptedRunnable {
-        void realRun() throws InterruptedException {
+    public class MediumInterruptedRunnable extends CheckedInterruptedRunnable {
+        protected void realRun() throws InterruptedException {
             Thread.sleep(MEDIUM_DELAY_MS);
         }
     }
 
-    class MediumPossiblyInterruptedRunnable extends CheckedRunnable {
-        void realRun() {
+    public class MediumPossiblyInterruptedRunnable extends CheckedRunnable {
+        protected void realRun() {
             try {
                 Thread.sleep(MEDIUM_DELAY_MS);
-            }
-            catch (InterruptedException ok) {
-            }
+            } catch (InterruptedException ok) {}
         }
     }
 
-    class LongPossiblyInterruptedRunnable extends CheckedRunnable {
-        void realRun() {
+    public class LongPossiblyInterruptedRunnable extends CheckedRunnable {
+        protected void realRun() {
             try {
                 Thread.sleep(LONG_DELAY_MS);
-            }
-            catch (InterruptedException ok) {
-            }
+            } catch (InterruptedException ok) {}
         }
     }
 
     /**
      * For use as ThreadFactory in constructors
      */
-    static class SimpleThreadFactory implements ThreadFactory {
+    public static class SimpleThreadFactory implements ThreadFactory {
         public Thread newThread(Runnable r) {
             return new Thread(r);
         }
     }
 
-    static class TrackedShortRunnable implements Runnable {
-        volatile boolean done = false;
+    public static class TrackedShortRunnable implements Runnable {
+        public volatile boolean done = false;
         public void run() {
             try {
                 Thread.sleep(SMALL_DELAY_MS);
                 done = true;
-            } catch (InterruptedException ok) {
-            }
+            } catch (InterruptedException ok) {}
         }
     }
 
-    static class TrackedMediumRunnable implements Runnable {
-        volatile boolean done = false;
+    public static class TrackedMediumRunnable implements Runnable {
+        public volatile boolean done = false;
         public void run() {
             try {
                 Thread.sleep(MEDIUM_DELAY_MS);
                 done = true;
-            } catch (InterruptedException ok) {
-            }
+            } catch (InterruptedException ok) {}
         }
     }
 
-    static class TrackedLongRunnable implements Runnable {
-        volatile boolean done = false;
+    public static class TrackedLongRunnable implements Runnable {
+        public volatile boolean done = false;
         public void run() {
             try {
                 Thread.sleep(LONG_DELAY_MS);
                 done = true;
-            } catch (InterruptedException ok) {
-            }
+            } catch (InterruptedException ok) {}
         }
     }
 
-    static class TrackedNoOpRunnable implements Runnable {
-        volatile boolean done = false;
+    public static class TrackedNoOpRunnable implements Runnable {
+        public volatile boolean done = false;
         public void run() {
             done = true;
         }
     }
 
-    static class TrackedCallable implements Callable {
-        volatile boolean done = false;
+    public static class TrackedCallable implements Callable {
+        public volatile boolean done = false;
         public Object call() {
             try {
                 Thread.sleep(SMALL_DELAY_MS);
                 done = true;
-            } catch (InterruptedException ok) {
-            }
+            } catch (InterruptedException ok) {}
             return Boolean.TRUE;
         }
     }
@@ -689,7 +758,7 @@ public class JSR166TestCase extends Test
     /**
      * For use as RejectedExecutionHandler in constructors
      */
-    static class NoOpREHandler implements RejectedExecutionHandler {
+    public static class NoOpREHandler implements RejectedExecutionHandler {
         public void rejectedExecution(Runnable r,
                                       ThreadPoolExecutor executor) {}
     }