196 lines
8.1 KiB
Java
196 lines
8.1 KiB
Java
/*
|
|
* Copyright (c) 2022, 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 8282241
|
|
* @summary Verifies class redefinition correctly updates generic_signature and source_file_name attributes
|
|
* @requires vm.jvmti
|
|
* @modules java.base/jdk.internal.org.objectweb.asm
|
|
* java.instrument
|
|
* @library /test/lib
|
|
* @run main RedefineClassHelper
|
|
* @run main/othervm -javaagent:redefineagent.jar --add-opens=java.base/java.lang=ALL-UNNAMED RedefineGenericSignatureTest
|
|
*/
|
|
|
|
import java.io.File;
|
|
import java.io.FileOutputStream;
|
|
import java.lang.invoke.MethodHandle;
|
|
import java.lang.invoke.MethodHandles;
|
|
import java.lang.invoke.MethodType;
|
|
import java.lang.reflect.Type;
|
|
import java.nio.file.Files;
|
|
import java.util.List;
|
|
|
|
import jdk.internal.org.objectweb.asm.ClassReader;
|
|
import jdk.internal.org.objectweb.asm.ClassVisitor;
|
|
import jdk.internal.org.objectweb.asm.ClassWriter;
|
|
import jdk.internal.org.objectweb.asm.Opcodes;
|
|
import jdk.test.lib.Asserts;
|
|
import jdk.test.lib.JDKToolLauncher;
|
|
import jdk.test.lib.compiler.InMemoryJavaCompiler;
|
|
import jdk.test.lib.process.ProcessTools;
|
|
import jdk.test.lib.process.OutputAnalyzer;
|
|
|
|
class GenericSignatureTester {
|
|
public GenericSignatureTarget<List<String>> method1() {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
class GenericSignatureTarget<T extends List<?>> {
|
|
public GenericSignatureTarget<T> foo() { return null; }
|
|
public static void throwException() { throw new RuntimeException(); }
|
|
}
|
|
|
|
public class RedefineGenericSignatureTest {
|
|
private static final String newTargetClassSource =
|
|
"class GenericSignatureTarget<T> {\n" +
|
|
" public GenericSignatureTarget<T> foo() { return null; }\n" +
|
|
" public static void throwException() { throw new RuntimeException(); }\n" +
|
|
"}\n";
|
|
|
|
public static void main (String[] args) throws Throwable {
|
|
RedefineGenericSignatureTest test = new RedefineGenericSignatureTest();
|
|
test.runTest();
|
|
}
|
|
|
|
private final static String sourceFileName = "RedefineGenericSignatureTest.java";
|
|
private final static String sourceFileNameNew = "RedefineGenericSignatureTestNew.java";
|
|
// expected signature of GenericSignatureTester.method1 return type
|
|
private final static String expectedRetType = "GenericSignatureTarget<java.util.List<java.lang.String>>";
|
|
// expected generic signature of the original GenericSignatureTarget
|
|
private final static String expectedSigOld = "<T::Ljava/util/List<*>;>Ljava/lang/Object;";
|
|
// expected generic signature of the redefined GenericSignatureTarget
|
|
private final static String expectedSigNew = "<T:Ljava/lang/Object;>Ljava/lang/Object;";
|
|
|
|
private static void log(Object o) {
|
|
System.out.println(o);
|
|
}
|
|
|
|
private String getTargetGenSig() throws Throwable {
|
|
MethodHandles.Lookup lookup = MethodHandles.lookup();
|
|
MethodHandles.Lookup classLookup = MethodHandles.privateLookupIn(Class.class, lookup);
|
|
MethodHandle getGenericSignature0 = classLookup.findVirtual(
|
|
Class.class, "getGenericSignature0", MethodType.methodType(String.class));
|
|
Object genericSignature = getGenericSignature0.invoke(GenericSignatureTarget.class);
|
|
return String.valueOf(genericSignature);
|
|
}
|
|
|
|
private String getTesterRetType() throws Throwable {
|
|
Type type = GenericSignatureTester.class.getDeclaredMethod("method1").getGenericReturnType();
|
|
return String.valueOf(type);
|
|
}
|
|
|
|
private String getTargetSourceFilename() {
|
|
try {
|
|
GenericSignatureTarget.throwException();
|
|
} catch (RuntimeException ex) {
|
|
return ex.getStackTrace()[0].getFileName();
|
|
}
|
|
return "Cannot get source file name";
|
|
}
|
|
|
|
// Prints dissassembled class bytes.
|
|
private void printDisassembled(String description, Class cls, byte[] bytes) throws Exception {
|
|
log(description + " -------------------");
|
|
|
|
File f = new File(cls.getSimpleName()+".class");
|
|
try (FileOutputStream fos = new FileOutputStream(f)) {
|
|
fos.write(bytes);
|
|
}
|
|
JDKToolLauncher javap = JDKToolLauncher.create("javap")
|
|
.addToolArg("-verbose")
|
|
.addToolArg("-p") // Shows all classes and members.
|
|
//.addToolArg("-c") // Prints out disassembled code
|
|
.addToolArg("-s") // Prints internal type signatures.
|
|
.addToolArg(f.toString());
|
|
ProcessBuilder pb = new ProcessBuilder(javap.getCommand());
|
|
OutputAnalyzer out = ProcessTools.executeProcess(pb);
|
|
out.shouldHaveExitValue(0);
|
|
try {
|
|
Files.delete(f.toPath());
|
|
} catch (Exception ex) {
|
|
// ignore
|
|
}
|
|
out.asLines().forEach(s -> log(s));
|
|
log("==========================================");
|
|
Files.deleteIfExists(f.toPath());
|
|
}
|
|
|
|
private byte[] getNewClassBytes() {
|
|
byte[] bytecode = InMemoryJavaCompiler.compile(GenericSignatureTarget.class.getName(), newTargetClassSource);
|
|
|
|
ClassWriter cw = new ClassWriter(0);
|
|
ClassReader cr = new ClassReader(bytecode);
|
|
cr.accept(new ClassVisitor(Opcodes.ASM7, cw) {
|
|
private boolean sourceSet = false;
|
|
@Override
|
|
public void visitSource(String source, String debug) {
|
|
sourceSet = true;
|
|
log("Changing source: \"" + source + "\" -> \"" + sourceFileNameNew + "\"");
|
|
super.visitSource(sourceFileNameNew, debug);
|
|
}
|
|
|
|
@Override
|
|
public void visitEnd() {
|
|
if (!sourceSet) {
|
|
log("Set source: \"" + sourceFileNameNew + "\"");
|
|
super.visitSource(sourceFileNameNew, null);
|
|
}
|
|
super.visitEnd();
|
|
}
|
|
}, 0);
|
|
return cw.toByteArray();
|
|
}
|
|
|
|
private void runTest() throws Throwable {
|
|
Class targetClass = GenericSignatureTarget.class;
|
|
|
|
String oldSig = getTargetGenSig();
|
|
log("old target class sig: \"" + oldSig + "\"");
|
|
|
|
byte[] oldClassBytes = targetClass.getResourceAsStream(targetClass.getName() + ".class").readAllBytes();
|
|
printDisassembled("Old " + targetClass.getName(), targetClass, oldClassBytes);
|
|
|
|
log("Redefining " + targetClass.getName() + " class");
|
|
byte[] newClassBytes = getNewClassBytes();
|
|
printDisassembled("New " + targetClass.getName(), targetClass, newClassBytes);
|
|
RedefineClassHelper.redefineClass(targetClass, newClassBytes);
|
|
|
|
String newSig = getTargetGenSig();
|
|
log("new target class sig: \"" + newSig + "\"");
|
|
|
|
String newRetType = getTesterRetType();
|
|
log("new tester ret type: \"" + newRetType + "\"");
|
|
|
|
String newSrcFileName = getTargetSourceFilename();
|
|
log("new source file name: \"" + newSrcFileName + "\"");
|
|
|
|
Asserts.assertStringsEqual(expectedSigOld, oldSig, "wrong old generic signature");
|
|
Asserts.assertStringsEqual(expectedSigNew, newSig, "wrong new generic signature");
|
|
Asserts.assertStringsEqual(expectedRetType, newRetType, "wrong ret type");
|
|
Asserts.assertStringsEqual(sourceFileNameNew, newSrcFileName, "wrong new source file name");
|
|
}
|
|
}
|