| /* | |
| * Copyright (c) 2012, 2022, 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 | |
| * @summary test access checking by java.lang.invoke.MethodHandles.Lookup | |
| * @compile AccessControlTest.java AccessControlTest_subpkg/Acquaintance_remote.java | |
| * @run testng/othervm test.java.lang.invoke.AccessControlTest | |
| */ | |
| package test.java.lang.invoke; | |
| import java.lang.invoke.*; | |
| import java.lang.reflect.*; | |
| import java.lang.reflect.Modifier; | |
| import java.util.*; | |
| import org.testng.annotations.*; | |
| import static java.lang.invoke.MethodHandles.*; | |
| import static java.lang.invoke.MethodHandles.Lookup.*; | |
| import static java.lang.invoke.MethodType.*; | |
| import static org.testng.Assert.*; | |
| import test.java.lang.invoke.AccessControlTest_subpkg.Acquaintance_remote; | |
| /** | |
| * Test many combinations of Lookup access and cross-class lookupStatic. | |
| * @author jrose | |
| */ | |
| public class AccessControlTest { | |
| static final Class<?> THIS_CLASS = AccessControlTest.class; | |
| // How much output? | |
| static int verbosity = 0; | |
| static { | |
| String vstr = System.getProperty(THIS_CLASS.getSimpleName()+".verbosity"); | |
| if (vstr == null) | |
| vstr = System.getProperty(THIS_CLASS.getName()+".verbosity"); | |
| if (vstr != null) verbosity = Integer.parseInt(vstr); | |
| } | |
| private class LookupCase implements Comparable<LookupCase> { | |
| final Lookup lookup; | |
| final Class<?> lookupClass; | |
| final Class<?> prevLookupClass; | |
| final int lookupModes; | |
| public LookupCase(Lookup lookup) { | |
| this.lookup = lookup; | |
| this.lookupClass = lookup.lookupClass(); | |
| this.prevLookupClass = lookup.previousLookupClass(); | |
| this.lookupModes = lookup.lookupModes(); | |
| assert(lookupString().equals(lookup.toString())); | |
| numberOf(lookupClass().getClassLoader()); // assign CL# | |
| } | |
| public LookupCase(Class<?> lookupClass, Class<?> prevLookupClass, int lookupModes) { | |
| this.lookup = null; | |
| this.lookupClass = lookupClass; | |
| this.prevLookupClass = prevLookupClass; | |
| this.lookupModes = lookupModes; | |
| numberOf(lookupClass().getClassLoader()); // assign CL# | |
| } | |
| public final Class<?> lookupClass() { return lookupClass; } | |
| public final Class<?> prevLookupClass() { return prevLookupClass; } | |
| public final int lookupModes() { return lookupModes; } | |
| public Lookup lookup() { lookup.getClass(); return lookup; } | |
| @Override | |
| public int compareTo(LookupCase that) { | |
| Class<?> c1 = this.lookupClass(); | |
| Class<?> c2 = that.lookupClass(); | |
| Class<?> p1 = this.prevLookupClass(); | |
| Class<?> p2 = that.prevLookupClass(); | |
| if (c1 != c2) { | |
| int cmp = c1.getName().compareTo(c2.getName()); | |
| if (cmp != 0) return cmp; | |
| cmp = numberOf(c1.getClassLoader()) - numberOf(c2.getClassLoader()); | |
| assert(cmp != 0); | |
| return cmp; | |
| } else if (p1 != p2){ | |
| if (p1 == null) | |
| return 1; | |
| else if (p2 == null) | |
| return -1; | |
| int cmp = p1.getName().compareTo(p2.getName()); | |
| if (cmp != 0) return cmp; | |
| cmp = numberOf(p1.getClassLoader()) - numberOf(p2.getClassLoader()); | |
| assert(cmp != 0); | |
| return cmp; | |
| } | |
| return -(this.lookupModes() - that.lookupModes()); | |
| } | |
| @Override | |
| public boolean equals(Object that) { | |
| return (that instanceof LookupCase && equals((LookupCase)that)); | |
| } | |
| public boolean equals(LookupCase that) { | |
| return (this.lookupClass() == that.lookupClass() && | |
| this.prevLookupClass() == that.prevLookupClass() && | |
| this.lookupModes() == that.lookupModes()); | |
| } | |
| @Override | |
| public int hashCode() { | |
| return lookupClass().hashCode() + (lookupModes() * 31); | |
| } | |
| /** Simulate all assertions in the spec. for Lookup.toString. */ | |
| private String lookupString() { | |
| String name = lookupClass.getName(); | |
| if (prevLookupClass != null) | |
| name += "/" + prevLookupClass.getName(); | |
| String suffix = ""; | |
| if (lookupModes == 0) | |
| suffix = "/noaccess"; | |
| else if (lookupModes == PUBLIC) | |
| suffix = "/public"; | |
| else if (lookupModes == UNCONDITIONAL) | |
| suffix = "/publicLookup"; | |
| else if (lookupModes == (PUBLIC|MODULE)) | |
| suffix = "/module"; | |
| else if (lookupModes == (PUBLIC|PACKAGE) | |
| || lookupModes == (PUBLIC|MODULE|PACKAGE)) | |
| suffix = "/package"; | |
| else if (lookupModes == (PUBLIC|PACKAGE|PRIVATE) | |
| || lookupModes == (PUBLIC|MODULE|PACKAGE|PRIVATE)) | |
| suffix = "/private"; | |
| else if (lookupModes == (PUBLIC|PACKAGE|PRIVATE|PROTECTED) | |
| || lookupModes == (PUBLIC|MODULE|PACKAGE|PRIVATE|PROTECTED) | |
| || lookupModes == (PUBLIC|MODULE|PACKAGE|PRIVATE|PROTECTED|ORIGINAL)) | |
| suffix = ""; | |
| else | |
| suffix = "/#"+Integer.toHexString(lookupModes); | |
| return name+suffix; | |
| } | |
| /** Simulate all assertions from the spec. for Lookup.in: | |
| * <hr> | |
| * Creates a lookup on the specified new lookup class. | |
| * [A1] The resulting object will report the specified | |
| * class as its own {@link #lookupClass lookupClass}. | |
| * [A1-a] However, the resulting {@code Lookup} object is guaranteed | |
| * to have no more access capabilities than the original. | |
| * In particular, access capabilities can be lost as follows:<ul> | |
| * [A2] If the new lookup class is not the same as the old lookup class, | |
| * then {@link #ORIGINAL ORIGINAL} access is lost. | |
| * [A3] If the new lookup class is in a different module from the old one, | |
| * i.e. {@link #MODULE MODULE} access is lost. | |
| * [A4] If the new lookup class is in a different package | |
| * than the old one, protected and default (package) members will not be accessible, | |
| * i.e. {@link #PROTECTED PROTECTED} and {@link #PACKAGE PACKAGE} access are lost. | |
| * [A5] If the new lookup class is not within the same package member | |
| * as the old one, private members will not be accessible, and protected members | |
| * will not be accessible by virtue of inheritance, | |
| * i.e. {@link #PRIVATE PRIVATE} access is lost. | |
| * (Protected members may continue to be accessible because of package sharing.) | |
| * [A6] If the new lookup class is not | |
| * {@linkplain #accessClass(Class) accessible} to this lookup, | |
| * then no members, not even public members, will be accessible | |
| * i.e. all access modes are lost. | |
| * [A7] If the new lookup class, the old lookup class and the previous lookup class | |
| * are all in different modules i.e. teleporting to a third module, | |
| * all access modes are lost. | |
| * <p> | |
| * The new previous lookup class is chosen as follows: | |
| * [A8] If the new lookup object has {@link #UNCONDITIONAL UNCONDITIONAL} bit, | |
| * the new previous lookup class is {@code null}. | |
| * [A9] If the new lookup class is in the same module as the old lookup class, | |
| * the new previous lookup class is the old previous lookup class. | |
| * [A10] If the new lookup class is in a different module from the old lookup class, | |
| * the new previous lookup class is the old lookup class. | |
| * | |
| * Other than the above cases, the new lookup will have the same | |
| * access capabilities as the original. [A11] | |
| * <hr> | |
| */ | |
| public LookupCase in(Class<?> c2) { | |
| Class<?> c1 = lookupClass(); | |
| Module m1 = c1.getModule(); | |
| Module m2 = c2.getModule(); | |
| Module m0 = prevLookupClass() != null ? prevLookupClass.getModule() : c1.getModule(); | |
| int modes1 = lookupModes(); | |
| int changed = 0; | |
| // for the purposes of access control then treat classes in different unnamed | |
| // modules as being in the same module. | |
| boolean sameModule = (m1 == m2) || | |
| (!m1.isNamed() && !m2.isNamed()); | |
| boolean samePackage = (c1.getClassLoader() == c2.getClassLoader() && | |
| c1.getPackageName().equals(c2.getPackageName())); | |
| boolean sameTopLevel = (topLevelClass(c1) == topLevelClass(c2)); | |
| boolean sameClass = (c1 == c2); | |
| assert(samePackage || !sameTopLevel); | |
| assert(sameTopLevel || !sameClass); | |
| boolean accessible = sameClass; | |
| if ((modes1 & PACKAGE) != 0) accessible |= samePackage; | |
| if ((modes1 & PUBLIC ) != 0) { | |
| if (isModuleAccessible(c2)) | |
| accessible |= (c2.getModifiers() & PUBLIC) != 0; | |
| else | |
| accessible = false; | |
| } | |
| if ((modes1 & UNCONDITIONAL) != 0) { | |
| if (m2.isExported(c2.getPackageName())) | |
| accessible |= (c2.getModifiers() & PUBLIC) != 0; | |
| else | |
| accessible = false; | |
| } | |
| if (!accessible) { | |
| // no access to c2; lose all access. | |
| changed |= (PUBLIC|MODULE|PACKAGE|PRIVATE|PROTECTED|UNCONDITIONAL); // [A7] | |
| } | |
| if (!sameClass) { | |
| changed |= ORIGINAL; // [A2] | |
| } | |
| if (m2 != m1 && m0 != m1) { | |
| // hop to a third module; lose all access | |
| changed |= (PUBLIC|MODULE|PACKAGE|PRIVATE|PROTECTED); // [A8] | |
| } | |
| if (!sameModule) { | |
| changed |= MODULE; // [A3] | |
| } | |
| if (!samePackage) { | |
| // Different package; loose PACKAGE and lower access. | |
| changed |= (PACKAGE|PRIVATE|PROTECTED); // [A4] | |
| } | |
| if (!sameTopLevel) { | |
| // Different top-level class. Lose PRIVATE and PROTECTED access. | |
| changed |= (PRIVATE|PROTECTED); // [A5] | |
| } | |
| if (sameClass) { | |
| assert(changed == 0); // [A11] (no deprivation if same class) | |
| } | |
| if (accessible) assert((changed & PUBLIC) == 0); | |
| int modes2 = modes1 & ~changed; | |
| Class<?> plc = (m1 == m2) ? prevLookupClass() : c1; // [A9] [A10] | |
| if ((modes1 & UNCONDITIONAL) != 0) plc = null; // [A8] | |
| LookupCase l2 = new LookupCase(c2, plc, modes2); | |
| assert(l2.lookupClass() == c2); // [A1] | |
| assert((modes1 | modes2) == modes1); // [A1-a] (no elevation of access) | |
| assert(l2.prevLookupClass() == null || (modes2 & MODULE) == 0); | |
| return l2; | |
| } | |
| LookupCase dropLookupMode(int modeToDrop) { | |
| int oldModes = lookupModes(); | |
| int newModes = oldModes & ~(modeToDrop | PROTECTED | ORIGINAL); | |
| switch (modeToDrop) { | |
| case PUBLIC: newModes &= ~(MODULE|PACKAGE|PROTECTED|PRIVATE); break; | |
| case MODULE: newModes &= ~(PACKAGE|PRIVATE); break; | |
| case PACKAGE: newModes &= ~(PRIVATE); break; | |
| case PROTECTED: | |
| case PRIVATE: | |
| case ORIGINAL: | |
| case UNCONDITIONAL: break; | |
| default: throw new IllegalArgumentException(modeToDrop + " is not a valid mode to drop"); | |
| } | |
| if (newModes == oldModes) return this; // return self if no change | |
| LookupCase l2 = new LookupCase(lookupClass(), prevLookupClass(), newModes); | |
| assert((oldModes | newModes) == oldModes); // [A2] (no elevation of access) | |
| assert(l2.prevLookupClass() == null || (newModes & MODULE) == 0); | |
| return l2; | |
| } | |
| boolean isModuleAccessible(Class<?> c) { | |
| Module m1 = lookupClass().getModule(); | |
| Module m2 = c.getModule(); | |
| Module m0 = prevLookupClass() != null ? prevLookupClass.getModule() : m1; | |
| String pn = c.getPackageName(); | |
| boolean accessible = m1.canRead(m2) && m2.isExported(pn, m1); | |
| if (m1 != m0) { | |
| accessible = accessible && m0.canRead(m2) && m2.isExported(pn, m0); | |
| } | |
| return accessible; | |
| } | |
| @Override | |
| public String toString() { | |
| String s = lookupClass().getSimpleName(); | |
| String lstr = lookupString(); | |
| int sl = lstr.indexOf('/'); | |
| if (sl >= 0) s += lstr.substring(sl); | |
| ClassLoader cld = lookupClass().getClassLoader(); | |
| if (cld != THIS_LOADER) s += "/loader#"+numberOf(cld); | |
| return s; | |
| } | |
| /** Predict the success or failure of accessing this method. */ | |
| public boolean willAccess(Method m) { | |
| Class<?> c1 = lookupClass(); | |
| Class<?> c2 = m.getDeclaringClass(); | |
| Module m1 = c1.getModule(); | |
| Module m2 = c2.getModule(); | |
| Module m0 = prevLookupClass != null ? prevLookupClass.getModule() : m1; | |
| // unconditional has access to all public types/members of types that is in a package | |
| // are unconditionally exported | |
| if ((lookupModes & UNCONDITIONAL) != 0) { | |
| return m2.isExported(c2.getPackageName()) | |
| && Modifier.isPublic(c2.getModifiers()) | |
| && Modifier.isPublic(m.getModifiers()); | |
| } | |
| // c1 and c2 are in different module | |
| if (m1 != m2 || m0 != m2) { | |
| return (lookupModes & PUBLIC) != 0 | |
| && isModuleAccessible(c2) | |
| && Modifier.isPublic(c2.getModifiers()) | |
| && Modifier.isPublic(m.getModifiers()); | |
| } | |
| assert(m1 == m2 && prevLookupClass == null); | |
| if (!willAccessClass(c2, false)) | |
| return false; | |
| LookupCase lc = this.in(c2); | |
| int modes1 = lc.lookupModes(); | |
| int modes2 = fixMods(m.getModifiers()); | |
| // allow private lookup on nestmates. Otherwise, privacy is strictly enforced | |
| if (c1 != c2 && ((modes2 & PRIVATE) == 0 || !c1.isNestmateOf(c2))) { | |
| modes1 &= ~PRIVATE; | |
| } | |
| // protected access is sometimes allowed | |
| if ((modes2 & PROTECTED) != 0) { | |
| int prev = modes2; | |
| modes2 |= PACKAGE; // it acts like a package method also | |
| if ((lookupModes() & PROTECTED) != 0 && | |
| c2.isAssignableFrom(c1)) | |
| modes2 |= PUBLIC; // from a subclass, it acts like a public method also | |
| } | |
| if (verbosity >= 2) | |
| System.out.format("%s willAccess %s modes1=0x%h modes2=0x%h => %s%n", lookupString(), lc.lookupString(), modes1, modes2, (modes2 & modes1) != 0); | |
| return (modes2 & modes1) != 0; | |
| } | |
| /** Predict the success or failure of accessing this class. */ | |
| public boolean willAccessClass(Class<?> c2, boolean load) { | |
| Class<?> c1 = lookupClass(); | |
| if (load && c2.getClassLoader() != null) { | |
| if (c1.getClassLoader() == null) { | |
| // not visible | |
| return false; | |
| } | |
| } | |
| Module m1 = c1.getModule(); | |
| Module m2 = c2.getModule(); | |
| Module m0 = prevLookupClass != null ? prevLookupClass.getModule() : m1; | |
| // unconditional has access to all public types that is in an unconditionally exported package | |
| if ((lookupModes & UNCONDITIONAL) != 0) { | |
| return m2.isExported(c2.getPackageName()) && Modifier.isPublic(c2.getModifiers()); | |
| } | |
| // c1 and c2 are in different module | |
| if (m1 != m2 || m0 != m2) { | |
| return (lookupModes & PUBLIC) != 0 | |
| && isModuleAccessible(c2) | |
| && Modifier.isPublic(c2.getModifiers()); | |
| } | |
| assert(m1 == m2 && prevLookupClass == null); | |
| LookupCase lc = this.in(c2); | |
| int modes1 = lc.lookupModes(); | |
| boolean r = false; | |
| if (modes1 == 0) { | |
| r = false; | |
| } else { | |
| if (Modifier.isPublic(c2.getModifiers())) { | |
| if ((modes1 & MODULE) != 0) | |
| r = true; | |
| else if ((modes1 & PUBLIC) != 0) | |
| r = m1.isExported(c2.getPackageName()); | |
| } else { | |
| if ((modes1 & PACKAGE) != 0 && c1.getPackage() == c2.getPackage()) | |
| r = true; | |
| } | |
| } | |
| if (verbosity >= 2) { | |
| System.out.println(this+" willAccessClass "+lc+" c1="+c1+" c2="+c2+" => "+r); | |
| } | |
| return r; | |
| } | |
| } | |
| private static Class<?> topLevelClass(Class<?> cls) { | |
| Class<?> c = cls; | |
| for (Class<?> ec; (ec = c.getEnclosingClass()) != null; ) | |
| c = ec; | |
| assert(c.getEnclosingClass() == null); | |
| assert(c == cls || cls.getEnclosingClass() != null); | |
| return c; | |
| } | |
| private final TreeSet<LookupCase> CASES = new TreeSet<>(); | |
| private final TreeMap<LookupCase,TreeSet<LookupCase>> CASE_EDGES = new TreeMap<>(); | |
| private final ArrayList<ClassLoader> LOADERS = new ArrayList<>(); | |
| private final ClassLoader THIS_LOADER = this.getClass().getClassLoader(); | |
| { if (THIS_LOADER != null) LOADERS.add(THIS_LOADER); } // #1 | |
| private LookupCase lookupCase(String name) { | |
| for (LookupCase lc : CASES) { | |
| if (lc.toString().equals(name)) | |
| return lc; | |
| } | |
| throw new AssertionError(name); | |
| } | |
| private int numberOf(ClassLoader cl) { | |
| if (cl == null) return 0; | |
| int i = LOADERS.indexOf(cl); | |
| if (i < 0) { | |
| i = LOADERS.size(); | |
| LOADERS.add(cl); | |
| } | |
| return i+1; | |
| } | |
| private void addLookupEdge(LookupCase l1, Class<?> c2, LookupCase l2, int dropAccess) { | |
| TreeSet<LookupCase> edges = CASE_EDGES.get(l2); | |
| if (edges == null) CASE_EDGES.put(l2, edges = new TreeSet<>()); | |
| if (edges.add(l1)) { | |
| Class<?> c1 = l1.lookupClass(); | |
| assert(l2.lookupClass() == c2); // [A1] | |
| int m1 = l1.lookupModes(); | |
| int m2 = l2.lookupModes(); | |
| assert((m1 | m2) == m1); // [A2] (no elevation of access) | |
| LookupCase expect = dropAccess == 0 ? l1.in(c2) : l1.in(c2).dropLookupMode(dropAccess); | |
| if (!expect.equals(l2)) | |
| System.out.println("*** expect "+l1+" => "+expect+" but got "+l2); | |
| assertEquals(l2, expect); | |
| } | |
| } | |
| private void makeCases(Lookup[] originalLookups) { | |
| // make initial set of lookup test cases | |
| CASES.clear(); LOADERS.clear(); CASE_EDGES.clear(); | |
| ArrayList<Class<?>> classes = new ArrayList<>(); | |
| for (Lookup l : originalLookups) { | |
| CASES.add(new LookupCase(l)); | |
| classes.remove(l.lookupClass()); // no dups please | |
| classes.add(l.lookupClass()); | |
| } | |
| System.out.println("loaders = "+LOADERS); | |
| int rounds = 0; | |
| for (int lastCount = -1; lastCount != CASES.size(); ) { | |
| lastCount = CASES.size(); // if CASES grow in the loop we go round again | |
| for (LookupCase lc1 : CASES.toArray(new LookupCase[0])) { | |
| for (int mode : ACCESS_CASES) { | |
| LookupCase lc2 = new LookupCase(lc1.lookup().dropLookupMode(mode)); | |
| addLookupEdge(lc1, lc1.lookupClass(), lc2, mode); | |
| CASES.add(lc2); | |
| } | |
| for (Class<?> c2 : classes) { | |
| LookupCase lc2 = new LookupCase(lc1.lookup().in(c2)); | |
| addLookupEdge(lc1, c2, lc2, 0); | |
| CASES.add(lc2); | |
| } | |
| } | |
| rounds++; | |
| } | |
| System.out.println("filled in "+CASES.size()+" cases from "+originalLookups.length+" original cases in "+rounds+" rounds"); | |
| if (false) { | |
| System.out.println("CASES: {"); | |
| for (LookupCase lc : CASES) { | |
| System.out.println(lc); | |
| Set<LookupCase> edges = CASE_EDGES.get(lc); | |
| if (edges != null) | |
| for (LookupCase prev : edges) { | |
| System.out.println("\t"+prev); | |
| } | |
| } | |
| System.out.println("}"); | |
| } | |
| } | |
| @Test public void test() { | |
| makeCases(lookups()); | |
| if (verbosity > 0) { | |
| verbosity += 9; | |
| Method pro_in_self = targetMethod(THIS_CLASS, PROTECTED, methodType(void.class)); | |
| testOneAccess(lookupCase("AccessControlTest/module"), pro_in_self, "find"); | |
| testOneAccess(lookupCase("Remote_subclass/module"), pro_in_self, "find"); | |
| testOneAccess(lookupCase("Remote_subclass"), pro_in_self, "find"); | |
| verbosity -= 9; | |
| } | |
| Set<Class<?>> targetClassesDone = new HashSet<>(); | |
| for (LookupCase targetCase : CASES) { | |
| Class<?> targetClass = targetCase.lookupClass(); | |
| if (!targetClassesDone.add(targetClass)) continue; // already saw this one | |
| String targetPlace = placeName(targetClass); | |
| if (targetPlace == null) continue; // Object, String, not a target | |
| for (int targetAccess : ACCESS_CASES) { | |
| if (targetAccess == MODULE || targetAccess == UNCONDITIONAL) | |
| continue; | |
| MethodType methodType = methodType(void.class); | |
| Method method = targetMethod(targetClass, targetAccess, methodType); | |
| // Try to access target method from various contexts. | |
| for (LookupCase sourceCase : CASES) { | |
| testOneAccess(sourceCase, method, "findClass"); | |
| testOneAccess(sourceCase, method, "accessClass"); | |
| testOneAccess(sourceCase, method, "find"); | |
| testOneAccess(sourceCase, method, "unreflect"); | |
| } | |
| } | |
| } | |
| System.out.println("tested "+testCount+" access scenarios; "+testCountFails+" accesses were denied"); | |
| } | |
| private int testCount, testCountFails; | |
| private void testOneAccess(LookupCase sourceCase, Method method, String kind) { | |
| Class<?> targetClass = method.getDeclaringClass(); | |
| String methodName = method.getName(); | |
| MethodType methodType = methodType(method.getReturnType(), method.getParameterTypes()); | |
| boolean isFindOrAccessClass = "findClass".equals(kind) || "accessClass".equals(kind); | |
| boolean willAccess = isFindOrAccessClass ? | |
| sourceCase.willAccessClass(targetClass, "findClass".equals(kind)) : sourceCase.willAccess(method); | |
| boolean didAccess = false; | |
| ReflectiveOperationException accessError = null; | |
| try { | |
| switch (kind) { | |
| case "accessClass": | |
| sourceCase.lookup().accessClass(targetClass); | |
| break; | |
| case "findClass": | |
| sourceCase.lookup().findClass(targetClass.getName()); | |
| break; | |
| case "find": | |
| if ((method.getModifiers() & Modifier.STATIC) != 0) | |
| sourceCase.lookup().findStatic(targetClass, methodName, methodType); | |
| else | |
| sourceCase.lookup().findVirtual(targetClass, methodName, methodType); | |
| break; | |
| case "unreflect": | |
| sourceCase.lookup().unreflect(method); | |
| break; | |
| default: | |
| throw new AssertionError(kind); | |
| } | |
| didAccess = true; | |
| } catch (ReflectiveOperationException ex) { | |
| accessError = ex; | |
| } | |
| if (willAccess != didAccess) { | |
| System.out.println(sourceCase+" => "+targetClass.getSimpleName()+(isFindOrAccessClass?"":"."+methodName+methodType)); | |
| System.out.println("fail "+(isFindOrAccessClass?kind:"on "+method)+" ex="+accessError); | |
| assertEquals(willAccess, didAccess); | |
| } | |
| testCount++; | |
| if (!didAccess) testCountFails++; | |
| } | |
| static Method targetMethod(Class<?> targetClass, int targetAccess, MethodType methodType) { | |
| String methodName = accessName(targetAccess)+placeName(targetClass); | |
| if (verbosity >= 2) | |
| System.out.println(targetClass.getSimpleName()+"."+methodName+methodType); | |
| try { | |
| Method method = targetClass.getDeclaredMethod(methodName, methodType.parameterArray()); | |
| assertEquals(method.getReturnType(), methodType.returnType()); | |
| int haveMods = method.getModifiers(); | |
| assert(Modifier.isStatic(haveMods)); | |
| assert(targetAccess == fixMods(haveMods)); | |
| return method; | |
| } catch (NoSuchMethodException ex) { | |
| throw new AssertionError(methodName, ex); | |
| } | |
| } | |
| static String placeName(Class<?> cls) { | |
| // return "self", "sibling", "nestmate", etc. | |
| if (cls == AccessControlTest.class) return "self"; | |
| String cln = cls.getSimpleName(); | |
| int under = cln.lastIndexOf('_'); | |
| if (under < 0) return null; | |
| return cln.substring(under+1); | |
| } | |
| static String accessName(int acc) { | |
| switch (acc) { | |
| case PUBLIC: return "pub_in_"; | |
| case PROTECTED: return "pro_in_"; | |
| case PACKAGE: return "pkg_in_"; | |
| case PRIVATE: return "pri_in_"; | |
| } | |
| assert(false); | |
| return "?"; | |
| } | |
| private static final int[] ACCESS_CASES = { | |
| PUBLIC, PACKAGE, PRIVATE, PROTECTED, MODULE, UNCONDITIONAL | |
| }; | |
| /* | |
| * Adjust PUBLIC => PUBLIC|MODULE|UNCONDITIONAL | |
| * Adjust 0 => PACKAGE | |
| */ | |
| /** Return one of the ACCESS_CASES. */ | |
| static int fixMods(int mods) { | |
| mods &= (PUBLIC|PRIVATE|PROTECTED); | |
| switch (mods) { | |
| case PUBLIC: case PRIVATE: case PROTECTED: return mods; | |
| case 0: return PACKAGE; | |
| } | |
| throw new AssertionError(mods); | |
| } | |
| static Lookup[] lookups() { | |
| ArrayList<Lookup> tem = new ArrayList<>(); | |
| Collections.addAll(tem, | |
| AccessControlTest.lookup_in_self(), | |
| Inner_nestmate.lookup_in_nestmate(), | |
| AccessControlTest_sibling.lookup_in_sibling()); | |
| if (true) { | |
| Collections.addAll(tem,Acquaintance_remote.lookups()); | |
| } else { | |
| try { | |
| Class<?> remc = Class.forName("test.java.lang.invoke.AccessControlTest_subpkg.Acquaintance_remote"); | |
| Lookup[] remls = (Lookup[]) remc.getMethod("lookups").invoke(null); | |
| Collections.addAll(tem, remls); | |
| } catch (ReflectiveOperationException ex) { | |
| throw new LinkageError("reflection failed", ex); | |
| } | |
| } | |
| tem.add(publicLookup()); | |
| tem.add(publicLookup().in(String.class)); | |
| tem.add(publicLookup().in(List.class)); | |
| return tem.toArray(new Lookup[0]); | |
| } | |
| static Lookup lookup_in_self() { | |
| return MethodHandles.lookup(); | |
| } | |
| public static void pub_in_self() { } | |
| protected static void pro_in_self() { } | |
| static /*package*/ void pkg_in_self() { } | |
| private static void pri_in_self() { } | |
| static class Inner_nestmate { | |
| static Lookup lookup_in_nestmate() { | |
| return MethodHandles.lookup(); | |
| } | |
| public static void pub_in_nestmate() { } | |
| protected static void pro_in_nestmate() { } | |
| static /*package*/ void pkg_in_nestmate() { } | |
| private static void pri_in_nestmate() { } | |
| } | |
| } | |
| class AccessControlTest_sibling { | |
| static Lookup lookup_in_sibling() { | |
| return MethodHandles.lookup(); | |
| } | |
| public static void pub_in_sibling() { } | |
| protected static void pro_in_sibling() { } | |
| static /*package*/ void pkg_in_sibling() { } | |
| private static void pri_in_sibling() { } | |
| } | |
| // This guy tests access from outside the package: | |
| /* | |
| package test.java.lang.invoke.AccessControlTest_subpkg; | |
| public class Acquaintance_remote { | |
| public static Lookup[] lookups() { ... | |
| } | |
| ... | |
| } | |
| */ |