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 }
|