48 
  49     private static Unsafe UNSAFE = getUnsafe();
  50     private static final Class<?> HIDDEN_CLASS = defineHiddenClass();
  51 
  52     private static Unsafe getUnsafe() {
  53         try {
  54             Field f = Unsafe.class.getDeclaredField("theUnsafe");
  55             f.setAccessible(true);
  56             return (Unsafe) f.get(null);
  57         } catch (ReflectiveOperationException e) {
  58             throw new RuntimeException(e);
  59         }
  60     }
  61 
  62     private static Class<?> defineHiddenClass() {
  63         String classes = System.getProperty("test.classes");
  64         Path cf = Paths.get(classes, "UnsafeFieldOffsets$Fields.class");
  65         try {
  66             byte[] bytes = Files.readAllBytes(cf);
  67             Class<?> c = MethodHandles.lookup().defineHiddenClass(bytes, true).lookupClass();
  68             if (!c.isHiddenClass())
  69                 throw new RuntimeException("Expected hidden class: " + c);
  70             return c;
  71         } catch (IOException e) {
  72             throw new UncheckedIOException(e);
  73         } catch (IllegalAccessException e) {
  74             throw new RuntimeException(e);
  75         }
  76     }
  77 
  78     public static void main(String[] args) throws Exception {
  79         // non-hidden class
  80         testStaticField(Fields.class, "STATIC_FINAL");
  81         testStaticField(Fields.class, "STATIC_NON_FINAL");
  82         testInstanceField(Fields.class, "FINAL");
  83         testInstanceField(Fields.class, "NON_FINAL");
  84 
  85         // hidden class
  86         testStaticField(HIDDEN_CLASS, "STATIC_FINAL");
  87         testStaticField(HIDDEN_CLASS, "STATIC_NON_FINAL");
  88         testInstanceField(HIDDEN_CLASS, "FINAL");
  89         testInstanceField(HIDDEN_CLASS, "NON_FINAL");

  93         Field f = c.getDeclaredField(name);
  94         try {
  95             UNSAFE.staticFieldOffset(f);
  96             assertNonHiddenClass(c);
  97         } catch (UnsupportedOperationException e) {
  98             assertHiddenClass(c);
  99         }
 100     }
 101 
 102     private static void testInstanceField(Class<?> c, String name) throws Exception {
 103         Field f = c.getDeclaredField(name);
 104         try {
 105             UNSAFE.objectFieldOffset(f);
 106             assertNonHiddenClass(c);
 107         } catch (UnsupportedOperationException e) {
 108             assertHiddenClass(c);
 109         }
 110     }
 111 
 112     private static void assertNonHiddenClass(Class<?> c) {
 113         if (c.isHiddenClass())
 114             throw new RuntimeException("Expected UOE but not thrown: " + c);
 115     }
 116 
 117     private static void assertHiddenClass(Class<?> c) {
 118         if (!c.isHiddenClass())
 119             throw new RuntimeException("Expected hidden class but is not: " + c);
 120     }
 121 }

  48 
  49     private static Unsafe UNSAFE = getUnsafe();
  50     private static final Class<?> HIDDEN_CLASS = defineHiddenClass();
  51 
  52     private static Unsafe getUnsafe() {
  53         try {
  54             Field f = Unsafe.class.getDeclaredField("theUnsafe");
  55             f.setAccessible(true);
  56             return (Unsafe) f.get(null);
  57         } catch (ReflectiveOperationException e) {
  58             throw new RuntimeException(e);
  59         }
  60     }
  61 
  62     private static Class<?> defineHiddenClass() {
  63         String classes = System.getProperty("test.classes");
  64         Path cf = Paths.get(classes, "UnsafeFieldOffsets$Fields.class");
  65         try {
  66             byte[] bytes = Files.readAllBytes(cf);
  67             Class<?> c = MethodHandles.lookup().defineHiddenClass(bytes, true).lookupClass();
  68             assertHiddenClass(c);

  69             return c;
  70         } catch (IOException e) {
  71             throw new UncheckedIOException(e);
  72         } catch (IllegalAccessException e) {
  73             throw new RuntimeException(e);
  74         }
  75     }
  76 
  77     public static void main(String[] args) throws Exception {
  78         // non-hidden class
  79         testStaticField(Fields.class, "STATIC_FINAL");
  80         testStaticField(Fields.class, "STATIC_NON_FINAL");
  81         testInstanceField(Fields.class, "FINAL");
  82         testInstanceField(Fields.class, "NON_FINAL");
  83 
  84         // hidden class
  85         testStaticField(HIDDEN_CLASS, "STATIC_FINAL");
  86         testStaticField(HIDDEN_CLASS, "STATIC_NON_FINAL");
  87         testInstanceField(HIDDEN_CLASS, "FINAL");
  88         testInstanceField(HIDDEN_CLASS, "NON_FINAL");

  92         Field f = c.getDeclaredField(name);
  93         try {
  94             UNSAFE.staticFieldOffset(f);
  95             assertNonHiddenClass(c);
  96         } catch (UnsupportedOperationException e) {
  97             assertHiddenClass(c);
  98         }
  99     }
 100 
 101     private static void testInstanceField(Class<?> c, String name) throws Exception {
 102         Field f = c.getDeclaredField(name);
 103         try {
 104             UNSAFE.objectFieldOffset(f);
 105             assertNonHiddenClass(c);
 106         } catch (UnsupportedOperationException e) {
 107             assertHiddenClass(c);
 108         }
 109     }
 110 
 111     private static void assertNonHiddenClass(Class<?> c) {
 112         if (c.isHidden())
 113             throw new RuntimeException("Expected UOE but not thrown: " + c);
 114     }
 115 
 116     private static void assertHiddenClass(Class<?> c) {
 117         if (!c.isHidden())
 118             throw new RuntimeException("Expected hidden class but is not: " + c);
 119     }
 120 }