< prev index next >
test/jdk/jdk/internal/reflect/constantPool/ConstantPoolTest.java
Print this page
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,42 ****
* @run main jdk.internal.reflect.constantPool.ConstantPoolTest
*/
package jdk.internal.reflect.constantPool;
! import java.util.HashMap;
import java.util.Map;
import jdk.internal.misc.SharedSecrets;
import jdk.test.lib.Asserts;
import jdk.internal.reflect.ConstantPool;
--- 32,42 ----
* @run main jdk.internal.reflect.constantPool.ConstantPoolTest
*/
package jdk.internal.reflect.constantPool;
! import java.util.TreeMap;
import java.util.Map;
import jdk.internal.misc.SharedSecrets;
import jdk.test.lib.Asserts;
import jdk.internal.reflect.ConstantPool;
*** 44,54 ****
private static final Class<?> TEST_CLASS = ConstantPoolTestDummy.class;
private static final ConstantPool CP = SharedSecrets.getJavaLangAccess()
.getConstantPool(TEST_CLASS);
! public static void main(String[] s) {
for (TestCase testCase : TestCase.values()) {
testCase.test();
}
}
--- 44,55 ----
private static final Class<?> TEST_CLASS = ConstantPoolTestDummy.class;
private static final ConstantPool CP = SharedSecrets.getJavaLangAccess()
.getConstantPool(TEST_CLASS);
! public static void main(String[] s) throws Throwable {
! TEST_CLASS.newInstance();
for (TestCase testCase : TestCase.values()) {
testCase.test();
}
}
*** 67,76 ****
--- 68,78 ----
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,87 ****
--- 80,178 ----
+ "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,171 ****
}
};
protected final Map<Integer, Object> referenceMap;
TestCase() {
! this.referenceMap = new HashMap<>();
}
abstract void testIndex(int cpi, Object reference);
public void test() {
referenceMap.forEach(this::testIndex);
}
}
}
--- 250,264 ----
}
};
protected final Map<Integer, Object> referenceMap;
TestCase() {
! // 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);
}
}
}
< prev index next >