1 /* 2 * Copyright (c) 2018, 2022, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 /* 25 * @test 26 * @bug 8202113 27 * @summary Test the caller class loader is not kept strongly reachable 28 * by reflection API 29 * @library /test/lib/ 30 * @modules jdk.compiler 31 * @build ReflectionCallerCacheTest Members jdk.test.lib.compiler.CompilerUtils 32 * @run testng/othervm ReflectionCallerCacheTest 33 */ 34 35 import java.io.IOException; 36 import java.lang.ref.WeakReference; 37 import java.lang.reflect.*; 38 import java.net.MalformedURLException; 39 import java.net.URL; 40 import java.net.URLClassLoader; 41 import java.nio.file.Path; 42 import java.nio.file.Paths; 43 import java.util.concurrent.Callable; 44 45 import jdk.test.lib.compiler.CompilerUtils; 46 import jdk.test.lib.util.ForceGC; 47 import org.testng.annotations.BeforeTest; 48 import org.testng.annotations.DataProvider; 49 import org.testng.annotations.Test; 50 51 public class ReflectionCallerCacheTest { 52 private static final Path CLASSES = Paths.get("classes"); 53 private static final ReflectionCallerCacheTest TEST = new ReflectionCallerCacheTest(); 54 55 @BeforeTest 56 public void setup() throws IOException { 57 String src = System.getProperty("test.src", "."); 58 String classpath = System.getProperty("test.classes", "."); 59 boolean rc = CompilerUtils.compile(Paths.get(src, "AccessTest.java"), CLASSES, "-cp", classpath); 60 if (!rc) { 61 throw new RuntimeException("fail compilation"); 62 } 63 } 64 @DataProvider(name = "memberAccess") 65 public Object[][] memberAccess() { 66 return new Object[][] { 67 { "AccessTest$PublicConstructor" }, 68 { "AccessTest$PublicMethod" }, 69 { "AccessTest$PublicField" }, 70 { "AccessTest$ProtectedMethod" }, 71 { "AccessTest$ProtectedField" }, 72 { "AccessTest$PrivateMethod" }, 73 { "AccessTest$PrivateField"}, 74 { "AccessTest$PublicFinalField"}, 75 { "AccessTest$PrivateFinalField"}, 76 { "AccessTest$PublicStaticFinalField"}, 77 { "AccessTest$PrivateStaticFinalField"}, 78 { "AccessTest$NewInstance"} 79 }; 80 } 81 82 // Keep the root of the reflective objects strongly reachable 83 private final Constructor<?> publicConstructor; 84 private final Method publicMethod; 85 private final Method protectedMethod; 86 private final Method privateMethod; 87 private final Field publicField; 88 private final Field protectedField; 89 private final Field privateField; 90 91 ReflectionCallerCacheTest() { 92 try { 93 this.publicConstructor = Members.class.getConstructor(); 94 this.publicMethod = Members.class.getDeclaredMethod("publicMethod"); 95 this.publicField = Members.class.getDeclaredField("publicField"); 96 this.protectedMethod = Members.class.getDeclaredMethod("protectedMethod"); 97 this.protectedField = Members.class.getDeclaredField("protectedField"); 98 this.privateMethod = Members.class.getDeclaredMethod("privateMethod"); 99 this.privateField = Members.class.getDeclaredField("privateField"); 100 } catch (ReflectiveOperationException e) { 101 throw new RuntimeException(e); 102 } 103 } 104 105 @Test(dataProvider = "memberAccess") 106 private void load(String classname) throws Exception { 107 WeakReference<?> weakLoader = loadAndRunClass(classname); 108 109 // Force garbage collection to trigger unloading of class loader 110 if (!ForceGC.wait(() -> weakLoader.refersTo(null))) { 111 throw new RuntimeException("Class " + classname + " not unloaded!"); 112 } 113 } 114 115 private WeakReference<?> loadAndRunClass(String classname) throws Exception { 116 try (TestLoader loader = new TestLoader()) { 117 // Load member access class with custom class loader 118 Class<?> c = Class.forName(classname, true, loader); 119 // access the reflective member 120 Callable callable = (Callable) c.newInstance(); 121 callable.call(); 122 return new WeakReference<>(loader); 123 } 124 } 125 126 static class TestLoader extends URLClassLoader { 127 static URL[] toURLs() { 128 try { 129 return new URL[] { CLASSES.toUri().toURL() }; 130 } catch (MalformedURLException e) { 131 throw new Error(e); 132 } 133 } 134 135 TestLoader() { 136 super("testloader", toURLs(), ClassLoader.getSystemClassLoader()); 137 } 138 } 139 }