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