8295059: test/langtools/tools/javap 12 test classes use com.sun.tools.classfile library

Reviewed-by: asotona

Author: xqoasis

test/langtools/tools/javap/T6716452.java

@@ -24,11 +24,18 @@
 /*
  * @test 6716452
  * @summary need a method to get an index of an attribute
- * @modules jdk.jdeps/com.sun.tools.classfile
+ * @modules java.base/jdk.internal.classfile
+ *          java.base/jdk.internal.classfile.attribute
+ *          java.base/jdk.internal.classfile.constantpool
+ *          java.base/jdk.internal.classfile.instruction
+ *          java.base/jdk.internal.classfile.components
  */
 
 import java.io.*;
-import com.sun.tools.classfile.*;
+import java.nio.file.Files;
+
+import jdk.internal.classfile.*;
+import jdk.internal.classfile.attribute.*;
 
 public class T6716452 {
     public static void main(String[] args) throws Exception {
@@ -38,49 +45,44 @@ public static void main(String[] args) throws Exception {
     public void run() throws Exception {
         File javaFile = writeTestFile();
         File classFile = compileTestFile(javaFile);
-
-        ClassFile cf = ClassFile.read(classFile);
-        for (Method m: cf.methods) {
-            test(cf, m);
+        ClassModel cm = Classfile.of().parse(classFile.toPath());
+        for (MethodModel mm: cm.methods()) {
+            test(mm);
         }
 
         if (errors > 0)
             throw new Exception(errors + " errors found");
     }
 
-    void test(ClassFile cf, Method m) {
-        test(cf, m, Attribute.Code, Code_attribute.class);
-        test(cf, m, Attribute.Exceptions, Exceptions_attribute.class);
+    void test(MethodModel mm) {
+        test(mm, Attributes.CODE, CodeAttribute.class);
+        test(mm, Attributes.EXCEPTIONS, ExceptionsAttribute.class);
     }
 
-    // test the result of Attributes.getIndex according to expectations
+    // test the result of MethodModel.findAttribute, MethodModel.attributes().indexOf() according to expectations
     // encoded in the method's name
-    void test(ClassFile cf, Method m, String name, Class<?> c) {
-        int index = m.attributes.getIndex(cf.constant_pool, name);
-        try {
-            String m_name = m.getName(cf.constant_pool);
-            System.err.println("Method " + m_name + " name:" + name + " index:" + index + " class: " + c);
-            boolean expect = (m_name.equals("<init>") && name.equals("Code"))
-                || (m_name.indexOf(name) != -1);
-            boolean found = (index != -1);
-            if (expect) {
-                if (found) {
-                    Attribute attr = m.attributes.get(index);
-                    if (!c.isAssignableFrom(attr.getClass())) {
-                        error(m + ": unexpected attribute found,"
-                              + " expected " + c.getName()
-                              + " found " + attr.getClass().getName());
-                    }
-                } else {
-                    error(m + ": expected attribute " + name + " not found");
+    <T extends Attribute<T>> void test(MethodModel mm, AttributeMapper<T> attr, Class<?> c) {
+        Attribute<T> attr_instance = mm.findAttribute(attr).orElse(null);
+        int index = mm.attributes().indexOf(attr_instance);
+        String mm_name = mm.methodName().stringValue();
+        System.err.println("Method " + mm_name + " name:" + attr.name() + " index:" + index + " class: " + c);
+        boolean expect = (mm_name.equals("<init>") && attr.name().equals("Code"))
+                || (mm_name.contains(attr.name()));
+        boolean found = (index != -1);
+        if (expect) {
+            if (found) {
+                if (!c.isAssignableFrom(mm.attributes().get(index).getClass())) {
+                    error(mm + ": unexpected attribute found,"
+                            + " expected " + c.getName()
+                            + " found " + mm.attributes().get(index).attributeName());
                 }
             } else {
-                if (found) {
-                    error(m + ": unexpected attribute " + name);
-                }
+                error(mm + ": expected attribute " + attr.name() + " not found");
+            }
+        } else {
+            if (found) {
+                error(mm + ": unexpected attribute " + attr.name());
             }
-        } catch (ConstantPoolException e) {
-            error(m + ": " + e);
         }
     }
 

test/langtools/tools/javap/TestClassNameWarning.java

@@ -29,12 +29,17 @@
  * @modules
  *      jdk.compiler/com.sun.tools.javac.api
  *      jdk.compiler/com.sun.tools.javac.main
- *      jdk.jdeps/com.sun.tools.classfile
  *      jdk.jdeps/com.sun.tools.javap
+ *      java.base/jdk.internal.classfile
+ *      java.base/jdk.internal.classfile.attribute
+ *      java.base/jdk.internal.classfile.constantpool
+ *      java.base/jdk.internal.classfile.instruction
+ *      java.base/jdk.internal.classfile.components
  * @build toolbox.JavacTask toolbox.JavapTask toolbox.ToolBox toolbox.TestRunner
  * @run main TestClassNameWarning
  */
 
+import java.lang.constant.ClassDesc;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
@@ -43,9 +48,8 @@
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
-import com.sun.tools.classfile.ClassFile;
-import com.sun.tools.classfile.ClassWriter;
 
+import jdk.internal.classfile.*;
 import toolbox.JavacTask;
 import toolbox.JavapTask;
 import toolbox.Task;
@@ -140,7 +144,7 @@ public void testLegacyModuleInfo(Path base) throws Exception {
         byte[] replaceBytes = "module-info".getBytes("UTF-8");
         for (int i = 0; i < bytes.length - searchBytes.length; i++) {
             if (Arrays.equals(bytes, i, i + searchBytes.length,
-                                searchBytes, 0, searchBytes.length)) {
+                    searchBytes, 0, searchBytes.length)) {
                 System.arraycopy(replaceBytes, 0, bytes, i, replaceBytes.length);
             }
         }
@@ -172,14 +176,15 @@ public void testNoNameClass(Path base) throws Exception {
                 .files(tb.findJavaFiles(src))
                 .run()
                 .writeAll();
-
-        ClassFile cf = ClassFile.read(classes.resolve("A.class"));
-        ClassFile cf2 = new ClassFile(
-                cf.magic, cf.minor_version, cf.major_version, cf.constant_pool,
-                cf.access_flags,
-                0, // this_class,
-                cf.super_class, cf.interfaces, cf.fields, cf.methods, cf.attributes);
-        new ClassWriter().write(cf2, Files.newOutputStream(classes.resolve("Z.class")));
+        ClassModel cm = Classfile.of().parse(classes.resolve("A.class"));
+        Classfile.of().buildTo(
+                classes.resolve("Z.class"),
+                ClassDesc.of("0"), cb -> {
+                    for (ClassElement ce : cm) {
+                        cb.with(ce);
+                    }
+                }
+        );
 
         List<String> log = new JavapTask(tb)
                 .classpath(classes.toString())
@@ -238,4 +243,3 @@ private void checkOutput(List<String> log, boolean expect, String regex) {
         }
     }
 }
-