8187607: [Testbug] Atomic*FieldUpdaterTest.checkPrivateAccess uses nested classes

Reviewed-by: martin, psandoz, dholmes
This commit is contained in:
Doug Lea 2017-10-03 13:41:55 -07:00
parent c6e3667228
commit 76db7c6b61
4 changed files with 234 additions and 177 deletions

@ -51,57 +51,6 @@ public class AtomicIntegerFieldUpdaterTest extends JSR166TestCase {
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 @@ public class AtomicIntegerFieldUpdaterTest extends JSR166TestCase {
* 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 @@ public class AtomicIntegerFieldUpdaterTest extends JSR166TestCase {
* 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 @@ public class AtomicIntegerFieldUpdaterTest extends JSR166TestCase {
* equal to expected else fails
*/
public void testCompareAndSetProtectedInSubclass() {
AtomicIntegerFieldUpdaterTestSubclass s =
new AtomicIntegerFieldUpdaterTestSubclass();
s.checkCompareAndSetProtectedSub();
new NonNestmates.AtomicIntegerFieldUpdaterTestSubclass()
.checkCompareAndSetProtectedSub();
}
/**

@ -51,57 +51,6 @@ public class AtomicLongFieldUpdaterTest extends JSR166TestCase {
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 @@ public class AtomicLongFieldUpdaterTest extends JSR166TestCase {
* 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 @@ public class AtomicLongFieldUpdaterTest extends JSR166TestCase {
* 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 @@ public class AtomicLongFieldUpdaterTest extends JSR166TestCase {
* equal to expected else fails
*/
public void testCompareAndSetProtectedInSubclass() {
AtomicLongFieldUpdaterTestSubclass s =
new AtomicLongFieldUpdaterTestSubclass();
s.checkCompareAndSetProtectedSub();
new NonNestmates.AtomicLongFieldUpdaterTestSubclass()
.checkCompareAndSetProtectedSub();
}
/**

@ -53,57 +53,6 @@ public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase {
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 @@ public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase {
* 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 @@ public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase {
* 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 @@ public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase {
}
/**
* 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;
@ -213,6 +161,15 @@ public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase {
assertSame(seven, a.get(this));
}
/**
* 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 @@ public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase {
}
/**
* 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;

@ -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));
}
}
}