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