171 lines
7.6 KiB
Java
171 lines
7.6 KiB
Java
/*
|
|
* 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);
|
|
}
|
|
}
|
|
}
|