< prev index next >

test/compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/TestHelper.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 package jdk.vm.ci.hotspot.test;
  25 
  26 import java.lang.reflect.Field;
  27 import java.util.HashMap;
  28 import java.util.Map;
  29 import jdk.vm.ci.hotspot.HotSpotConstantReflectionProvider;
  30 import jdk.vm.ci.meta.JavaConstant;
  31 import jdk.vm.ci.meta.MetaAccessProvider;
  32 import jdk.vm.ci.meta.ResolvedJavaField;
  33 import jdk.vm.ci.runtime.JVMCI;
  34 
  35 public class TestHelper {
  36 
  37     public static final DummyClass DUMMY_CLASS_INSTANCE = new DummyClass();
  38     public static final HotSpotConstantReflectionProvider CONSTANT_REFLECTION_PROVIDER
  39             = (HotSpotConstantReflectionProvider) JVMCI.getRuntime().getHostJVMCIBackend().getConstantReflection();
  40     public static final JavaConstant DUMMY_CLASS_CONSTANT
  41             = CONSTANT_REFLECTION_PROVIDER.forObject(DUMMY_CLASS_INSTANCE);
  42 
  43     public static final Map<ResolvedJavaField, JavaConstant> INSTANCE_FIELDS_MAP
  44             = new HashMap<>();
  45 
  46     static {
  47         INSTANCE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "booleanField"),
  48                                 JavaConstant.forBoolean(DUMMY_CLASS_INSTANCE.booleanField));
  49         INSTANCE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "byteField"),
  50                                 JavaConstant.forByte(DUMMY_CLASS_INSTANCE.byteField));
  51         INSTANCE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "shortField"),
  52                                 JavaConstant.forShort(DUMMY_CLASS_INSTANCE.shortField));
  53         INSTANCE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "charField"),
  54                                 JavaConstant.forChar(DUMMY_CLASS_INSTANCE.charField));
  55         INSTANCE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "intField"),
  56                                 JavaConstant.forInt(DUMMY_CLASS_INSTANCE.intField));
  57         INSTANCE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "longField"),
  58                                 JavaConstant.forLong(DUMMY_CLASS_INSTANCE.longField));
  59         INSTANCE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "floatField"),
  60                                 JavaConstant.forFloat(DUMMY_CLASS_INSTANCE.floatField));
  61         INSTANCE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "doubleField"),
  62                                 JavaConstant.forDouble(DUMMY_CLASS_INSTANCE.doubleField));
  63         INSTANCE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "objectField"),
  64                                 CONSTANT_REFLECTION_PROVIDER.forObject(
  65                                         DUMMY_CLASS_INSTANCE.objectField));
  66     }
  67 
  68     public static final Map<ResolvedJavaField, JavaConstant> INSTANCE_FINAL_FIELDS_MAP
  69             = new HashMap<>();
  70 
  71     static {
  72         INSTANCE_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "finalBooleanField"),
  73                                       JavaConstant.forBoolean(
  74                                               DUMMY_CLASS_INSTANCE.finalBooleanField));
  75         INSTANCE_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "finalByteField"),
  76                                       JavaConstant.forByte(DUMMY_CLASS_INSTANCE.finalByteField));
  77         INSTANCE_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "finalShortField"),
  78                                       JavaConstant.forShort(DUMMY_CLASS_INSTANCE.finalShortField));
  79         INSTANCE_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "finalCharField"),
  80                                       JavaConstant.forChar(DUMMY_CLASS_INSTANCE.finalCharField));
  81         INSTANCE_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "finalIntField"),
  82                                       JavaConstant.forInt(DUMMY_CLASS_INSTANCE.finalIntField));
  83         INSTANCE_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "finalLongField"),
  84                                       JavaConstant.forLong(DUMMY_CLASS_INSTANCE.finalLongField));
  85         INSTANCE_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "finalFloatField"),
  86                                       JavaConstant.forFloat(DUMMY_CLASS_INSTANCE.finalFloatField));
  87         INSTANCE_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "finalDoubleField"),
  88                                       JavaConstant.forDouble(
  89                                               DUMMY_CLASS_INSTANCE.finalDoubleField));
  90         INSTANCE_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "finalObjectField"),
  91                                       CONSTANT_REFLECTION_PROVIDER.forObject(
  92                                               DUMMY_CLASS_INSTANCE.finalObjectField));
  93     }
  94 
  95     public static final Map<ResolvedJavaField, JavaConstant> INSTANCE_FINAL_DEFAULT_FIELDS_MAP
  96             = new HashMap<>();
  97 
  98     static {
  99         INSTANCE_FINAL_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 100                                                                    "finalDefaultBooleanField"),
 101                                               JavaConstant.forBoolean(
 102                                                       DUMMY_CLASS_INSTANCE.finalDefaultBooleanField));
 103         INSTANCE_FINAL_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 104                                                                    "finalDefaultByteField"),
 105                                               JavaConstant.forByte(
 106                                                       DUMMY_CLASS_INSTANCE.finalDefaultByteField));
 107         INSTANCE_FINAL_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 108                                                                    "finalDefaultShortField"),
 109                                               JavaConstant.forShort(
 110                                                       DUMMY_CLASS_INSTANCE.finalDefaultShortField));
 111         INSTANCE_FINAL_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 112                                                                    "finalDefaultCharField"),
 113                                               JavaConstant.forChar(
 114                                                       DUMMY_CLASS_INSTANCE.finalDefaultCharField));
 115         INSTANCE_FINAL_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 116                                                                    "finalDefaultIntField"),
 117                                               JavaConstant.forInt(
 118                                                       DUMMY_CLASS_INSTANCE.finalDefaultIntField));
 119         INSTANCE_FINAL_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 120                                                                    "finalDefaultLongField"),
 121                                               JavaConstant.forLong(
 122                                                       DUMMY_CLASS_INSTANCE.finalDefaultLongField));
 123         INSTANCE_FINAL_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 124                                                                    "finalDefaultFloatField"),
 125                                               JavaConstant.forFloat(
 126                                                       DUMMY_CLASS_INSTANCE.finalDefaultFloatField));
 127         INSTANCE_FINAL_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 128                                                                    "finalDefaultDoubleField"),
 129                                               JavaConstant.forDouble(
 130                                                       DUMMY_CLASS_INSTANCE.finalDefaultDoubleField));
 131         INSTANCE_FINAL_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 132                                                                    "finalDefaultObjectField"),
 133                                               CONSTANT_REFLECTION_PROVIDER.forObject(
 134                                                       DUMMY_CLASS_INSTANCE.finalDefaultObjectField));
 135     }
 136 
 137     public static final Map<ResolvedJavaField, JavaConstant> INSTANCE_STABLE_FIELDS_MAP
 138             = new HashMap<>();
 139 
 140     static {
 141         INSTANCE_STABLE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "stableBooleanField"),
 142                                        JavaConstant.forBoolean(
 143                                                DUMMY_CLASS_INSTANCE.stableBooleanField));
 144         INSTANCE_STABLE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "stableByteField"),
 145                                        JavaConstant.forByte(DUMMY_CLASS_INSTANCE.stableByteField));
 146         INSTANCE_STABLE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "stableShortField"),
 147                                        JavaConstant.forShort(
 148                                                DUMMY_CLASS_INSTANCE.stableShortField));
 149         INSTANCE_STABLE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "stableCharField"),
 150                                        JavaConstant.forChar(DUMMY_CLASS_INSTANCE.stableCharField));
 151         INSTANCE_STABLE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "stableIntField"),
 152                                        JavaConstant.forInt(DUMMY_CLASS_INSTANCE.stableIntField));
 153         INSTANCE_STABLE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "stableLongField"),
 154                                        JavaConstant.forLong(DUMMY_CLASS_INSTANCE.stableLongField));
 155         INSTANCE_STABLE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "stableFloatField"),
 156                                        JavaConstant.forFloat(
 157                                                DUMMY_CLASS_INSTANCE.stableFloatField));
 158         INSTANCE_STABLE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "stableDoubleField"),
 159                                        JavaConstant.forDouble(
 160                                                DUMMY_CLASS_INSTANCE.stableDoubleField));
 161         INSTANCE_STABLE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "stableObjectField"),
 162                                        CONSTANT_REFLECTION_PROVIDER.forObject(
 163                                                DUMMY_CLASS_INSTANCE.stableObjectField));
 164     }
 165 
 166     public static final Map<ResolvedJavaField, JavaConstant> INSTANCE_STABLE_DEFAULT_FIELDS_MAP
 167             = new HashMap<>();
 168 
 169     static {
 170         INSTANCE_STABLE_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 171                                                                     "stableDefaultBooleanField"),
 172                                                JavaConstant.forBoolean(
 173                                                        DUMMY_CLASS_INSTANCE.stableDefaultBooleanField));
 174         INSTANCE_STABLE_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 175                                                                     "stableDefaultByteField"),
 176                                                JavaConstant.forByte(
 177                                                        DUMMY_CLASS_INSTANCE.stableDefaultByteField));
 178         INSTANCE_STABLE_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 179                                                                     "stableDefaultShortField"),
 180                                                JavaConstant.forShort(
 181                                                        DUMMY_CLASS_INSTANCE.stableDefaultShortField));
 182         INSTANCE_STABLE_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 183                                                                     "stableDefaultCharField"),
 184                                                JavaConstant.forChar(
 185                                                        DUMMY_CLASS_INSTANCE.stableDefaultCharField));
 186         INSTANCE_STABLE_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 187                                                                     "stableDefaultIntField"),


 211         STATIC_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticBooleanField"),
 212                               JavaConstant.forBoolean(DummyClass.staticBooleanField));
 213         STATIC_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticByteField"),
 214                               JavaConstant.forByte(DummyClass.staticByteField));
 215         STATIC_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticShortField"),
 216                               JavaConstant.forShort(DummyClass.staticShortField));
 217         STATIC_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticCharField"),
 218                               JavaConstant.forChar(DummyClass.staticCharField));
 219         STATIC_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticIntField"),
 220                               JavaConstant.forInt(DummyClass.staticIntField));
 221         STATIC_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticLongField"),
 222                               JavaConstant.forLong(DummyClass.staticLongField));
 223         STATIC_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticFloatField"),
 224                               JavaConstant.forFloat(DummyClass.staticFloatField));
 225         STATIC_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticDoubleField"),
 226                               JavaConstant.forDouble(DummyClass.staticDoubleField));
 227         STATIC_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticObjectField"),
 228                               CONSTANT_REFLECTION_PROVIDER.forObject(DummyClass.staticObjectField));
 229     }
 230 
 231     public static final Map<ResolvedJavaField, JavaConstant> STATIC_FINAL_FIELDS_MAP
 232             = new HashMap<>();
 233 
 234     static {
 235         STATIC_FINAL_FIELDS_MAP.put(
 236                 getResolvedJavaField(DummyClass.class, "staticFinalBooleanField"),
 237                 JavaConstant.forBoolean(DummyClass.staticFinalBooleanField));
 238         STATIC_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticFinalByteField"),
 239                                     JavaConstant.forByte(DummyClass.staticFinalByteField));
 240         STATIC_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticFinalShortField"),
 241                                     JavaConstant.forShort(DummyClass.staticFinalShortField));
 242         STATIC_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticFinalCharField"),
 243                                     JavaConstant.forChar(DummyClass.staticFinalCharField));
 244         STATIC_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticFinalIntField"),
 245                                     JavaConstant.forInt(DummyClass.staticFinalIntField));
 246         STATIC_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticFinalLongField"),
 247                                     JavaConstant.forLong(DummyClass.staticFinalLongField));
 248         STATIC_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticFinalFloatField"),
 249                                     JavaConstant.forFloat(DummyClass.staticFinalFloatField));
 250         STATIC_FINAL_FIELDS_MAP.put(
 251                 getResolvedJavaField(DummyClass.class, "staticFinalDoubleField"),
 252                 JavaConstant.forDouble(DummyClass.staticFinalDoubleField));
 253         STATIC_FINAL_FIELDS_MAP.put(
 254                 getResolvedJavaField(DummyClass.class, "staticFinalObjectField"),
 255                 CONSTANT_REFLECTION_PROVIDER.forObject(DummyClass.staticFinalObjectField));
 256     }
 257 
 258     public static final Map<ResolvedJavaField, JavaConstant> STATIC_STABLE_FIELDS_MAP
 259             = new HashMap<>();
 260 
 261     static {
 262         STATIC_STABLE_FIELDS_MAP.put(
 263                 getResolvedJavaField(DummyClass.class, "staticStableBooleanField"),
 264                 JavaConstant.forBoolean(DummyClass.staticStableBooleanField));
 265         STATIC_STABLE_FIELDS_MAP.put(
 266                 getResolvedJavaField(DummyClass.class, "staticStableByteField"),
 267                 JavaConstant.forByte(DummyClass.staticStableByteField));
 268         STATIC_STABLE_FIELDS_MAP.put(
 269                 getResolvedJavaField(DummyClass.class, "staticStableShortField"),
 270                 JavaConstant.forShort(DummyClass.staticStableShortField));
 271         STATIC_STABLE_FIELDS_MAP.put(
 272                 getResolvedJavaField(DummyClass.class, "staticStableCharField"),
 273                 JavaConstant.forChar(DummyClass.staticStableCharField));
 274         STATIC_STABLE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticStableIntField"),
 275                                      JavaConstant.forInt(DummyClass.staticStableIntField));
 276         STATIC_STABLE_FIELDS_MAP.put(
 277                 getResolvedJavaField(DummyClass.class, "staticStableLongField"),
 278                 JavaConstant.forLong(DummyClass.staticStableLongField));
 279         STATIC_STABLE_FIELDS_MAP.put(
 280                 getResolvedJavaField(DummyClass.class, "staticStableFloatField"),
 281                 JavaConstant.forFloat(DummyClass.staticStableFloatField));
 282         STATIC_STABLE_FIELDS_MAP.put(
 283                 getResolvedJavaField(DummyClass.class, "staticStableDoubleField"),
 284                 JavaConstant.forDouble(DummyClass.staticStableDoubleField));
 285         STATIC_STABLE_FIELDS_MAP.put(
 286                 getResolvedJavaField(DummyClass.class, "staticStableObjectField"),
 287                 CONSTANT_REFLECTION_PROVIDER.forObject(DummyClass.staticStableObjectField));
 288     }
 289 
 290     public static final Map<ResolvedJavaField, JavaConstant> STATIC_STABLE_DEFAULT_FIELDS_MAP
 291             = new HashMap<>();
 292 
 293     static {
 294         STATIC_STABLE_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 295                                                                   "staticStableDefaultBooleanField"),
 296                                              JavaConstant.forBoolean(
 297                                                      DummyClass.staticStableDefaultBooleanField));
 298         STATIC_STABLE_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 299                                                                   "staticStableDefaultByteField"),
 300                                              JavaConstant.forByte(
 301                                                      DummyClass.staticStableDefaultByteField));
 302         STATIC_STABLE_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 303                                                                   "staticStableDefaultShortField"),
 304                                              JavaConstant.forShort(
 305                                                      DummyClass.staticStableDefaultShortField));
 306         STATIC_STABLE_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 307                                                                   "staticStableDefaultCharField"),
 308                                              JavaConstant.forChar(
 309                                                      DummyClass.staticStableDefaultCharField));
 310         STATIC_STABLE_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 311                                                                   "staticStableDefaultIntField"),






  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 package jdk.vm.ci.hotspot.test;
  25 
  26 import java.lang.reflect.Field;
  27 import java.util.HashMap;
  28 import java.util.Map;
  29 import jdk.vm.ci.hotspot.HotSpotConstantReflectionProvider;
  30 import jdk.vm.ci.meta.JavaConstant;
  31 import jdk.vm.ci.meta.MetaAccessProvider;
  32 import jdk.vm.ci.meta.ResolvedJavaField;
  33 import jdk.vm.ci.runtime.JVMCI;
  34 
  35 public class TestHelper {
  36 
  37     public static final DummyClass DUMMY_CLASS_INSTANCE = new DummyClass();
  38     public static final HotSpotConstantReflectionProvider CONSTANT_REFLECTION_PROVIDER = (HotSpotConstantReflectionProvider) JVMCI.getRuntime().getHostJVMCIBackend().getConstantReflection();
  39     public static final JavaConstant DUMMY_CLASS_CONSTANT = CONSTANT_REFLECTION_PROVIDER.forObject(DUMMY_CLASS_INSTANCE);


  40 
  41     public static final Map<ResolvedJavaField, JavaConstant> INSTANCE_FIELDS_MAP = new HashMap<>();

  42 
  43     static {
  44         INSTANCE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "booleanField"),
  45                         JavaConstant.forBoolean(DUMMY_CLASS_INSTANCE.booleanField));
  46         INSTANCE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "byteField"),
  47                         JavaConstant.forByte(DUMMY_CLASS_INSTANCE.byteField));
  48         INSTANCE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "shortField"),
  49                         JavaConstant.forShort(DUMMY_CLASS_INSTANCE.shortField));
  50         INSTANCE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "charField"),
  51                         JavaConstant.forChar(DUMMY_CLASS_INSTANCE.charField));
  52         INSTANCE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "intField"),
  53                         JavaConstant.forInt(DUMMY_CLASS_INSTANCE.intField));
  54         INSTANCE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "longField"),
  55                         JavaConstant.forLong(DUMMY_CLASS_INSTANCE.longField));
  56         INSTANCE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "floatField"),
  57                         JavaConstant.forFloat(DUMMY_CLASS_INSTANCE.floatField));
  58         INSTANCE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "doubleField"),
  59                         JavaConstant.forDouble(DUMMY_CLASS_INSTANCE.doubleField));
  60         INSTANCE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "objectField"),
  61                         CONSTANT_REFLECTION_PROVIDER.forObject(
  62                                         DUMMY_CLASS_INSTANCE.objectField));
  63     }
  64 
  65     public static final Map<ResolvedJavaField, JavaConstant> INSTANCE_FINAL_FIELDS_MAP = new HashMap<>();

  66 
  67     static {
  68         INSTANCE_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "finalBooleanField"),
  69                         JavaConstant.forBoolean(
  70                                         DUMMY_CLASS_INSTANCE.finalBooleanField));
  71         INSTANCE_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "finalByteField"),
  72                         JavaConstant.forByte(DUMMY_CLASS_INSTANCE.finalByteField));
  73         INSTANCE_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "finalShortField"),
  74                         JavaConstant.forShort(DUMMY_CLASS_INSTANCE.finalShortField));
  75         INSTANCE_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "finalCharField"),
  76                         JavaConstant.forChar(DUMMY_CLASS_INSTANCE.finalCharField));
  77         INSTANCE_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "finalIntField"),
  78                         JavaConstant.forInt(DUMMY_CLASS_INSTANCE.finalIntField));
  79         INSTANCE_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "finalLongField"),
  80                         JavaConstant.forLong(DUMMY_CLASS_INSTANCE.finalLongField));
  81         INSTANCE_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "finalFloatField"),
  82                         JavaConstant.forFloat(DUMMY_CLASS_INSTANCE.finalFloatField));
  83         INSTANCE_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "finalDoubleField"),
  84                         JavaConstant.forDouble(
  85                                         DUMMY_CLASS_INSTANCE.finalDoubleField));
  86         INSTANCE_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "finalObjectField"),
  87                         CONSTANT_REFLECTION_PROVIDER.forObject(
  88                                         DUMMY_CLASS_INSTANCE.finalObjectField));
  89     }
  90 
  91     public static final Map<ResolvedJavaField, JavaConstant> INSTANCE_FINAL_DEFAULT_FIELDS_MAP = new HashMap<>();

  92 
  93     static {
  94         INSTANCE_FINAL_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
  95                         "finalDefaultBooleanField"),
  96                         JavaConstant.forBoolean(
  97                                         DUMMY_CLASS_INSTANCE.finalDefaultBooleanField));
  98         INSTANCE_FINAL_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
  99                         "finalDefaultByteField"),
 100                         JavaConstant.forByte(
 101                                         DUMMY_CLASS_INSTANCE.finalDefaultByteField));
 102         INSTANCE_FINAL_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 103                         "finalDefaultShortField"),
 104                         JavaConstant.forShort(
 105                                         DUMMY_CLASS_INSTANCE.finalDefaultShortField));
 106         INSTANCE_FINAL_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 107                         "finalDefaultCharField"),
 108                         JavaConstant.forChar(
 109                                         DUMMY_CLASS_INSTANCE.finalDefaultCharField));
 110         INSTANCE_FINAL_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 111                         "finalDefaultIntField"),
 112                         JavaConstant.forInt(
 113                                         DUMMY_CLASS_INSTANCE.finalDefaultIntField));
 114         INSTANCE_FINAL_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 115                         "finalDefaultLongField"),
 116                         JavaConstant.forLong(
 117                                         DUMMY_CLASS_INSTANCE.finalDefaultLongField));
 118         INSTANCE_FINAL_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 119                         "finalDefaultFloatField"),
 120                         JavaConstant.forFloat(
 121                                         DUMMY_CLASS_INSTANCE.finalDefaultFloatField));
 122         INSTANCE_FINAL_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 123                         "finalDefaultDoubleField"),
 124                         JavaConstant.forDouble(
 125                                         DUMMY_CLASS_INSTANCE.finalDefaultDoubleField));
 126         INSTANCE_FINAL_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 127                         "finalDefaultObjectField"),
 128                         CONSTANT_REFLECTION_PROVIDER.forObject(
 129                                         DUMMY_CLASS_INSTANCE.finalDefaultObjectField));
 130     }
 131 
 132     public static final Map<ResolvedJavaField, JavaConstant> INSTANCE_STABLE_FIELDS_MAP = new HashMap<>();

 133 
 134     static {
 135         INSTANCE_STABLE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "stableBooleanField"),
 136                         JavaConstant.forBoolean(
 137                                         DUMMY_CLASS_INSTANCE.stableBooleanField));
 138         INSTANCE_STABLE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "stableByteField"),
 139                         JavaConstant.forByte(DUMMY_CLASS_INSTANCE.stableByteField));
 140         INSTANCE_STABLE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "stableShortField"),
 141                         JavaConstant.forShort(
 142                                         DUMMY_CLASS_INSTANCE.stableShortField));
 143         INSTANCE_STABLE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "stableCharField"),
 144                         JavaConstant.forChar(DUMMY_CLASS_INSTANCE.stableCharField));
 145         INSTANCE_STABLE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "stableIntField"),
 146                         JavaConstant.forInt(DUMMY_CLASS_INSTANCE.stableIntField));
 147         INSTANCE_STABLE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "stableLongField"),
 148                         JavaConstant.forLong(DUMMY_CLASS_INSTANCE.stableLongField));
 149         INSTANCE_STABLE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "stableFloatField"),
 150                         JavaConstant.forFloat(
 151                                         DUMMY_CLASS_INSTANCE.stableFloatField));
 152         INSTANCE_STABLE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "stableDoubleField"),
 153                         JavaConstant.forDouble(
 154                                         DUMMY_CLASS_INSTANCE.stableDoubleField));
 155         INSTANCE_STABLE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "stableObjectField"),
 156                         CONSTANT_REFLECTION_PROVIDER.forObject(
 157                                         DUMMY_CLASS_INSTANCE.stableObjectField));
 158     }
 159 
 160     public static final Map<ResolvedJavaField, JavaConstant> INSTANCE_STABLE_DEFAULT_FIELDS_MAP = new HashMap<>();

 161 
 162     static {
 163         INSTANCE_STABLE_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 164                         "stableDefaultBooleanField"),
 165                         JavaConstant.forBoolean(
 166                                         DUMMY_CLASS_INSTANCE.stableDefaultBooleanField));
 167         INSTANCE_STABLE_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 168                         "stableDefaultByteField"),
 169                         JavaConstant.forByte(
 170                                         DUMMY_CLASS_INSTANCE.stableDefaultByteField));
 171         INSTANCE_STABLE_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 172                         "stableDefaultShortField"),
 173                         JavaConstant.forShort(
 174                                         DUMMY_CLASS_INSTANCE.stableDefaultShortField));
 175         INSTANCE_STABLE_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 176                         "stableDefaultCharField"),
 177                         JavaConstant.forChar(
 178                                         DUMMY_CLASS_INSTANCE.stableDefaultCharField));
 179         INSTANCE_STABLE_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 180                         "stableDefaultIntField"),


 204         STATIC_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticBooleanField"),
 205                         JavaConstant.forBoolean(DummyClass.staticBooleanField));
 206         STATIC_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticByteField"),
 207                         JavaConstant.forByte(DummyClass.staticByteField));
 208         STATIC_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticShortField"),
 209                         JavaConstant.forShort(DummyClass.staticShortField));
 210         STATIC_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticCharField"),
 211                         JavaConstant.forChar(DummyClass.staticCharField));
 212         STATIC_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticIntField"),
 213                         JavaConstant.forInt(DummyClass.staticIntField));
 214         STATIC_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticLongField"),
 215                         JavaConstant.forLong(DummyClass.staticLongField));
 216         STATIC_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticFloatField"),
 217                         JavaConstant.forFloat(DummyClass.staticFloatField));
 218         STATIC_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticDoubleField"),
 219                         JavaConstant.forDouble(DummyClass.staticDoubleField));
 220         STATIC_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticObjectField"),
 221                         CONSTANT_REFLECTION_PROVIDER.forObject(DummyClass.staticObjectField));
 222     }
 223 
 224     public static final Map<ResolvedJavaField, JavaConstant> STATIC_FINAL_FIELDS_MAP = new HashMap<>();

 225 
 226     static {
 227         STATIC_FINAL_FIELDS_MAP.put(
 228                         getResolvedJavaField(DummyClass.class, "staticFinalBooleanField"),
 229                         JavaConstant.forBoolean(DummyClass.staticFinalBooleanField));
 230         STATIC_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticFinalByteField"),
 231                         JavaConstant.forByte(DummyClass.staticFinalByteField));
 232         STATIC_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticFinalShortField"),
 233                         JavaConstant.forShort(DummyClass.staticFinalShortField));
 234         STATIC_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticFinalCharField"),
 235                         JavaConstant.forChar(DummyClass.staticFinalCharField));
 236         STATIC_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticFinalIntField"),
 237                         JavaConstant.forInt(DummyClass.staticFinalIntField));
 238         STATIC_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticFinalLongField"),
 239                         JavaConstant.forLong(DummyClass.staticFinalLongField));
 240         STATIC_FINAL_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticFinalFloatField"),
 241                         JavaConstant.forFloat(DummyClass.staticFinalFloatField));
 242         STATIC_FINAL_FIELDS_MAP.put(
 243                         getResolvedJavaField(DummyClass.class, "staticFinalDoubleField"),
 244                         JavaConstant.forDouble(DummyClass.staticFinalDoubleField));
 245         STATIC_FINAL_FIELDS_MAP.put(
 246                         getResolvedJavaField(DummyClass.class, "staticFinalObjectField"),
 247                         CONSTANT_REFLECTION_PROVIDER.forObject(DummyClass.staticFinalObjectField));
 248     }
 249 
 250     public static final Map<ResolvedJavaField, JavaConstant> STATIC_STABLE_FIELDS_MAP = new HashMap<>();

 251 
 252     static {
 253         STATIC_STABLE_FIELDS_MAP.put(
 254                         getResolvedJavaField(DummyClass.class, "staticStableBooleanField"),
 255                         JavaConstant.forBoolean(DummyClass.staticStableBooleanField));
 256         STATIC_STABLE_FIELDS_MAP.put(
 257                         getResolvedJavaField(DummyClass.class, "staticStableByteField"),
 258                         JavaConstant.forByte(DummyClass.staticStableByteField));
 259         STATIC_STABLE_FIELDS_MAP.put(
 260                         getResolvedJavaField(DummyClass.class, "staticStableShortField"),
 261                         JavaConstant.forShort(DummyClass.staticStableShortField));
 262         STATIC_STABLE_FIELDS_MAP.put(
 263                         getResolvedJavaField(DummyClass.class, "staticStableCharField"),
 264                         JavaConstant.forChar(DummyClass.staticStableCharField));
 265         STATIC_STABLE_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class, "staticStableIntField"),
 266                         JavaConstant.forInt(DummyClass.staticStableIntField));
 267         STATIC_STABLE_FIELDS_MAP.put(
 268                         getResolvedJavaField(DummyClass.class, "staticStableLongField"),
 269                         JavaConstant.forLong(DummyClass.staticStableLongField));
 270         STATIC_STABLE_FIELDS_MAP.put(
 271                         getResolvedJavaField(DummyClass.class, "staticStableFloatField"),
 272                         JavaConstant.forFloat(DummyClass.staticStableFloatField));
 273         STATIC_STABLE_FIELDS_MAP.put(
 274                         getResolvedJavaField(DummyClass.class, "staticStableDoubleField"),
 275                         JavaConstant.forDouble(DummyClass.staticStableDoubleField));
 276         STATIC_STABLE_FIELDS_MAP.put(
 277                         getResolvedJavaField(DummyClass.class, "staticStableObjectField"),
 278                         CONSTANT_REFLECTION_PROVIDER.forObject(DummyClass.staticStableObjectField));
 279     }
 280 
 281     public static final Map<ResolvedJavaField, JavaConstant> STATIC_STABLE_DEFAULT_FIELDS_MAP = new HashMap<>();

 282 
 283     static {
 284         STATIC_STABLE_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 285                         "staticStableDefaultBooleanField"),
 286                         JavaConstant.forBoolean(
 287                                         DummyClass.staticStableDefaultBooleanField));
 288         STATIC_STABLE_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 289                         "staticStableDefaultByteField"),
 290                         JavaConstant.forByte(
 291                                         DummyClass.staticStableDefaultByteField));
 292         STATIC_STABLE_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 293                         "staticStableDefaultShortField"),
 294                         JavaConstant.forShort(
 295                                         DummyClass.staticStableDefaultShortField));
 296         STATIC_STABLE_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 297                         "staticStableDefaultCharField"),
 298                         JavaConstant.forChar(
 299                                         DummyClass.staticStableDefaultCharField));
 300         STATIC_STABLE_DEFAULT_FIELDS_MAP.put(getResolvedJavaField(DummyClass.class,
 301                         "staticStableDefaultIntField"),







< prev index next >