--- jsr166/src/test/tck/JSR166TestCase.java	2009/12/01 06:47:14	1.47
+++ jsr166/src/test/tck/JSR166TestCase.java	2010/09/13 23:19:31	1.52
@@ -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));
@@ -286,6 +295,17 @@ public class JSR166TestCase extends Test
     }
 
     /**
+     * If arguments not identical, set status to indicate current testcase
+     * should fail
+     */
+    public void threadAssertSame(Object x, Object y) {
+        if (x != y) {
+            threadFailed = true;
+            assertSame(x, y);
+        }
+    }
+
+    /**
      * threadFail with message "should throw exception"
      */
     public void threadShouldThrow() {
@@ -390,12 +410,56 @@ public class JSR166TestCase extends Test
 
 
     /**
+     * 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.
      */
     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,6 +475,25 @@ 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.
      */
@@ -540,6 +623,16 @@ public class JSR166TestCase extends Test
         public String call() { return TEST_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(); }
     }