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 }