gt:         JavaConstant value = JavaConstant.forInt(encoded);
context: /*
   * Copyright (c) 2012, 2019, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.
   *
   * This code is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  
  /**
   * @test
   * @requires vm.jvmci
   * @library ../../../../../
   * @modules jdk.internal.vm.ci/jdk.vm.ci.meta
   *          jdk.internal.vm.ci/jdk.vm.ci.runtime
   *          java.base/jdk.internal.misc
   * @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableJVMCI -XX:-UseJVMCICompiler jdk.vm.ci.runtime.test.TestMetaAccessProvider
   */
  
  package jdk.vm.ci.runtime.test;
  
  import jdk.vm.ci.meta.DeoptimizationAction;
  import jdk.vm.ci.meta.DeoptimizationReason;
  import jdk.vm.ci.meta.JavaConstant;
  import jdk.vm.ci.meta.JavaKind;
  import jdk.vm.ci.meta.MetaAccessProvider;
  import jdk.vm.ci.meta.ResolvedJavaField;
  import jdk.vm.ci.meta.ResolvedJavaMethod;
  import jdk.vm.ci.meta.ResolvedJavaType;
  import jdk.vm.ci.meta.Signature;
  import org.junit.Test;
  
  import java.lang.reflect.Field;
  import java.lang.reflect.Method;
  
  import static jdk.vm.ci.meta.MetaUtil.toInternalName;
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertNotNull;
  import static org.junit.Assert.assertNull;
  import static org.junit.Assert.assertTrue;
  
  /**
   * Tests for {@link MetaAccessProvider}.
   */
  public class TestMetaAccessProvider extends TypeUniverse {
      private static final DeoptimizationAction DEOPT_ACTION = DeoptimizationAction.InvalidateRecompile;
      private static final DeoptimizationReason DEOPT_REASON = DeoptimizationReason.Aliasing;
      private static final int INT_23BITS_SET = 0x7FFFFF;
      private static final int[] DEBUG_IDS = new int[]{0, 1, 42, INT_23BITS_SET};
      private static final int[] VALID_ENCODED_VALUES = new int[]{
                      metaAccess.encodeDeoptActionAndReason(DEOPT_ACTION, DEOPT_REASON, DEBUG_IDS[0]).asInt(),
                      metaAccess.encodeDeoptActionAndReason(DEOPT_ACTION, DEOPT_REASON, DEBUG_IDS[1]).asInt(),
                      metaAccess.encodeDeoptActionAndReason(DEOPT_ACTION, DEOPT_REASON, DEBUG_IDS[2]).asInt(),
                      metaAccess.encodeDeoptActionAndReason(DEOPT_ACTION, DEOPT_REASON, DEBUG_IDS[3]).asInt()
      };
  
      private static boolean isUnsafeAnoymous(ResolvedJavaType type) {
          return type.getHostClass() != null;
      }
  
      @Test
      public void lookupJavaTypeTest() {
          for (Class<?> c : classes) {
              ResolvedJavaType type = metaAccess.lookupJavaType(c);
              assertNotNull(c.toString(), type);
              if (!isUnsafeAnoymous(type)) {
                  assertEquals(c.toString(), type.getName(), toInternalName(c.getName()));
                  assertEquals(c.toString(), type.getName(), toInternalName(type.toJavaName()));
                  assertEquals(c.toString(), c.getName(), type.toClassName());
                  if (!type.isArray()) {
                      assertEquals(c.toString(), c.getName(), type.toJavaName());
                  }
              }
          }
      }
  
      @Test(expected = IllegalArgumentException.class)
      public void lookupJavaTypeNegativeTest() {
          metaAccess.lookupJavaType((Class<?>) null);
      }
  
      @Test
      public void lookupJavaTypesTest() {
          ResolvedJavaType[] result = metaAccess.lookupJavaTypes(classes.toArray(new Class<?>[classes.size()]));
          int counter = 0;
          for (Class<?> aClass : classes) {
              if (!isUnsafeAnoymous(result[counter])) {
                  assertEquals("Unexpected javaType: " + result[counter] + " while expecting of class: " + aClass, result[counter].toClassName(), aClass.getName());
              }
              counter++;
          }
      }
  
      @Test(expected = NullPointerException.class)
      public void lookupJavaTypesNegative1Test() {
          assertNull("Expected null", metaAccess.lookupJavaTypes(null));
      }
  
      @Test(expected = IllegalArgumentException.class)
      public void lookupJavaTypesNegative2Test() {
          ResolvedJavaType[] result = metaAccess.lookupJavaTypes(new Class<?>[]{null, null, null});
          for (ResolvedJavaType aType : result) {
              assertNull("Expected null javaType", aType);
          }
          result = metaAccess.lookupJavaTypes(new Class<?>[]{String.class, String.class});
          assertEquals("Results not equals", result[0].getClass(), result[1].getClass());
          assertEquals("Result is not String.class", result[0].getClass(), String.class);
      }
  
      @Test
      public void lookupJavaMethodTest() {
          for (Class<?> c : classes) {
              for (Method reflect : c.getDeclaredMethods()) {
                  ResolvedJavaMethod method = metaAccess.lookupJavaMethod(reflect);
                  assertNotNull(method);
                  assertTrue(method.getDeclaringClass().equals(metaAccess.lookupJavaType(reflect.getDeclaringClass())));
              }
          }
      }
  
      @Test(expected = NullPointerException.class)
      public void lookupJavaMethodNegativeTest() {
          metaAccess.lookupJavaMethod(null);
      }
  
      @Test
      public void lookupJavaFieldTest() {
          for (Class<?> c : classes) {
              for (Field reflect : c.getDeclaredFields()) {
                  ResolvedJavaField field = metaAccess.lookupJavaField(reflect);
                  assertNotNull(field);
                  assertTrue(field.getDeclaringClass().equals(metaAccess.lookupJavaType(reflect.getDeclaringClass())));
              }
          }
      }
  
      @Test
      public void lookupJavaTypeConstantTest() {
          for (ConstantValue cv : constants()) {
              JavaConstant c = cv.value;
              if (c.getJavaKind() == JavaKind.Object && !c.isNull()) {
                  Object o = cv.boxed;
                  ResolvedJavaType type = metaAccess.lookupJavaType(c);
                  assertNotNull(type);
                  assertTrue(type.equals(metaAccess.lookupJavaType(o.getClass())));
              } else {
                  assertEquals(metaAccess.lookupJavaType(c), null);
              }
          }
      }
  
      @Test(expected = NullPointerException.class)
      public void lookupJavaTypeConstantNegativeTest() {
          metaAccess.lookupJavaType((JavaConstant) null);
      }
  
      @Test
      public void getMemorySizeTest() {
          for (ConstantValue cv : constants()) {
              JavaConstant c = cv.value;
              long memSize = metaAccess.getMemorySize(c);
              if (c.isNull()) {
                  assertEquals("Expected size = 0 for null", memSize, 0L);
              } else {
                  assertTrue("Expected size != 0 for " + cv, memSize != 0L);
              }
          }
      }
  
      @Test(expected = NullPointerException.class)
      public void getMemorySizeNegativeTest() {
          metaAccess.getMemorySize(null);
      }
  
      @Test
      public void parseMethodDescriptorTest() {
          for (String retType : new String[]{"V", "Z", "Ljava/lang/String;"}) {
              for (String paramTypes : new String[]{"", "B",
                              "Ljava/lang/String;", "JLjava/lang/String;",
                              "Ljava/lang/String;F",
                              "[Ljava/lang/String;ZBCDFIJLS[ILjava/lang/Object;"}) {
                  String signature = "(" + paramTypes + ")" + retType;
                  Signature result = metaAccess.parseMethodDescriptor(signature);
                  assertEquals("Expected signatures to be equal", result.toMethodDescriptor(), signature);
              }
          }
      }
  
      @Test(expected = NullPointerException.class)
      public void parseMethodDescriptorNegativeNullTest() {
          metaAccess.parseMethodDescriptor(null);
      }
  
      @Test(expected = NullPointerException.class)
      public void encodeDeoptActionAndReasonNegative1Test() {
          metaAccess.encodeDeoptActionAndReason(null, DeoptimizationReason.Aliasing, 0);
  
      }
  
      @Test(expected = NullPointerException.class)
      public void encodeDeoptActionAndReasonNegative2Test() {
          metaAccess.encodeDeoptActionAndReason(DeoptimizationAction.InvalidateRecompile, null, 0);
      }
  
      @Test
      public void decodeDeoptReasonTest() {
          for (int encoded : VALID_ENCODED_VALUES) {
              JavaConstant value = JavaConstant.forInt(encoded);
              DeoptimizationReason reason = metaAccess.decodeDeoptReason(value);
              assertEquals("Expected equal reasons", reason, DEOPT_REASON);
          }
      }
  
      @Test
      public void decodeDeoptReasonNegative1Test() {
          int encoded = 42;
  