20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /**
25 * @test
26 * @requires (os.simpleArch == "x64" | os.simpleArch == "sparcv9" | os.simpleArch == "aarch64")
27 * @library ../../../../../
28 * @modules jdk.vm.ci/jdk.vm.ci.meta
29 * jdk.vm.ci/jdk.vm.ci.runtime
30 * java.base/jdk.internal.misc
31 * @build jdk.vm.ci.runtime.test.TestMetaAccessProvider
32 * @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI jdk.vm.ci.runtime.test.TestMetaAccessProvider
33 */
34
35 package jdk.vm.ci.runtime.test;
36
37 import static jdk.vm.ci.meta.MetaUtil.toInternalName;
38 import static org.junit.Assert.assertEquals;
39 import static org.junit.Assert.assertNotNull;
40 import static org.junit.Assert.assertTrue;
41
42 import java.lang.reflect.Field;
43 import java.lang.reflect.Method;
44
45 import jdk.vm.ci.meta.JavaConstant;
46 import jdk.vm.ci.meta.JavaKind;
47 import jdk.vm.ci.meta.MetaAccessProvider;
48 import jdk.vm.ci.meta.ResolvedJavaField;
49 import jdk.vm.ci.meta.ResolvedJavaMethod;
50 import jdk.vm.ci.meta.ResolvedJavaType;
51
52 import org.junit.Test;
53
54 /**
55 * Tests for {@link MetaAccessProvider}.
56 */
57 public class TestMetaAccessProvider extends TypeUniverse {
58
59 @Test
60 public void lookupJavaTypeTest() {
61 for (Class<?> c : classes) {
62 ResolvedJavaType type = metaAccess.lookupJavaType(c);
63 assertNotNull(c.toString(), type);
64 assertEquals(c.toString(), type.getName(), toInternalName(c.getName()));
65 assertEquals(c.toString(), type.getName(), toInternalName(type.toJavaName()));
66 assertEquals(c.toString(), c.getName(), type.toClassName());
67 if (!type.isArray()) {
68 assertEquals(c.toString(), c.getName(), type.toJavaName());
69 }
70 }
71 }
72
73 @Test
74 public void lookupJavaMethodTest() {
75 for (Class<?> c : classes) {
76 for (Method reflect : c.getDeclaredMethods()) {
77 ResolvedJavaMethod method = metaAccess.lookupJavaMethod(reflect);
78 assertNotNull(method);
79 assertTrue(method.getDeclaringClass().equals(metaAccess.lookupJavaType(reflect.getDeclaringClass())));
80 }
81 }
82 }
83
84 @Test
85 public void lookupJavaFieldTest() {
86 for (Class<?> c : classes) {
87 for (Field reflect : c.getDeclaredFields()) {
88 ResolvedJavaField field = metaAccess.lookupJavaField(reflect);
89 assertNotNull(field);
90 assertTrue(field.getDeclaringClass().equals(metaAccess.lookupJavaType(reflect.getDeclaringClass())));
91 }
92 }
93 }
94
95 @Test
96 public void lookupJavaTypeConstantTest() {
97 for (ConstantValue cv : constants()) {
98 JavaConstant c = cv.value;
99 if (c.getJavaKind() == JavaKind.Object && !c.isNull()) {
100 Object o = cv.boxed;
101 ResolvedJavaType type = metaAccess.lookupJavaType(c);
102 assertNotNull(type);
103 assertTrue(type.equals(metaAccess.lookupJavaType(o.getClass())));
104 } else {
105 assertEquals(metaAccess.lookupJavaType(c), null);
106 }
107 }
108 }
109 }
|
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /**
25 * @test
26 * @requires (os.simpleArch == "x64" | os.simpleArch == "sparcv9" | os.simpleArch == "aarch64")
27 * @library ../../../../../
28 * @modules jdk.vm.ci/jdk.vm.ci.meta
29 * jdk.vm.ci/jdk.vm.ci.runtime
30 * java.base/jdk.internal.misc
31 * @build jdk.vm.ci.runtime.test.TestMetaAccessProvider
32 * @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI jdk.vm.ci.runtime.test.TestMetaAccessProvider
33 */
34
35 package jdk.vm.ci.runtime.test;
36
37 import static jdk.vm.ci.meta.MetaUtil.toInternalName;
38 import static org.junit.Assert.assertEquals;
39 import static org.junit.Assert.assertNotNull;
40 import static org.junit.Assert.assertNull;
41 import static org.junit.Assert.assertTrue;
42
43 import java.lang.reflect.Field;
44 import java.lang.reflect.Method;
45 import jdk.vm.ci.meta.DeoptimizationAction;
46 import jdk.vm.ci.meta.DeoptimizationReason;
47
48 import jdk.vm.ci.meta.JavaConstant;
49 import jdk.vm.ci.meta.JavaKind;
50 import jdk.vm.ci.meta.MetaAccessProvider;
51 import jdk.vm.ci.meta.ResolvedJavaField;
52 import jdk.vm.ci.meta.ResolvedJavaMethod;
53 import jdk.vm.ci.meta.ResolvedJavaType;
54 import jdk.vm.ci.meta.Signature;
55
56 import org.junit.Test;
57
58 /**
59 * Tests for {@link MetaAccessProvider}.
60 */
61 public class TestMetaAccessProvider extends TypeUniverse {
62 private static final DeoptimizationAction DEOPT_ACTION = DeoptimizationAction.InvalidateRecompile;
63 private static final DeoptimizationReason DEOPT_REASON = DeoptimizationReason.Aliasing;
64 private static final int INT_23BITS_SET = 0x7FFFFF;
65 private static final int[] DEBUG_IDS = new int[]{0, 1, 42, INT_23BITS_SET};
66 private static final int[] VALID_ENCODED_VALUES = new int[]{
67 metaAccess.encodeDeoptActionAndReason(DEOPT_ACTION, DEOPT_REASON, DEBUG_IDS[0]).asInt(),
68 metaAccess.encodeDeoptActionAndReason(DEOPT_ACTION, DEOPT_REASON, DEBUG_IDS[1]).asInt(),
69 metaAccess.encodeDeoptActionAndReason(DEOPT_ACTION, DEOPT_REASON, DEBUG_IDS[2]).asInt(),
70 metaAccess.encodeDeoptActionAndReason(DEOPT_ACTION, DEOPT_REASON, DEBUG_IDS[3]).asInt()
71 };
72
73 @Test
74 public void lookupJavaTypeTest() {
75 for (Class<?> c : classes) {
76 ResolvedJavaType type = metaAccess.lookupJavaType(c);
77 assertNotNull(c.toString(), type);
78 assertEquals(c.toString(), type.getName(), toInternalName(c.getName()));
79 assertEquals(c.toString(), type.getName(), toInternalName(type.toJavaName()));
80 assertEquals(c.toString(), c.getName(), type.toClassName());
81 if (!type.isArray()) {
82 assertEquals(c.toString(), c.getName(), type.toJavaName());
83 }
84 }
85 }
86
87 @Test(expected = IllegalArgumentException.class)
88 public void lookupJavaTypeNegativeTest() {
89 metaAccess.lookupJavaType((Class<?>) null);
90 }
91
92 @Test
93 public void lookupJavaTypesTest() {
94 ResolvedJavaType[] result = metaAccess
95 .lookupJavaTypes(classes.toArray(new Class<?>[classes.size()]));
96 int counter = 0;
97 for (Class<?> aClass : classes) {
98 assertEquals("Unexpected javaType: " + result[counter]
99 + " while expecting of class: " + aClass,
100 result[counter].toClassName(), aClass.getName());
101 counter++;
102 }
103 }
104
105 @Test(expected = NullPointerException.class)
106 public void lookupJavaTypesNegative1Test() {
107 assertNull("Expected null", metaAccess.lookupJavaTypes(null));
108 }
109
110 @Test(expected = IllegalArgumentException.class)
111 public void lookupJavaTypesNegative2Test() {
112 ResolvedJavaType[] result = metaAccess.lookupJavaTypes(
113 new Class<?>[]{null, null, null});
114 for (ResolvedJavaType aType : result) {
115 assertNull("Expected null javaType", aType);
116 }
117 result = metaAccess.lookupJavaTypes(new Class<?>[]{String.class,
118 String.class});
119 assertEquals("Results not equals", result[0].getClass(),
120 result[1].getClass());
121 assertEquals("Result is not String.class", result[0].getClass(),
122 String.class);
123 }
124
125 @Test
126 public void lookupJavaMethodTest() {
127 for (Class<?> c : classes) {
128 for (Method reflect : c.getDeclaredMethods()) {
129 ResolvedJavaMethod method = metaAccess.lookupJavaMethod(reflect);
130 assertNotNull(method);
131 assertTrue(method.getDeclaringClass().equals(metaAccess.lookupJavaType(reflect.getDeclaringClass())));
132 }
133 }
134 }
135
136 @Test(expected = NullPointerException.class)
137 public void lookupJavaMethodNegativeTest() {
138 metaAccess.lookupJavaMethod(null);
139 }
140
141 @Test
142 public void lookupJavaFieldTest() {
143 for (Class<?> c : classes) {
144 for (Field reflect : c.getDeclaredFields()) {
145 ResolvedJavaField field = metaAccess.lookupJavaField(reflect);
146 assertNotNull(field);
147 assertTrue(field.getDeclaringClass().equals(metaAccess.lookupJavaType(reflect.getDeclaringClass())));
148 }
149 }
150 }
151
152 @Test
153 public void lookupJavaTypeConstantTest() {
154 for (ConstantValue cv : constants()) {
155 JavaConstant c = cv.value;
156 if (c.getJavaKind() == JavaKind.Object && !c.isNull()) {
157 Object o = cv.boxed;
158 ResolvedJavaType type = metaAccess.lookupJavaType(c);
159 assertNotNull(type);
160 assertTrue(type.equals(metaAccess.lookupJavaType(o.getClass())));
161 } else {
162 assertEquals(metaAccess.lookupJavaType(c), null);
163 }
164 }
165 }
166
167 @Test(expected = NullPointerException.class)
168 public void lookupJavaTypeConstantNegativeTest() {
169 metaAccess.lookupJavaType((JavaConstant) null);
170 }
171
172 @Test
173 public void getMemorySizeTest() {
174 for (ConstantValue cv : constants()) {
175 JavaConstant c = cv.value;
176 long memSize = metaAccess.getMemorySize(c);
177 if (c.isNull()) {
178 assertEquals("Expected size = 0 for null", memSize, 0L);
179 } else {
180 assertTrue("Expected size != 0 for " + cv, memSize != 0L);
181 }
182 }
183 }
184
185 @Test(expected = NullPointerException.class)
186 public void getMemorySizeNegativeTest() {
187 metaAccess.getMemorySize(null);
188 }
189
190 @Test
191 public void parseMethodDescriptorTest() {
192 for (String retType : new String[] {"V", "Z", "Ljava/lang/String;"}) {
193 for (String paramTypes : new String[] {"", "B",
194 "Ljava/lang/String;", "JLjava/lang/String;",
195 "Ljava/lang/String;F",
196 "[Ljava/lang/String;ZBCDFIJLS[ILjava/lang/Object;"}) {
197 String signature = "(" + paramTypes + ")" + retType;
198 Signature result = metaAccess.parseMethodDescriptor(signature);
199 assertEquals("Expected signatures to be equal",
200 result.toMethodDescriptor(), signature);
201 }
202 }
203 }
204
205 @Test(expected = NullPointerException.class)
206 public void parseMethodDescriptorNegativeNullTest() {
207 metaAccess.parseMethodDescriptor(null);
208 }
209
210 @Test(expected = NullPointerException.class)
211 public void encodeDeoptActionAndReasonNegative1Test() {
212 metaAccess.encodeDeoptActionAndReason(null,
213 DeoptimizationReason.Aliasing, 0);
214
215 }
216
217 @Test(expected = NullPointerException.class)
218 public void encodeDeoptActionAndReasonNegative2Test() {
219 metaAccess.encodeDeoptActionAndReason(
220 DeoptimizationAction.InvalidateRecompile, null, 0);
221 }
222
223 @Test
224 public void decodeDeoptReasonTest() {
225 for (int encoded : VALID_ENCODED_VALUES) {
226 JavaConstant value = JavaConstant.forInt(encoded);
227 DeoptimizationReason reason = metaAccess.decodeDeoptReason(value);
228 assertEquals("Expected equal reasons", reason, DEOPT_REASON);
229 }
230 }
231
232 @Test
233 public void decodeDeoptReasonNegative1Test() {
234 int encoded = 42;
235 JavaConstant value = JavaConstant.forInt(encoded);
236 metaAccess.decodeDeoptReason(value);
237 }
238
239 @Test(expected = NullPointerException.class)
240 public void decodeDeoptReasonNegative2Test() {
241 metaAccess.decodeDeoptReason(null);
242 }
243
244 @Test
245 public void decodeDeoptActionTest() {
246 for (int encoded : VALID_ENCODED_VALUES) {
247 JavaConstant value = JavaConstant.forInt(encoded);
248 DeoptimizationAction action = metaAccess.decodeDeoptAction(value);
249 assertEquals("Expected equal actions", action, DEOPT_ACTION);
250 }
251 }
252
253 @Test
254 public void decodeDeoptActionNegative1Test() {
255 int encoded = 123456789;
256 JavaConstant value = JavaConstant.forInt(encoded);
257 metaAccess.decodeDeoptAction(value);
258 }
259
260 @Test(expected = NullPointerException.class)
261 public void decodeDeoptActionNegative2Test() {
262 metaAccess.decodeDeoptAction(null);
263 }
264
265 @Test
266 public void decodeDebugIdTest() {
267 for (int i = 0; i < VALID_ENCODED_VALUES.length; i++) {
268 JavaConstant value = JavaConstant.forInt(VALID_ENCODED_VALUES[i]);
269 assertEquals("Unexpected debugId", metaAccess.decodeDebugId(value), DEBUG_IDS[i]);
270 }
271 }
272 }
|