1 /*
  2  * Copyright (c) 2017, 2023, 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 /* @test
 25  * @modules java.base/java.lang:open
 26  * @enablePreview
 27  * @run testng/othervm test.DefineClassTest
 28  * @summary Basic test for java.lang.invoke.MethodHandles.Lookup.defineClass
 29  */
 30 
 31 package test;
 32 
 33 import java.lang.classfile.ClassFile;
 34 import java.lang.constant.ClassDesc;
 35 import java.lang.invoke.MethodHandles.Lookup;
 36 import java.lang.reflect.AccessFlag;
 37 import java.net.URL;
 38 import java.net.URLClassLoader;
 39 import java.nio.file.Files;
 40 import java.nio.file.Path;
 41 import java.nio.file.Paths;
 42 import org.testng.annotations.Test;
 43 
 44 import static java.lang.classfile.ClassFile.ACC_PUBLIC;
 45 import static java.lang.classfile.ClassFile.ACC_STATIC;
 46 import static java.lang.constant.ConstantDescs.CD_Object;
 47 import static java.lang.constant.ConstantDescs.CLASS_INIT_NAME;
 48 import static java.lang.constant.ConstantDescs.INIT_NAME;
 49 import static java.lang.constant.ConstantDescs.MTD_void;
 50 import static java.lang.invoke.MethodHandles.*;
 51 import static java.lang.invoke.MethodHandles.Lookup.*;
 52 import static org.testng.Assert.*;
 53 
 54 public class DefineClassTest {
 55     private static final String THIS_PACKAGE = DefineClassTest.class.getPackageName();
 56     private static final ClassDesc CD_Runnable = Runnable.class.describeConstable().orElseThrow();
 57     private static final ClassDesc CD_MissingSuperClass = ClassDesc.of("MissingSuperClass");
 58 
 59     /**
 60      * Test that a class has the same class loader, and is in the same package and
 61      * protection domain, as a lookup class.
 62      */
 63     void testSameAbode(Class<?> clazz, Class<?> lc) {
 64         assertTrue(clazz.getClassLoader() == lc.getClassLoader());
 65         assertEquals(clazz.getPackageName(), lc.getPackageName());
 66         assertTrue(clazz.getProtectionDomain() == lc.getProtectionDomain());
 67     }
 68 
 69     /**
 70      * Tests that a class is discoverable by name using Class.forName and
 71      * lookup.findClass
 72      */
 73     void testDiscoverable(Class<?> clazz, Lookup lookup) throws Exception {
 74         String cn = clazz.getName();
 75         ClassLoader loader = clazz.getClassLoader();
 76         assertTrue(Class.forName(cn, false, loader) == clazz);
 77         assertTrue(lookup.findClass(cn) == clazz);
 78     }
 79 
 80     /**
 81      * Basic test of defineClass to define a class in the same package as test.
 82      */
 83     @Test
 84     public void testDefineClass() throws Exception {
 85         final String CLASS_NAME = THIS_PACKAGE + ".Foo";
 86         Lookup lookup = lookup();
 87         Class<?> clazz = lookup.defineClass(generateClass(CLASS_NAME));
 88 
 89         // test name
 90         assertEquals(clazz.getName(), CLASS_NAME);
 91 
 92         // test loader/package/protection-domain
 93         testSameAbode(clazz, lookup.lookupClass());
 94 
 95         // test discoverable
 96         testDiscoverable(clazz, lookup);
 97 
 98         // attempt defineClass again
 99         try {
100             lookup.defineClass(generateClass(CLASS_NAME));
101             assertTrue(false);
102         } catch (LinkageError expected) { }
103     }
104 
105     /**
106      * Test public/package/protected/private access from class defined with defineClass.
107      */
108     @Test
109     public void testAccess() throws Exception {
110         final String THIS_CLASS = this.getClass().getName();
111         final String CLASS_NAME = THIS_PACKAGE + ".Runner";
112         Lookup lookup = lookup();
113 
114         // public
115         byte[] classBytes = generateRunner(CLASS_NAME + nextNumber(), THIS_CLASS, "method1");
116         testInvoke(lookup.defineClass(classBytes));
117 
118         // package
119         classBytes = generateRunner(CLASS_NAME + nextNumber(), THIS_CLASS, "method2");
120         testInvoke(lookup.defineClass(classBytes));
121 
122         // protected (same package)
123         classBytes = generateRunner(CLASS_NAME + nextNumber(), THIS_CLASS, "method3");
124         testInvoke(lookup.defineClass(classBytes));
125 
126         // private
127         classBytes = generateRunner(CLASS_NAME + nextNumber(), THIS_CLASS, "method4");
128         Class<?> clazz = lookup.defineClass(classBytes);
129         Runnable r = (Runnable) clazz.newInstance();
130         try {
131             r.run();
132             assertTrue(false);
133         } catch (IllegalAccessError expected) { }
134     }
135 
136     public static void method1() { }
137     static void method2() { }
138     protected static void method3() { }
139     private static void method4() { }
140 
141     void testInvoke(Class<?> clazz) throws Exception {
142         Object obj = clazz.newInstance();
143         ((Runnable) obj).run();
144     }
145 
146     /**
147      * Test that defineClass does not run the class initializer
148      */
149     @Test
150     public void testInitializerNotRun() throws Exception {
151         final String THIS_CLASS = this.getClass().getName();
152         final String CLASS_NAME = THIS_PACKAGE + ".ClassWithClinit";
153 
154         byte[] classBytes = generateClassWithInitializer(CLASS_NAME, THIS_CLASS, "fail");
155         Class<?> clazz = lookup().defineClass(classBytes);
156 
157         // trigger initializer to run
158         try {
159             clazz.newInstance();
160             assertTrue(false);
161         } catch (ExceptionInInitializerError e) {
162             assertTrue(e.getCause() instanceof IllegalCallerException);
163         }
164     }
165 
166     static void fail() { throw new IllegalCallerException(); }
167 
168 
169     /**
170      * Test defineClass to define classes in a package containing classes with
171      * different protection domains.
172      */
173     @Test
174     public void testTwoProtectionDomains() throws Exception {
175         Path here = Paths.get("");
176 
177         // p.C1 in one exploded directory
178         Path dir1 = Files.createTempDirectory(here, "classes");
179         Path p = Files.createDirectory(dir1.resolve("p"));
180         Files.write(p.resolve("C1.class"), generateClass("p.C1"));
181         URL url1 = dir1.toUri().toURL();
182 
183         // p.C2 in another exploded directory
184         Path dir2 = Files.createTempDirectory(here, "classes");
185         p = Files.createDirectory(dir2.resolve("p"));
186         Files.write(p.resolve("C2.class"), generateClass("p.C2"));
187         URL url2 = dir2.toUri().toURL();
188 
189         // load p.C1 and p.C2
190         ClassLoader loader = new URLClassLoader(new URL[] { url1, url2 });
191         Class<?> target1 = Class.forName("p.C1", false, loader);
192         Class<?> target2 = Class.forName("p.C2", false, loader);
193         assertTrue(target1.getClassLoader() == loader);
194         assertTrue(target1.getClassLoader() == loader);
195         assertNotEquals(target1.getProtectionDomain(), target2.getProtectionDomain());
196 
197         // protection domain 1
198         Lookup lookup1 = privateLookupIn(target1, lookup());
199 
200         Class<?> clazz = lookup1.defineClass(generateClass("p.Foo"));
201         testSameAbode(clazz, lookup1.lookupClass());
202         testDiscoverable(clazz, lookup1);
203 
204         // protection domain 2
205         Lookup lookup2 = privateLookupIn(target2, lookup());
206 
207         clazz = lookup2.defineClass(generateClass("p.Bar"));
208         testSameAbode(clazz, lookup2.lookupClass());
209         testDiscoverable(clazz, lookup2);
210     }
211 
212     /**
213      * Test defineClass defining a class to the boot loader
214      */
215     @Test
216     public void testBootLoader() throws Exception {
217         Lookup lookup = privateLookupIn(Thread.class, lookup());
218         assertTrue(lookup.getClass().getClassLoader() == null);
219 
220         Class<?> clazz = lookup.defineClass(generateClass("java.lang.Foo"));
221         assertEquals(clazz.getName(), "java.lang.Foo");
222         testSameAbode(clazz, Thread.class);
223         testDiscoverable(clazz, lookup);
224     }
225 
226     @Test(expectedExceptions = { IllegalArgumentException.class })
227     public void testWrongPackage() throws Exception {
228         lookup().defineClass(generateClass("other.C"));
229     }
230 
231     @Test(expectedExceptions = { IllegalAccessException.class })
232     public void testNoPackageAccess() throws Exception {
233         Lookup lookup = lookup().dropLookupMode(PACKAGE);
234         lookup.defineClass(generateClass(THIS_PACKAGE + ".C"));
235     }
236 
237     @Test(expectedExceptions = { ClassFormatError.class })
238     public void testTruncatedClassFile() throws Exception {
239         lookup().defineClass(new byte[0]);
240     }
241 
242     @Test(expectedExceptions = { NullPointerException.class })
243     public void testNull() throws Exception {
244         lookup().defineClass(null);
245     }
246 
247     @Test(expectedExceptions = { NoClassDefFoundError.class })
248     public void testLinking() throws Exception {
249         lookup().defineClass(generateNonLinkableClass(THIS_PACKAGE + ".NonLinkableClass"));
250     }
251 
252     @Test(expectedExceptions = { IllegalArgumentException.class })
253     public void testModuleInfo() throws Exception {
254         lookup().defineClass(generateModuleInfo());
255     }
256 
257     /**
258      * Generates a class file with the given class name
259      */
260     byte[] generateClass(String className) {
261         return ClassFile.of().build(ClassDesc.of(className), clb -> {
262             clb.withFlags(AccessFlag.PUBLIC, AccessFlag.IDENTITY);
263             clb.withSuperclass(CD_Object);
264             clb.withMethodBody(INIT_NAME, MTD_void, PUBLIC, cob -> {
265                 cob.aload(0);
266                 cob.invokespecial(CD_Object, INIT_NAME, MTD_void);
267                 cob.return_();
268             });
269         });
270     }
271 
272     /**
273      * Generate a class file with the given class name. The class implements Runnable
274      * with a run method to invokestatic the given targetClass/targetMethod.
275      */
276     byte[] generateRunner(String className,
277                           String targetClass,
278                           String targetMethod) throws Exception {
279 
280         return ClassFile.of().build(ClassDesc.of(className), clb -> {
281             clb.withSuperclass(CD_Object);
282             clb.withInterfaceSymbols(CD_Runnable);
283             clb.withMethodBody(INIT_NAME, MTD_void, PUBLIC, cob -> {
284                 cob.aload(0);
285                 cob.invokespecial(CD_Object, INIT_NAME, MTD_void);
286                 cob.return_();
287             });
288             clb.withMethodBody("run", MTD_void, PUBLIC, cob -> {
289                 cob.invokestatic(ClassDesc.of(targetClass), targetMethod, MTD_void);
290                 cob.return_();
291             });
292         });
293     }
294 
295     /**
296      * Generate a class file with the given class name. The class will initializer
297      * to invokestatic the given targetClass/targetMethod.
298      */
299     byte[] generateClassWithInitializer(String className,
300                                         String targetClass,
301                                         String targetMethod) throws Exception {
302 
303         return ClassFile.of().build(ClassDesc.of(className), clb -> {
304             clb.withFlags(AccessFlag.PUBLIC, AccessFlag.IDENTITY);
305             clb.withSuperclass(CD_Object);
306             clb.withMethodBody(INIT_NAME, MTD_void, ACC_PUBLIC, cob -> {
307                 cob.aload(0);
308                 cob.invokespecial(CD_Object, INIT_NAME, MTD_void);
309                 cob.return_();
310             });
311             clb.withMethodBody(CLASS_INIT_NAME, MTD_void, ACC_STATIC, cob -> {
312                 cob.invokestatic(ClassDesc.of(targetClass), targetMethod, MTD_void);
313                 cob.return_();
314             });
315         });
316     }
317 
318     /**
319      * Generates a non-linkable class file with the given class name
320      */
321     byte[] generateNonLinkableClass(String className) {
322         return ClassFile.of().build(ClassDesc.of(className), clb -> {
323             clb.withFlags(AccessFlag.PUBLIC, AccessFlag.IDENTITY);
324             clb.withSuperclass(CD_MissingSuperClass);
325             clb.withMethodBody(INIT_NAME, MTD_void, ACC_PUBLIC, cob -> {
326                 cob.aload(0);
327                 cob.invokespecial(CD_MissingSuperClass, INIT_NAME, MTD_void);
328                 cob.return_();
329             });
330         });
331     }
332 
333     /**
334      * Generates a class file with the given class name
335      */
336     byte[] generateModuleInfo() {
337         return ClassFile.of().build(ClassDesc.of("module-info"), cb -> cb.withFlags(AccessFlag.MODULE));
338     }
339 
340     private int nextNumber() {
341         return ++nextNumber;
342     }
343 
344     private int nextNumber;
345 }