< prev index next >

test/java/lang/invoke/DefineClassTest.java

Print this page




  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  *          java.base/jdk.internal.org.objectweb.asm
  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.invoke.MethodHandles.Lookup;
  34 import static java.lang.invoke.MethodHandles.*;
  35 import static java.lang.invoke.MethodHandles.Lookup.*;
  36 import java.net.URL;
  37 import java.net.URLClassLoader;
  38 import java.nio.file.Files;
  39 import java.nio.file.Path;

  40 
  41 import jdk.internal.org.objectweb.asm.ClassWriter;
  42 import jdk.internal.org.objectweb.asm.MethodVisitor;
  43 import static jdk.internal.org.objectweb.asm.Opcodes.*;
  44 
  45 import org.testng.annotations.Test;
  46 import static org.testng.Assert.*;
  47 
  48 public class DefineClassTest {
  49     private static final String THIS_PACKAGE = DefineClassTest.class.getPackageName();
  50 
  51     /**
  52      * Test that a class has the same class loader, and is in the same package and
  53      * protection domain, as a lookup class.
  54      */
  55     void testSameAbode(Class<?> clazz, Class<?> lc) {
  56         assertTrue(clazz.getClassLoader() == lc.getClassLoader());
  57         assertEquals(clazz.getPackageName(), lc.getPackageName());
  58         assertTrue(clazz.getProtectionDomain() == lc.getProtectionDomain());
  59     }


 147         Class<?> clazz = lookup().defineClass(classBytes);
 148 
 149         // trigger initializer to run
 150         try {
 151             clazz.newInstance();
 152             assertTrue(false);
 153         } catch (ExceptionInInitializerError e) {
 154             assertTrue(e.getCause() instanceof IllegalCallerException);
 155         }
 156     }
 157 
 158     static void fail() { throw new IllegalCallerException(); }
 159 
 160 
 161     /**
 162      * Test defineClass to define classes in a package containing classes with
 163      * different protection domains.
 164      */
 165     @Test
 166     public void testTwoProtectionDomains() throws Exception {


 167         // p.C1 in one exploded directory
 168         Path dir1 = Files.createTempDirectory("classes");
 169         Path p = Files.createDirectory(dir1.resolve("p"));
 170         Files.write(p.resolve("C1.class"), generateClass("p.C1"));
 171         URL url1 = dir1.toUri().toURL();
 172 
 173         // p.C2 in another exploded directory
 174         Path dir2 = Files.createTempDirectory("classes");
 175         p = Files.createDirectory(dir2.resolve("p"));
 176         Files.write(p.resolve("C2.class"), generateClass("p.C2"));
 177         URL url2 = dir2.toUri().toURL();
 178 
 179         // load p.C1 and p.C2
 180         ClassLoader loader = new URLClassLoader(new URL[] { url1, url2 });
 181         Class<?> target1 = Class.forName("p.C1", false, loader);
 182         Class<?> target2 = Class.forName("p.C2", false, loader);
 183         assertTrue(target1.getClassLoader() == loader);
 184         assertTrue(target1.getClassLoader() == loader);
 185         assertNotEquals(target1.getProtectionDomain(), target2.getProtectionDomain());
 186 
 187         // protection domain 1
 188         Lookup lookup1 = privateLookupIn(target1, lookup());
 189 
 190         Class<?> clazz = lookup1.defineClass(generateClass("p.Foo"));
 191         testSameAbode(clazz, lookup1.lookupClass());
 192         testDiscoverable(clazz, lookup1);
 193 
 194         // protection domain 2




  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  *          java.base/jdk.internal.org.objectweb.asm
  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.invoke.MethodHandles.Lookup;
  34 import static java.lang.invoke.MethodHandles.*;
  35 import static java.lang.invoke.MethodHandles.Lookup.*;
  36 import java.net.URL;
  37 import java.net.URLClassLoader;
  38 import java.nio.file.Files;
  39 import java.nio.file.Path;
  40 import java.nio.file.Paths;
  41 
  42 import jdk.internal.org.objectweb.asm.ClassWriter;
  43 import jdk.internal.org.objectweb.asm.MethodVisitor;
  44 import static jdk.internal.org.objectweb.asm.Opcodes.*;
  45 
  46 import org.testng.annotations.Test;
  47 import static org.testng.Assert.*;
  48 
  49 public class DefineClassTest {
  50     private static final String THIS_PACKAGE = DefineClassTest.class.getPackageName();
  51 
  52     /**
  53      * Test that a class has the same class loader, and is in the same package and
  54      * protection domain, as a lookup class.
  55      */
  56     void testSameAbode(Class<?> clazz, Class<?> lc) {
  57         assertTrue(clazz.getClassLoader() == lc.getClassLoader());
  58         assertEquals(clazz.getPackageName(), lc.getPackageName());
  59         assertTrue(clazz.getProtectionDomain() == lc.getProtectionDomain());
  60     }


 148         Class<?> clazz = lookup().defineClass(classBytes);
 149 
 150         // trigger initializer to run
 151         try {
 152             clazz.newInstance();
 153             assertTrue(false);
 154         } catch (ExceptionInInitializerError e) {
 155             assertTrue(e.getCause() instanceof IllegalCallerException);
 156         }
 157     }
 158 
 159     static void fail() { throw new IllegalCallerException(); }
 160 
 161 
 162     /**
 163      * Test defineClass to define classes in a package containing classes with
 164      * different protection domains.
 165      */
 166     @Test
 167     public void testTwoProtectionDomains() throws Exception {
 168         Path here = Paths.get("");
 169 
 170         // p.C1 in one exploded directory
 171         Path dir1 = Files.createTempDirectory(here, "classes");
 172         Path p = Files.createDirectory(dir1.resolve("p"));
 173         Files.write(p.resolve("C1.class"), generateClass("p.C1"));
 174         URL url1 = dir1.toUri().toURL();
 175 
 176         // p.C2 in another exploded directory
 177         Path dir2 = Files.createTempDirectory(here, "classes");
 178         p = Files.createDirectory(dir2.resolve("p"));
 179         Files.write(p.resolve("C2.class"), generateClass("p.C2"));
 180         URL url2 = dir2.toUri().toURL();
 181 
 182         // load p.C1 and p.C2
 183         ClassLoader loader = new URLClassLoader(new URL[] { url1, url2 });
 184         Class<?> target1 = Class.forName("p.C1", false, loader);
 185         Class<?> target2 = Class.forName("p.C2", false, loader);
 186         assertTrue(target1.getClassLoader() == loader);
 187         assertTrue(target1.getClassLoader() == loader);
 188         assertNotEquals(target1.getProtectionDomain(), target2.getProtectionDomain());
 189 
 190         // protection domain 1
 191         Lookup lookup1 = privateLookupIn(target1, lookup());
 192 
 193         Class<?> clazz = lookup1.defineClass(generateClass("p.Foo"));
 194         testSameAbode(clazz, lookup1.lookupClass());
 195         testDiscoverable(clazz, lookup1);
 196 
 197         // protection domain 2


< prev index next >