test/jdk/jdk/internal/reflect/constantPool/ConstantPoolTest.java

rev 52749 : Bootstrap method consolidation
* clean up and simplify JDK support code for BSM invocation
* simplify JVM bootstrap handshake: use BootstrapCallInfo only
* remove unused JVM paths and data fields
* move bootstrap argument processing from MethodHandleNatives to ConstantPool
* remove ConstantGroup; merge argument access into BootstrapCallInfo
* adjust BSM argument access: remove copyArguments, add argumentRef API
* add metadata-free BSM modes, including symbolic arguments from CP

@@ -32,11 +32,11 @@
  * @run main jdk.internal.reflect.constantPool.ConstantPoolTest
  */
 
 package jdk.internal.reflect.constantPool;
 
-import java.util.HashMap;
+import java.util.TreeMap;
 import java.util.Map;
 import jdk.internal.misc.SharedSecrets;
 import jdk.test.lib.Asserts;
 import jdk.internal.reflect.ConstantPool;
 

@@ -44,11 +44,12 @@
 
     private static final Class<?> TEST_CLASS = ConstantPoolTestDummy.class;
     private static final ConstantPool CP = SharedSecrets.getJavaLangAccess()
             .getConstantPool(TEST_CLASS);
 
-    public static void main(String[] s) {
+    public static void main(String[] s) throws Throwable {
+        TEST_CLASS.newInstance();
         for (TestCase testCase : TestCase.values()) {
             testCase.test();
         }
     }
 

@@ -67,10 +68,11 @@
                 referenceMap.put(25, ConstantPool.Tag.INVOKEDYNAMIC);
                 referenceMap.put(29, ConstantPool.Tag.METHODHANDLE);
                 referenceMap.put(30, ConstantPool.Tag.METHODTYPE);
                 referenceMap.put(48, ConstantPool.Tag.FIELDREF);
                 referenceMap.put(52, ConstantPool.Tag.FLOAT);
+                referenceMap.put(53, ConstantPool.Tag.DYNAMIC);
             }
             @Override
             void testIndex(int cpi, Object reference) {
                 ConstantPool.Tag tagToVerify = CP.getTagAt(cpi);
                 ConstantPool.Tag tagToRefer = (ConstantPool.Tag) reference;

@@ -78,10 +80,99 @@
                         + "at CP entry #%d: got CP tag %s, but should be %s",
                         cpi, tagToVerify.name(), tagToRefer.name());
                 Asserts.assertEquals(tagToVerify, tagToRefer, msg);
             }
         },
+        GET_CONSTANT_AT {
+            {
+                referenceMap.put(3, Object.class);
+                referenceMap.put(13, (long)6);
+                referenceMap.put(15, (int)1);
+                referenceMap.put(17, Runnable.class);
+                referenceMap.put(21, (double)1.45);
+                referenceMap.put(23, "Hello");
+                referenceMap.put(31, "[a method handle]");
+                referenceMap.put(52, (float)1.34);
+                //referenceMap.put(53, "[a dynamic constant]");
+            }
+            @Override
+            void testIndex(int cpi, Object reference) {
+                Object entryToVerify = CP.getConstantAt(cpi);
+                Object entryToRefer = reference;
+                if (cpi == 31 && entryToVerify instanceof java.lang.invoke.MethodHandle) {
+                    // const #31 = MethodHandle    5:#34;  //  REF_invokeVirtual:java/lang/Object.toString:"()Ljava/lang/String;"
+                    entryToVerify = entryToRefer;  // good enough
+                }
+                String msg = String.format("Method getConstantAt works not"
+                        + " as expected at CP entry #%d:"
+                        + " got %s, but should be %s",
+                        cpi, entryToVerify, entryToRefer);
+                Asserts.assertEquals(entryToVerify, entryToRefer, msg);
+            }
+        },
+        GET_CONSTANTDESC_AT {
+            {
+                referenceMap.put(3, Object.class);
+                referenceMap.put(13, (long)6);
+                referenceMap.put(15, (int)1);
+                referenceMap.put(17, Runnable.class);
+                referenceMap.put(21, (double)1.45);
+                referenceMap.put(23, "Hello");
+                referenceMap.put(31, "[a method handle]");
+                referenceMap.put(52, (float)1.34);
+                referenceMap.put(53, "[a dynamic constant]");
+            }
+            @Override
+            void testIndex(int cpi, Object reference) {
+                Object entryToVerify = CP.getConstantDescAt(cpi);
+                Object entryToRefer = ((java.lang.constant.Constable<?>)reference).describeConstable().orElse(null);
+                if (cpi == 31 && entryToVerify instanceof java.lang.constant.MethodHandleDesc) {
+                    String str = entryToVerify.toString();
+                    // MethodHandleDesc[VIRTUAL/Object::toString()String]
+                    if (str.contains("toString") &&
+                        str.contains("Object") &&
+                        str.contains("()") &&
+                        (str.contains("virtual") || str.contains("Virtual") || str.contains("VIRTUAL")))
+                        // close enough
+                        entryToVerify = entryToRefer;
+                }
+                if (cpi == 53 && entryToVerify instanceof java.lang.constant.DynamicConstantDesc) {
+                    // DynamicConstantDesc[LambdaMetafactory::metafactory(
+                    //   toString/MethodTypeDesc[(Object)void],
+                    //   MethodHandleDesc[VIRTUAL/Object::toString()String],
+                    //   MethodTypeDesc[(Object)void]
+                    // )Object],
+                    String str = entryToVerify.toString();
+                    if (str.contains("toString") &&
+                        str.contains("metafactory") &&
+                        str.contains("(Object)void"))
+                        // close enough
+                        entryToVerify = entryToRefer;
+                }
+                String msg = String.format("Method getConstantDescAt works not"
+                        + " as expected at CP entry #%d:"
+                        + " got %s, but should be %s",
+                        cpi, entryToVerify, entryToRefer);
+                Asserts.assertEquals(entryToVerify, entryToRefer, msg);
+            }
+        },
+        GET_CLASS_AT {
+            {
+                referenceMap.put(3, Object.class);
+                referenceMap.put(17, Runnable.class);
+            }
+            @Override
+            void testIndex(int cpi, Object reference) {
+                Object entryToVerify = CP.getClassAt(cpi);
+                Object entryToRefer = reference;
+                String msg = String.format("Method getClassAt works not"
+                        + " as expected at CP entry #%d:"
+                        + " got %s, but should be %s",
+                        cpi, entryToVerify, entryToRefer);
+                Asserts.assertEquals(entryToVerify, entryToRefer, msg);
+            }
+        },
         GET_CLASS_REF_INDEX_AT {
             {
                 referenceMap.put(1, 3);
                 referenceMap.put(16, 17);
                 referenceMap.put(32, 35);

@@ -159,13 +250,15 @@
             }
         };
 
         protected final Map<Integer, Object> referenceMap;
         TestCase() {
-            this.referenceMap = new HashMap<>();
+            // Use a TreeMap for deterministic test order.
+            this.referenceMap = new TreeMap<>();
         }
         abstract void testIndex(int cpi, Object reference);
         public void test() {
+            System.out.println(this);
             referenceMap.forEach(this::testIndex);
         }
     }
 }