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