< prev index next >

test/compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestMetaAccessProvider.java

Print this page




  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 }
< prev index next >