226 lines
8.9 KiB
Java
226 lines
8.9 KiB
Java
/*
|
|
* Copyright (c) 2012, 2017, Oracle and/or its affiliates. All rights reserved.
|
|
* 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.
|
|
*/
|
|
|
|
/*
|
|
* @test
|
|
* @bug 7103570 8189291
|
|
* @author David Holmes
|
|
* @run main/othervm AtomicUpdaters
|
|
* @run main/othervm AtomicUpdaters UseSM
|
|
* @summary Checks the (in)ability to create field updaters for differently
|
|
* accessible fields in different locations with/without a security
|
|
* manager
|
|
*/
|
|
|
|
import java.lang.reflect.Field;
|
|
import java.security.AccessControlException;
|
|
import java.security.CodeSource;
|
|
import java.security.Permission;
|
|
import java.security.PermissionCollection;
|
|
import java.security.Policy;
|
|
import java.security.ProtectionDomain;
|
|
import java.util.concurrent.atomic.AtomicInteger;
|
|
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
|
|
import java.util.concurrent.atomic.AtomicLong;
|
|
import java.util.concurrent.atomic.AtomicLongFieldUpdater;
|
|
import java.util.concurrent.atomic.AtomicReference;
|
|
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
|
|
|
|
public class AtomicUpdaters {
|
|
static final Policy DEFAULT_POLICY = Policy.getPolicy();
|
|
|
|
enum TYPE { INT, LONG, REF }
|
|
|
|
static class Config {
|
|
final Class<?> clazz;
|
|
final String field;
|
|
final String access;
|
|
final boolean reflectOk;
|
|
final boolean updaterOk;
|
|
final String desc;
|
|
final TYPE type;
|
|
|
|
Config(Class<?> clazz, String field, String access,
|
|
boolean reflectOk, boolean updaterOk, String desc, TYPE type) {
|
|
this.clazz = clazz;
|
|
this.field = field;
|
|
this.access = access;
|
|
this.reflectOk = reflectOk;
|
|
this.updaterOk = updaterOk;
|
|
this.desc = desc;
|
|
this.type =type;
|
|
}
|
|
|
|
public String toString() {
|
|
return desc + ": " + access + " " + clazz.getName() + "." + field;
|
|
}
|
|
}
|
|
|
|
static Config[] tests;
|
|
|
|
static void initTests(boolean hasSM) {
|
|
tests = new Config[] {
|
|
new Config(AtomicUpdaters.class, "pub_int", "public", true, true, "public int field of current class", TYPE.INT),
|
|
new Config(AtomicUpdaters.class, "priv_int", "private", true, true, "private int field of current class", TYPE.INT),
|
|
new Config(AtomicUpdaters.class, "pub_long", "public", true, true, "public long field of current class", TYPE.LONG),
|
|
new Config(AtomicUpdaters.class, "priv_long", "private", true, true, "private long field of current class", TYPE.LONG),
|
|
new Config(AtomicUpdaters.class, "pub_ref", "public", true, true, "public ref field of current class", TYPE.REF),
|
|
new Config(AtomicUpdaters.class, "priv_ref", "private", true, true, "private ref field of current class", TYPE.REF),
|
|
|
|
// Would like to test a public volatile in a class in another
|
|
// package - but of course there aren't any
|
|
new Config(AtomicInteger.class, "value", "private", hasSM ? false : true, false, "private int field of class in different package", TYPE.INT),
|
|
new Config(AtomicLong.class, "value", "private", hasSM ? false : true, false, "private long field of class in different package", TYPE.LONG),
|
|
new Config(AtomicReference.class, "value", "private", hasSM ? false : true, false, "private reference field of class in different package", TYPE.REF),
|
|
};
|
|
}
|
|
|
|
public volatile int pub_int;
|
|
private volatile int priv_int;
|
|
public volatile long pub_long;
|
|
private volatile long priv_long;
|
|
public volatile Object pub_ref;
|
|
private volatile Object priv_ref;
|
|
|
|
|
|
// This should be set dynamically at runtime using a System property, but
|
|
// ironically we get a SecurityException if we try to do that with a
|
|
// SecurityManager installed
|
|
static boolean verbose;
|
|
|
|
public static void main(String[] args) throws Throwable {
|
|
boolean hasSM = false;
|
|
for (String arg : args) {
|
|
if ("-v".equals(arg)) {
|
|
verbose = true;
|
|
}
|
|
else if ("UseSM".equals(arg)) {
|
|
// Ensure that the test is not influenced by the default users policy.
|
|
Policy.setPolicy(new NoPermissionsPolicy());
|
|
SecurityManager m = System.getSecurityManager();
|
|
if (m != null)
|
|
throw new RuntimeException("No security manager should initially be installed");
|
|
System.setSecurityManager(new java.lang.SecurityManager());
|
|
hasSM = true;
|
|
}
|
|
else {
|
|
throw new IllegalArgumentException("Unexpected option: " + arg);
|
|
}
|
|
}
|
|
initTests(hasSM);
|
|
|
|
int failures = 0;
|
|
|
|
System.out.printf("Testing with%s a SecurityManager present\n", hasSM ? "" : "out");
|
|
for (Config c : tests) {
|
|
System.out.println("Testing: " + c);
|
|
Error reflectionFailure = null;
|
|
Error updaterFailure = null;
|
|
Class<?> clazz = c.clazz;
|
|
// See if we can reflectively access the field
|
|
System.out.println(" - testing getDeclaredField");
|
|
try {
|
|
Field f = clazz.getDeclaredField(c.field);
|
|
if (!c.reflectOk)
|
|
reflectionFailure = new Error("Unexpected reflective access: " + c);
|
|
}
|
|
catch (AccessControlException e) {
|
|
if (c.reflectOk)
|
|
reflectionFailure = new Error("Unexpected reflective access failure: " + c, e);
|
|
else if (verbose) {
|
|
System.out.println("Got expected reflection exception: " + e);
|
|
e.printStackTrace(System.out);
|
|
}
|
|
}
|
|
|
|
if (reflectionFailure != null) {
|
|
reflectionFailure.printStackTrace(System.out);
|
|
}
|
|
|
|
// see if we can create an atomic updater for the field
|
|
Object u = null;
|
|
try {
|
|
switch (c.type) {
|
|
case INT:
|
|
System.out.println(" - testing AtomicIntegerFieldUpdater");
|
|
u = AtomicIntegerFieldUpdater.newUpdater(clazz, c.field);
|
|
break;
|
|
case LONG:
|
|
System.out.println(" - testing AtomicLongFieldUpdater");
|
|
u = AtomicLongFieldUpdater.newUpdater(clazz, c.field);
|
|
break;
|
|
case REF:
|
|
System.out.println(" - testing AtomicReferenceFieldUpdater");
|
|
u = AtomicReferenceFieldUpdater.newUpdater(clazz, Object.class, c.field);
|
|
break;
|
|
}
|
|
|
|
if (!c.updaterOk)
|
|
updaterFailure = new Error("Unexpected updater access: " + c);
|
|
}
|
|
catch (Exception e) {
|
|
if (c.updaterOk)
|
|
updaterFailure = new Error("Unexpected updater access failure: " + c, e);
|
|
else if (verbose) {
|
|
System.out.println("Got expected updater exception: " + e);
|
|
e.printStackTrace(System.out);
|
|
}
|
|
}
|
|
|
|
if (updaterFailure != null) {
|
|
updaterFailure.printStackTrace(System.out);
|
|
}
|
|
|
|
if (updaterFailure != null || reflectionFailure != null) {
|
|
failures++;
|
|
|
|
}
|
|
}
|
|
|
|
if (failures > 0) {
|
|
throw new Error("Some tests failed - see previous stacktraces");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Policy with no permissions.
|
|
*/
|
|
private static class NoPermissionsPolicy extends Policy {
|
|
@Override
|
|
public PermissionCollection getPermissions(CodeSource cs) {
|
|
return Policy.UNSUPPORTED_EMPTY_COLLECTION;
|
|
}
|
|
|
|
@Override
|
|
public PermissionCollection getPermissions(ProtectionDomain pd) {
|
|
return Policy.UNSUPPORTED_EMPTY_COLLECTION;
|
|
}
|
|
|
|
@Override
|
|
public boolean implies(ProtectionDomain pd, Permission p) {
|
|
return Policy.UNSUPPORTED_EMPTY_COLLECTION.implies(p) ||
|
|
DEFAULT_POLICY.implies(pd, p);
|
|
}
|
|
}
|
|
}
|