changeset 47385:e0637258a133

8187607: [Testbug] Atomic*FieldUpdaterTest.checkPrivateAccess uses nested classes Reviewed-by: martin, psandoz, dholmes
author dl
date Tue, 03 Oct 2017 13:41:55 -0700
parents f517fa4f4dc6
children 3f5f9bc0bdc2
files test/jdk/java/util/concurrent/tck/AtomicIntegerFieldUpdaterTest.java test/jdk/java/util/concurrent/tck/AtomicLongFieldUpdaterTest.java test/jdk/java/util/concurrent/tck/AtomicReferenceFieldUpdaterTest.java test/jdk/java/util/concurrent/tck/NonNestmates.java
diffstat 4 files changed, 234 insertions(+), 177 deletions(-) [+]
line wrap: on
line diff
--- a/test/jdk/java/util/concurrent/tck/AtomicIntegerFieldUpdaterTest.java	Tue Oct 03 13:37:01 2017 -0700
+++ b/test/jdk/java/util/concurrent/tck/AtomicIntegerFieldUpdaterTest.java	Tue Oct 03 13:41:55 2017 -0700
@@ -51,57 +51,6 @@
         return new TestSuite(AtomicIntegerFieldUpdaterTest.class);
     }
 
-    // for testing subclass access
-    static class AtomicIntegerFieldUpdaterTestSubclass extends AtomicIntegerFieldUpdaterTest {
-        public void checkPrivateAccess() {
-            try {
-                AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a =
-                    AtomicIntegerFieldUpdater.newUpdater
-                    (AtomicIntegerFieldUpdaterTest.class, "privateField");
-                shouldThrow();
-            } catch (RuntimeException success) {
-                assertNotNull(success.getCause());
-            }
-        }
-
-        public void checkCompareAndSetProtectedSub() {
-            AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a =
-                AtomicIntegerFieldUpdater.newUpdater
-                (AtomicIntegerFieldUpdaterTest.class, "protectedField");
-            this.protectedField = 1;
-            assertTrue(a.compareAndSet(this, 1, 2));
-            assertTrue(a.compareAndSet(this, 2, -4));
-            assertEquals(-4, a.get(this));
-            assertFalse(a.compareAndSet(this, -5, 7));
-            assertEquals(-4, a.get(this));
-            assertTrue(a.compareAndSet(this, -4, 7));
-            assertEquals(7, a.get(this));
-        }
-    }
-
-    static class UnrelatedClass {
-        public void checkPackageAccess(AtomicIntegerFieldUpdaterTest obj) {
-            obj.x = 72;
-            AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a =
-                AtomicIntegerFieldUpdater.newUpdater
-                (AtomicIntegerFieldUpdaterTest.class, "x");
-            assertEquals(72, a.get(obj));
-            assertTrue(a.compareAndSet(obj, 72, 73));
-            assertEquals(73, a.get(obj));
-        }
-
-        public void checkPrivateAccess(AtomicIntegerFieldUpdaterTest obj) {
-            try {
-                AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a =
-                    AtomicIntegerFieldUpdater.newUpdater
-                    (AtomicIntegerFieldUpdaterTest.class, "privateField");
-                throw new AssertionError("should throw");
-            } catch (RuntimeException success) {
-                assertNotNull(success.getCause());
-            }
-        }
-    }
-
     AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> updaterFor(String fieldName) {
         return AtomicIntegerFieldUpdater.newUpdater
             (AtomicIntegerFieldUpdaterTest.class, fieldName);
@@ -143,9 +92,8 @@
      * construction using private field from subclass throws RuntimeException
      */
     public void testPrivateFieldInSubclass() {
-        AtomicIntegerFieldUpdaterTestSubclass s =
-            new AtomicIntegerFieldUpdaterTestSubclass();
-        s.checkPrivateAccess();
+        new NonNestmates.AtomicIntegerFieldUpdaterTestSubclass()
+            .checkPrivateAccess();
     }
 
     /**
@@ -153,8 +101,8 @@
      * private access is not
      */
     public void testUnrelatedClassAccess() {
-        new UnrelatedClass().checkPackageAccess(this);
-        new UnrelatedClass().checkPrivateAccess(this);
+        new NonNestmates().checkPackageAccess(this);
+        new NonNestmates().checkPrivateAccess(this);
     }
 
     /**
@@ -223,9 +171,8 @@
      * equal to expected else fails
      */
     public void testCompareAndSetProtectedInSubclass() {
-        AtomicIntegerFieldUpdaterTestSubclass s =
-            new AtomicIntegerFieldUpdaterTestSubclass();
-        s.checkCompareAndSetProtectedSub();
+        new NonNestmates.AtomicIntegerFieldUpdaterTestSubclass()
+            .checkCompareAndSetProtectedSub();
     }
 
     /**
--- a/test/jdk/java/util/concurrent/tck/AtomicLongFieldUpdaterTest.java	Tue Oct 03 13:37:01 2017 -0700
+++ b/test/jdk/java/util/concurrent/tck/AtomicLongFieldUpdaterTest.java	Tue Oct 03 13:41:55 2017 -0700
@@ -51,57 +51,6 @@
         return new TestSuite(AtomicLongFieldUpdaterTest.class);
     }
 
-    // for testing subclass access
-    static class AtomicLongFieldUpdaterTestSubclass extends AtomicLongFieldUpdaterTest {
-        public void checkPrivateAccess() {
-            try {
-                AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a =
-                    AtomicLongFieldUpdater.newUpdater
-                    (AtomicLongFieldUpdaterTest.class, "privateField");
-                shouldThrow();
-            } catch (RuntimeException success) {
-                assertNotNull(success.getCause());
-            }
-        }
-
-        public void checkCompareAndSetProtectedSub() {
-            AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a =
-                AtomicLongFieldUpdater.newUpdater
-                (AtomicLongFieldUpdaterTest.class, "protectedField");
-            this.protectedField = 1;
-            assertTrue(a.compareAndSet(this, 1, 2));
-            assertTrue(a.compareAndSet(this, 2, -4));
-            assertEquals(-4, a.get(this));
-            assertFalse(a.compareAndSet(this, -5, 7));
-            assertEquals(-4, a.get(this));
-            assertTrue(a.compareAndSet(this, -4, 7));
-            assertEquals(7, a.get(this));
-        }
-    }
-
-    static class UnrelatedClass {
-        public void checkPackageAccess(AtomicLongFieldUpdaterTest obj) {
-            obj.x = 72L;
-            AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a =
-                AtomicLongFieldUpdater.newUpdater
-                (AtomicLongFieldUpdaterTest.class, "x");
-            assertEquals(72L, a.get(obj));
-            assertTrue(a.compareAndSet(obj, 72L, 73L));
-            assertEquals(73L, a.get(obj));
-        }
-
-        public void checkPrivateAccess(AtomicLongFieldUpdaterTest obj) {
-            try {
-                AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a =
-                    AtomicLongFieldUpdater.newUpdater
-                    (AtomicLongFieldUpdaterTest.class, "privateField");
-                throw new AssertionError("should throw");
-            } catch (RuntimeException success) {
-                assertNotNull(success.getCause());
-            }
-        }
-    }
-
     AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> updaterFor(String fieldName) {
         return AtomicLongFieldUpdater.newUpdater
             (AtomicLongFieldUpdaterTest.class, fieldName);
@@ -143,9 +92,8 @@
      * construction using private field from subclass throws RuntimeException
      */
     public void testPrivateFieldInSubclass() {
-        AtomicLongFieldUpdaterTestSubclass s =
-            new AtomicLongFieldUpdaterTestSubclass();
-        s.checkPrivateAccess();
+        new NonNestmates.AtomicLongFieldUpdaterTestSubclass()
+            .checkPrivateAccess();
     }
 
     /**
@@ -153,8 +101,8 @@
      * private access is not
      */
     public void testUnrelatedClassAccess() {
-        new UnrelatedClass().checkPackageAccess(this);
-        new UnrelatedClass().checkPrivateAccess(this);
+        new NonNestmates().checkPackageAccess(this);
+        new NonNestmates().checkPrivateAccess(this);
     }
 
     /**
@@ -223,9 +171,8 @@
      * equal to expected else fails
      */
     public void testCompareAndSetProtectedInSubclass() {
-        AtomicLongFieldUpdaterTestSubclass s =
-            new AtomicLongFieldUpdaterTestSubclass();
-        s.checkCompareAndSetProtectedSub();
+        new NonNestmates.AtomicLongFieldUpdaterTestSubclass()
+            .checkCompareAndSetProtectedSub();
     }
 
     /**
--- a/test/jdk/java/util/concurrent/tck/AtomicReferenceFieldUpdaterTest.java	Tue Oct 03 13:37:01 2017 -0700
+++ b/test/jdk/java/util/concurrent/tck/AtomicReferenceFieldUpdaterTest.java	Tue Oct 03 13:41:55 2017 -0700
@@ -53,57 +53,6 @@
         return new TestSuite(AtomicReferenceFieldUpdaterTest.class);
     }
 
-    // for testing subclass access
-    static class AtomicReferenceFieldUpdaterTestSubclass extends AtomicReferenceFieldUpdaterTest {
-        public void checkPrivateAccess() {
-            try {
-                AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest,Integer> a =
-                    AtomicReferenceFieldUpdater.newUpdater
-                    (AtomicReferenceFieldUpdaterTest.class, Integer.class, "privateField");
-                shouldThrow();
-            } catch (RuntimeException success) {
-                assertNotNull(success.getCause());
-            }
-        }
-
-        public void checkCompareAndSetProtectedSub() {
-            AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest,Integer> a =
-                AtomicReferenceFieldUpdater.newUpdater
-                (AtomicReferenceFieldUpdaterTest.class, Integer.class, "protectedField");
-            this.protectedField = one;
-            assertTrue(a.compareAndSet(this, one, two));
-            assertTrue(a.compareAndSet(this, two, m4));
-            assertSame(m4, a.get(this));
-            assertFalse(a.compareAndSet(this, m5, seven));
-            assertNotSame(seven, a.get(this));
-            assertTrue(a.compareAndSet(this, m4, seven));
-            assertSame(seven, a.get(this));
-        }
-    }
-
-    static class UnrelatedClass {
-        public void checkPackageAccess(AtomicReferenceFieldUpdaterTest obj) {
-            obj.x = one;
-            AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest,Integer> a =
-                AtomicReferenceFieldUpdater.newUpdater
-                (AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
-            assertSame(one, a.get(obj));
-            assertTrue(a.compareAndSet(obj, one, two));
-            assertSame(two, a.get(obj));
-        }
-
-        public void checkPrivateAccess(AtomicReferenceFieldUpdaterTest obj) {
-            try {
-                AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest,Integer> a =
-                    AtomicReferenceFieldUpdater.newUpdater
-                    (AtomicReferenceFieldUpdaterTest.class, Integer.class, "privateField");
-                throw new AssertionError("should throw");
-            } catch (RuntimeException success) {
-                assertNotNull(success.getCause());
-            }
-        }
-    }
-
     static AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> updaterFor(String fieldName) {
         return AtomicReferenceFieldUpdater.newUpdater
             (AtomicReferenceFieldUpdaterTest.class, Integer.class, fieldName);
@@ -155,9 +104,8 @@
      * construction using private field from subclass throws RuntimeException
      */
     public void testPrivateFieldInSubclass() {
-        AtomicReferenceFieldUpdaterTestSubclass s =
-            new AtomicReferenceFieldUpdaterTestSubclass();
-        s.checkPrivateAccess();
+        new NonNestmates.AtomicReferenceFieldUpdaterTestSubclass()
+            .checkPrivateAccess();
     }
 
     /**
@@ -165,8 +113,8 @@
      * private access is not
      */
     public void testUnrelatedClassAccess() {
-        new UnrelatedClass().checkPackageAccess(this);
-        new UnrelatedClass().checkPrivateAccess(this);
+        new NonNestmates().checkPackageAccess(this);
+        new NonNestmates().checkPrivateAccess(this);
     }
 
     /**
@@ -198,7 +146,7 @@
     }
 
     /**
-     * compareAndSet succeeds in changing value if equal to expected else fails
+     * compareAndSet succeeds in changing value if same as expected else fails
      */
     public void testCompareAndSet() {
         AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a;
@@ -214,6 +162,15 @@
     }
 
     /**
+     * compareAndSet succeeds in changing protected field value if
+     * same as expected else fails
+     */
+    public void testCompareAndSetProtectedInSubclass() {
+        new NonNestmates.AtomicReferenceFieldUpdaterTestSubclass()
+            .checkCompareAndSetProtectedSub();
+    }
+
+    /**
      * compareAndSet in one thread enables another waiting for value
      * to succeed
      */
@@ -236,8 +193,7 @@
     }
 
     /**
-     * repeated weakCompareAndSet succeeds in changing value when equal
-     * to expected
+     * repeated weakCompareAndSet succeeds in changing value when same as expected
      */
     public void testWeakCompareAndSet() {
         AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a;
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/jdk/java/util/concurrent/tck/NonNestmates.java	Tue Oct 03 13:41:55 2017 -0700
@@ -0,0 +1,207 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * This file is available under and governed by the GNU General Public
+ * License version 2 only, as published by the Free Software Foundation.
+ * However, the following notice accompanied the original version of this
+ * file:
+ *
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ * Other contributors include Andrew Wright, Jeffrey Hayes,
+ * Pat Fisher, Mike Judd.
+ */
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
+import java.util.concurrent.atomic.AtomicLongFieldUpdater;
+import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
+
+/**
+ * This source file contains test code deliberately not contained in
+ * the same source file as the tests that use them, to avoid making
+ * them nestmates, which affects accessibility rules (see JEP 181).
+ */
+class NonNestmates {
+
+    public void checkPackageAccess(AtomicIntegerFieldUpdaterTest obj) {
+        obj.x = 72;
+        AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a =
+            AtomicIntegerFieldUpdater.newUpdater(
+                AtomicIntegerFieldUpdaterTest.class, "x");
+        assertEquals(72, a.get(obj));
+        assertTrue(a.compareAndSet(obj, 72, 73));
+        assertEquals(73, a.get(obj));
+    }
+
+    public void checkPackageAccess(AtomicLongFieldUpdaterTest obj) {
+        obj.x = 72L;
+        AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a =
+            AtomicLongFieldUpdater.newUpdater(
+                AtomicLongFieldUpdaterTest.class, "x");
+        assertEquals(72L, a.get(obj));
+        assertTrue(a.compareAndSet(obj, 72L, 73L));
+        assertEquals(73L, a.get(obj));
+    }
+
+    public void checkPackageAccess(AtomicReferenceFieldUpdaterTest obj) {
+        Integer one = new Integer(1);
+        Integer two = new Integer(2);
+        obj.x = one;
+        AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest,Integer> a =
+            AtomicReferenceFieldUpdater.newUpdater(
+                AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
+        assertSame(one, a.get(obj));
+        assertTrue(a.compareAndSet(obj, one, two));
+        assertSame(two, a.get(obj));
+    }
+
+    public void checkPrivateAccess(AtomicIntegerFieldUpdaterTest obj) {
+        try {
+            AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a =
+                AtomicIntegerFieldUpdater.newUpdater(
+                    AtomicIntegerFieldUpdaterTest.class, "privateField");
+            throw new AssertionError("should throw");
+        } catch (RuntimeException success) {
+            assertNotNull(success.getCause());
+        }
+    }
+
+    public void checkPrivateAccess(AtomicLongFieldUpdaterTest obj) {
+        try {
+            AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a =
+                AtomicLongFieldUpdater.newUpdater(
+                    AtomicLongFieldUpdaterTest.class, "privateField");
+            throw new AssertionError("should throw");
+        } catch (RuntimeException success) {
+            assertNotNull(success.getCause());
+        }
+    }
+
+    public void checkPrivateAccess(AtomicReferenceFieldUpdaterTest obj) {
+        try {
+            AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest,Integer> a =
+                AtomicReferenceFieldUpdater.newUpdater(
+                    AtomicReferenceFieldUpdaterTest.class,
+                    Integer.class, "privateField");
+            throw new AssertionError("should throw");
+        } catch (RuntimeException success) {
+            assertNotNull(success.getCause());
+        }
+    }
+
+    static class AtomicIntegerFieldUpdaterTestSubclass
+        extends AtomicIntegerFieldUpdaterTest {
+
+        public void checkPrivateAccess() {
+            try {
+                AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a =
+                    AtomicIntegerFieldUpdater.newUpdater(
+                        AtomicIntegerFieldUpdaterTest.class, "privateField");
+                shouldThrow();
+            } catch (RuntimeException success) {
+                assertNotNull(success.getCause());
+            }
+        }
+
+        public void checkCompareAndSetProtectedSub() {
+            AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a =
+                AtomicIntegerFieldUpdater.newUpdater(
+                    AtomicIntegerFieldUpdaterTest.class, "protectedField");
+            this.protectedField = 1;
+            assertTrue(a.compareAndSet(this, 1, 2));
+            assertTrue(a.compareAndSet(this, 2, -4));
+            assertEquals(-4, a.get(this));
+            assertFalse(a.compareAndSet(this, -5, 7));
+            assertEquals(-4, a.get(this));
+            assertTrue(a.compareAndSet(this, -4, 7));
+            assertEquals(7, a.get(this));
+        }
+    }
+
+    static class AtomicLongFieldUpdaterTestSubclass
+        extends AtomicLongFieldUpdaterTest {
+
+        public void checkPrivateAccess() {
+            try {
+                AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a =
+                    AtomicLongFieldUpdater.newUpdater(
+                        AtomicLongFieldUpdaterTest.class, "privateField");
+                shouldThrow();
+            } catch (RuntimeException success) {
+                assertNotNull(success.getCause());
+            }
+        }
+
+        public void checkCompareAndSetProtectedSub() {
+            AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a =
+                AtomicLongFieldUpdater.newUpdater(
+                    AtomicLongFieldUpdaterTest.class, "protectedField");
+            this.protectedField = 1;
+            assertTrue(a.compareAndSet(this, 1, 2));
+            assertTrue(a.compareAndSet(this, 2, -4));
+            assertEquals(-4, a.get(this));
+            assertFalse(a.compareAndSet(this, -5, 7));
+            assertEquals(-4, a.get(this));
+            assertTrue(a.compareAndSet(this, -4, 7));
+            assertEquals(7, a.get(this));
+        }
+    }
+
+    static class AtomicReferenceFieldUpdaterTestSubclass
+        extends AtomicReferenceFieldUpdaterTest {
+
+        public void checkPrivateAccess() {
+            try {
+                AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest,Integer> a =
+                    AtomicReferenceFieldUpdater.newUpdater(
+                        AtomicReferenceFieldUpdaterTest.class,
+                        Integer.class, "privateField");
+                shouldThrow();
+            } catch (RuntimeException success) {
+                assertNotNull(success.getCause());
+            }
+        }
+
+        public void checkCompareAndSetProtectedSub() {
+            AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest,Integer> a =
+                AtomicReferenceFieldUpdater.newUpdater(
+                    AtomicReferenceFieldUpdaterTest.class,
+                    Integer.class, "protectedField");
+            this.protectedField = one;
+            assertTrue(a.compareAndSet(this, one, two));
+            assertTrue(a.compareAndSet(this, two, m4));
+            assertSame(m4, a.get(this));
+            assertFalse(a.compareAndSet(this, m5, seven));
+            assertNotSame(seven, a.get(this));
+            assertTrue(a.compareAndSet(this, m4, seven));
+            assertSame(seven, a.get(this));
+        }
+    }
+}