252 lines
8.8 KiB
Java
252 lines
8.8 KiB
Java
/*
|
|
* Copyright (c) 2019, 2020, 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
|
|
* @requires vm.jvmti
|
|
* @library /test/lib
|
|
* @modules java.base/jdk.internal.misc
|
|
* jdk.compiler
|
|
* @compile HiddenClassSigTest.java
|
|
* @run main/othervm/native -agentlib:HiddenClassSigTest P.Q.HiddenClassSigTest
|
|
*/
|
|
|
|
package P.Q;
|
|
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
|
|
import java.lang.invoke.MethodHandles;
|
|
import java.lang.invoke.MethodHandles.Lookup;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.Paths;
|
|
|
|
import jdk.test.lib.Utils;
|
|
|
|
|
|
interface HCInterf<T> {
|
|
String hcMethod(T t);
|
|
}
|
|
|
|
class HiddenClassSig<T> implements HCInterf<T> {
|
|
private String realTest() { return "HiddenClassSig: "; }
|
|
|
|
public String hcMethod(T t) {
|
|
String str = realTest();
|
|
return str + t.toString();
|
|
}
|
|
}
|
|
|
|
public class HiddenClassSigTest {
|
|
private static void log(String str) { System.out.println(str); }
|
|
|
|
private static final String HCName = "P/Q/HiddenClassSig.class";
|
|
private static final Path CLASSES_DIR = Paths.get(Utils.TEST_CLASSES);
|
|
private static final String LOG_PREFIX = "HiddenClassSigTest: ";
|
|
|
|
static native void checkHiddenClass(Class klass, String sig);
|
|
static native void checkHiddenClassArray(Class array, String sig);
|
|
static native boolean checkFailed(); // get native agent failing status
|
|
|
|
static {
|
|
try {
|
|
System.loadLibrary("HiddenClassSigTest");
|
|
} catch (UnsatisfiedLinkError ule) {
|
|
System.err.println("Could not load HiddenClassSigTest library");
|
|
System.err.println("java.library.path: "
|
|
+ System.getProperty("java.library.path"));
|
|
throw ule;
|
|
}
|
|
}
|
|
|
|
static Class<?> defineHiddenClass(String classFileName) throws Exception {
|
|
Lookup lookup = MethodHandles.lookup();
|
|
byte[] bytes = Files.readAllBytes(CLASSES_DIR.resolve(classFileName));
|
|
Class<?> hc = lookup.defineHiddenClass(bytes, false).lookupClass();
|
|
return hc;
|
|
}
|
|
|
|
// print all name variations
|
|
static void logClassInfo(Class<?> klass) {
|
|
log("\n### Testing class: " + klass);
|
|
log(LOG_PREFIX + "isHidden: " + klass.isHidden());
|
|
log(LOG_PREFIX + "getName: " + klass.getName());
|
|
log(LOG_PREFIX + "typeName: " + klass.getTypeName());
|
|
log(LOG_PREFIX + "toString: " + klass.toString());
|
|
log(LOG_PREFIX + "toGenStr: " + klass.toGenericString());
|
|
log(LOG_PREFIX + "elem type: " + klass.componentType());
|
|
}
|
|
|
|
private static final String HC_NAME = "P.Q.HiddenClassSig";
|
|
private static final String HC_SUFFIX_REGEX = "0x[0-9a-f]+";
|
|
|
|
static boolean checkName(Class<?> klass, String name, String toString) {
|
|
boolean failed = false;
|
|
String regex = "";
|
|
Class<?> c = klass;
|
|
|
|
// for an array add the prefix "[" for each dimension
|
|
while (c.isArray()) {
|
|
regex = "\\[" + regex;
|
|
c = c.componentType();
|
|
}
|
|
// construct the expected name
|
|
if (klass.isArray()) {
|
|
regex += "L" + HC_NAME + "/" + HC_SUFFIX_REGEX + ";";
|
|
} else {
|
|
regex = HC_NAME + "/" + HC_SUFFIX_REGEX;
|
|
}
|
|
// check the name matches the expected
|
|
if (!name.matches(regex)) {
|
|
log("Test FAIL: result of Class::getName" + " \"" + name + "\" does not match " + regex);
|
|
failed = true;
|
|
}
|
|
// check the string name matches the expected
|
|
if (!toString.matches("class " + regex)) {
|
|
log("Test FAIL: result of Class::toString" + " \"" + name + "\" does not match " + regex);
|
|
failed = true;
|
|
}
|
|
return failed;
|
|
}
|
|
|
|
static boolean checkTypeName(Class<?> klass, String name) {
|
|
boolean failed = false;
|
|
// construct the expected type name
|
|
String regex = HC_NAME + "/" + HC_SUFFIX_REGEX;
|
|
Class<?> c = klass;
|
|
|
|
// for an array add the suffix "[]" for each dimension
|
|
while (c.isArray()) {
|
|
c = c.componentType();
|
|
regex = regex + "\\[\\]";
|
|
}
|
|
// check the type name matches the expected
|
|
if (!name.matches(regex)) {
|
|
log("Test FAIL: result of Class::getTypeName" + " \"" + name + "\" does not match " + regex);
|
|
failed = true;
|
|
}
|
|
return failed;
|
|
}
|
|
|
|
static boolean checkGenericString(Class<?> klass, String name) {
|
|
boolean failed = false;
|
|
Class<?> c = klass;
|
|
// construct the expected generic string
|
|
String regex = HC_NAME + "/" + HC_SUFFIX_REGEX + "<T>";
|
|
|
|
// add the expected name prefix for a non-array class
|
|
if (!klass.isArray()) {
|
|
regex = "class " + regex;
|
|
}
|
|
// for an array get the bottom component class
|
|
while (c.isArray()) {
|
|
c = c.componentType();
|
|
regex = regex + "\\[\\]";
|
|
}
|
|
// check the generic string matches the expected
|
|
if (!name.matches(regex)) {
|
|
log("Test FAIL: result of Class::toGenericString" + " \"" + name + "\" does not match " + regex);
|
|
failed = true;
|
|
}
|
|
return failed;
|
|
}
|
|
|
|
static boolean checkDescriptorString(Class<?> klass, String name) {
|
|
boolean failed = false;
|
|
// construct the expected descriptor string
|
|
String regex = "L" + HC_NAME.replace('.', '/') + "." + HC_SUFFIX_REGEX + ";";
|
|
Class<?> c = klass;
|
|
|
|
// for array get the bottom component class
|
|
while (c.isArray()) {
|
|
regex = "\\[" + regex;
|
|
c = c.componentType();
|
|
}
|
|
// check the descriptor string matches the expected
|
|
if (!name.matches(regex)) {
|
|
log("Test FAIL: result of Class::descriptorString" + " \"" + name + "\" does not match " + regex);
|
|
failed = true;
|
|
}
|
|
return failed;
|
|
}
|
|
|
|
static boolean testClass(Class<?> klass) {
|
|
boolean failed = false;
|
|
logClassInfo(klass);
|
|
|
|
// verify all name variations
|
|
failed |= checkName(klass, klass.getName(), klass.toString());
|
|
failed |= checkTypeName(klass, klass.getTypeName());
|
|
failed |= checkGenericString(klass, klass.toGenericString());
|
|
failed |= checkDescriptorString(klass, klass.descriptorString());
|
|
|
|
// an array class is never hidden
|
|
if (klass.isArray() && klass.isHidden()) {
|
|
log("Test FAIL: an array class is never hidden");
|
|
failed = true;
|
|
}
|
|
|
|
// verify hidden class array or class by the native agent
|
|
if (klass.isArray()) {
|
|
checkHiddenClassArray(klass, klass.descriptorString());
|
|
} else {
|
|
checkHiddenClass(klass, klass.descriptorString());
|
|
}
|
|
return failed;
|
|
}
|
|
|
|
public static void main(String args[]) throws Exception {
|
|
log(LOG_PREFIX + "started");
|
|
|
|
// define a hidden class to test
|
|
Class<?> hc = defineHiddenClass(HCName);
|
|
|
|
// allocate a hidden class instance to test
|
|
HCInterf<String> testObj = (HCInterf<String>)hc.newInstance();
|
|
|
|
String str = testObj.hcMethod("Test generic hidden class");
|
|
log(LOG_PREFIX + "hc.hcMethod() returned string: " + str);
|
|
|
|
// test all hidden class name/signature variations
|
|
boolean failed = testClass(hc);
|
|
|
|
// test all hidden class array name/signature variations
|
|
Class<?> hcArr = hc.arrayType();
|
|
failed |= testClass(hcArr);
|
|
|
|
// test all hidden class double array name/signature variations
|
|
Class<?> hcArrArr = hcArr.arrayType();
|
|
failed |= testClass(hcArrArr);
|
|
|
|
if (failed) { // check the java part failing status
|
|
throw new RuntimeException("FAIL: failed status from java part");
|
|
}
|
|
if (checkFailed()) { // check the native agent failing status
|
|
throw new RuntimeException("FAIL: failed status from native agent");
|
|
}
|
|
log(LOG_PREFIX + "finished");
|
|
}
|
|
}
|