--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/sun/reflect/constantPool/ConstantPoolTest.java Tue Jan 12 17:03:06 2016 +0300
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2015, 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
+ * @bug 8141615
+ * @summary Tests new public methods at sun.reflect.ConstantPool
+ * @modules java.base/sun.reflect
+ * @library /lib/testlibrary
+ * @compile ConstantPoolTestDummy.jasm
+ * @run main sun.reflect.constantPool.ConstantPoolTest
+ */
+
+package sun.reflect.constantPool;
+
+import java.util.HashMap;
+import java.util.Map;
+import jdk.internal.misc.SharedSecrets;
+import jdk.testlibrary.Asserts;
+import sun.reflect.ConstantPool;
+
+public class ConstantPoolTest {
+
+ 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();
+ }
+ }
+
+ public static enum TestCase {
+ GET_TAG_AT {
+ {
+ referenceMap.put(1, ConstantPool.Tag.METHODREF);
+ referenceMap.put(2, ConstantPool.Tag.CLASS);
+ referenceMap.put(4, ConstantPool.Tag.UTF8);
+ referenceMap.put(10, ConstantPool.Tag.NAMEANDTYPE);
+ referenceMap.put(13, ConstantPool.Tag.LONG);
+ referenceMap.put(15, ConstantPool.Tag.INTEGER);
+ referenceMap.put(16, ConstantPool.Tag.INTERFACEMETHODREF);
+ referenceMap.put(21, ConstantPool.Tag.DOUBLE);
+ referenceMap.put(23, ConstantPool.Tag.STRING);
+ 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);
+ }
+ @Override
+ void testIndex(int cpi, Object reference) {
+ ConstantPool.Tag tagToVerify = CP.getTagAt(cpi);
+ ConstantPool.Tag tagToRefer = (ConstantPool.Tag) reference;
+ String msg = String.format("Method getTagAt works not as expected"
+ + "at CP entry #%d: got CP tag %s, but should be %s",
+ cpi, tagToVerify.name(), tagToRefer.name());
+ Asserts.assertEquals(tagToVerify, tagToRefer, msg);
+ }
+ },
+ GET_CLASS_REF_INDEX_AT {
+ {
+ referenceMap.put(1, 3);
+ referenceMap.put(16, 17);
+ referenceMap.put(32, 35);
+ referenceMap.put(34, 3);
+ referenceMap.put(48, 2);
+ }
+ @Override
+ void testIndex(int cpi, Object reference) {
+ int indexToVerify = CP.getClassRefIndexAt(cpi);
+ int indexToRefer = (int) reference;
+ String msg = String.format("Method getClassRefIndexAt works not"
+ + " as expected at CP entry #%d:"
+ + " got index %d, but should be %d",
+ cpi, indexToVerify, indexToRefer);
+ Asserts.assertEquals(indexToVerify, indexToRefer, msg);
+ }
+ },
+ GET_NAME_AND_TYPE_REF_INDEX_AT {
+ {
+ referenceMap.put(1, 10);
+ referenceMap.put(16, 18);
+ referenceMap.put(25, 26);
+ referenceMap.put(32, 36);
+ referenceMap.put(34, 37);
+ referenceMap.put(48, 49);
+ }
+ @Override
+ void testIndex(int cpi, Object reference) {
+ int indexToRefer = (int) reference;
+ int indexToVerify = CP.getNameAndTypeRefIndexAt(cpi);
+ String msg = String.format("Method getNameAndTypeRefIndexAt works"
+ + " not as expected at CP entry #%d:"
+ + " got index %d, but should be %d",
+ cpi, indexToVerify, indexToRefer);
+ Asserts.assertEquals(indexToVerify, indexToRefer, msg);
+ }
+ },
+ GET_NAME_AND_TYPE_REF_INFO_AT {
+ {
+ referenceMap.put(10, new String[]{"<init>", "()V"});
+ referenceMap.put(18, new String[]{"run", "()V"});
+ referenceMap.put(26, new String[]{"accept", "()Ljava/util/function/Consumer;"});
+ referenceMap.put(36, new String[]{"metafactory",
+ "(Ljava/lang/invoke/MethodHandles$Lookup;"
+ + "Ljava/lang/String;Ljava/lang/invoke/MethodType;"
+ + "Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;"
+ + "Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;"});
+ referenceMap.put(37, new String[]{"toString", "()Ljava/lang/String;"});
+ referenceMap.put(49, new String[]{"myField", "I"});
+ }
+ @Override
+ void testIndex(int cpi, Object reference) {
+ String[] natInfo = CP.getNameAndTypeRefInfoAt(cpi);
+ String msg = String.format("Method getNameAndTypeRefInfoAt"
+ + " works not as expected at CP entry #%d:"
+ + " returned value should not be null", cpi);
+ Asserts.assertNotNull(natInfo, msg);
+ String[] castedReference = (String[]) reference;
+ int natInfoLength = natInfo.length;
+ msg = String.format("Method getNameAndTypeRefInfoAt"
+ + " works not as expected at CP entry #%d:"
+ + " length of the returned string array is %d, but should be 2",
+ cpi, natInfoLength);
+ Asserts.assertEquals(natInfoLength, 2, msg);
+ String[] nameOrType = new String[]{"name", "type"};
+ for (int i = 0; i < 2; i++) {
+ String infoToVerify = natInfo[i];
+ String infoToRefer = castedReference[i];
+ msg = String.format("Method getNameAndTypeRefInfoAt"
+ + " works not as expected at CP entry #%d:"
+ + " got %s info %s, but should be %s",
+ cpi, nameOrType[i], infoToVerify, infoToRefer);
+ Asserts.assertEquals(infoToVerify, infoToRefer, msg);
+ }
+ }
+ };
+
+ 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);
+ }
+ }
+}