1 /*
2  * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * This code is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 only, as
7  * published by the Free Software Foundation.
8  *
9  * This code is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12  * version 2 for more details (a copy is included in the LICENSE file that
13  * accompanied this code).
14  *
15  * You should have received a copy of the GNU General Public License version
16  * 2 along with this work; if not, write to the Free Software Foundation,
17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18  *
19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20  * or visit www.oracle.com if you need additional information or have any
21  * questions.
22  */
23 
24 /* @test
25  * @bug 8057919
26  * @summary Class.getSimpleName() should work for non-JLS compliant class names
27  * @modules java.base/jdk.internal.org.objectweb.asm
28  */
29 import jdk.internal.org.objectweb.asm.*;
30 import static jdk.internal.org.objectweb.asm.Opcodes.*;
31 
32 public class GetSimpleNameTest {
33     static class NestedClass {}
34     class InnerClass {}
35 
f1()36     static Class<?> f1() {
37         class LocalClass {}
38         return LocalClass.class;
39     }
40 
main(String[] args)41     public static void main(String[] args) throws Exception {
42         assertEquals(NestedClass.class.getSimpleName(), "NestedClass");
43         assertEquals( InnerClass.class.getSimpleName(),  "InnerClass");
44         assertEquals(             f1().getSimpleName(),  "LocalClass");
45 
46         java.io.Serializable anon = new java.io.Serializable() {};
47         assertEquals(anon.getClass().getSimpleName(), "");
48 
49         // Java class names, prepended enclosing class name.
50         testNested("p.Outer$Nested", "p.Outer", "Nested");
51         testInner( "p.Outer$Inner",  "p.Inner",  "Inner");
52         testLocal( "p.Outer$1Local", "p.Outer",  "Local");
53         testAnon(  "p.Outer$1",      "p.Outer",       "");
54 
55         // Non-Java class names, prepended enclosing class name.
56         testNested("p.$C1$Nested", "p.$C1$", "Nested");
57         testInner( "p.$C1$Inner",  "p.$C1$",  "Inner");
58         testLocal( "p.$C1$Local",  "p.$C1$",  "Local");
59         testAnon(  "p.$C1$1",      "p.$C1$",       "");
60 
61         // Non-Java class names, unrelated class names.
62         testNested("p1.$Nested$", "p2.$C1$", "Nested");
63         testInner( "p1.$Inner$",  "p2.$C1$",  "Inner");
64         testLocal( "p1.$Local$",  "p2.$C1$",  "Local");
65         testAnon(  "p1.$anon$",   "p2.$C1$",       "");
66     }
67 
testNested(String innerName, String outerName, String simpleName)68     static void testNested(String innerName, String outerName, String simpleName) throws Exception {
69         BytecodeGenerator bg = new BytecodeGenerator(innerName, outerName, simpleName);
70         CustomCL cl = new CustomCL(innerName, outerName, bg.getNestedClasses(true), bg.getNestedClasses(false));
71         assertEquals(cl.loadClass(innerName).getSimpleName(), simpleName);
72     }
73 
testInner(String innerName, String outerName, String simpleName)74     static void testInner(String innerName, String outerName, String simpleName) throws Exception {
75         BytecodeGenerator bg = new BytecodeGenerator(innerName, outerName, simpleName);
76         CustomCL cl = new CustomCL(innerName, outerName, bg.getInnerClasses(true), bg.getInnerClasses(false));
77         assertEquals(cl.loadClass(innerName).getSimpleName(), simpleName);
78     }
79 
testLocal(String innerName, String outerName, String simpleName)80     static void testLocal(String innerName, String outerName, String simpleName) throws Exception {
81         BytecodeGenerator bg = new BytecodeGenerator(innerName, outerName, simpleName);
82         CustomCL cl = new CustomCL(innerName, outerName, bg.getLocalClasses(true), bg.getLocalClasses(false));
83         assertEquals(cl.loadClass(innerName).getSimpleName(), simpleName);
84     }
85 
testAnon(String innerName, String outerName, String simpleName)86     static void testAnon(String innerName, String outerName, String simpleName) throws Exception {
87         BytecodeGenerator bg = new BytecodeGenerator(innerName, outerName, simpleName);
88         CustomCL cl = new CustomCL(innerName, outerName, bg.getAnonymousClasses(true), bg.getAnonymousClasses(false));
89         assertEquals(cl.loadClass(innerName).getSimpleName(), simpleName);
90     }
91 
assertEquals(Object o1, Object o2)92     static void assertEquals(Object o1, Object o2) {
93         if (!java.util.Objects.equals(o1, o2)) {
94             throw new AssertionError(o1 + " != " + o2);
95         }
96     }
97 
98     static class CustomCL extends ClassLoader {
99         final String  innerName;
100         final String  outerName;
101 
102         final byte[] innerClassFile;
103         final byte[] outerClassFile;
104 
CustomCL(String innerName, String outerName, byte[] innerClassFile, byte[] outerClassFile)105         CustomCL(String innerName, String outerName, byte[] innerClassFile, byte[] outerClassFile) {
106             this.innerName = innerName;
107             this.outerName = outerName;
108             this.innerClassFile = innerClassFile;
109             this.outerClassFile = outerClassFile;
110         }
111         @Override
findClass(String name)112         protected Class<?> findClass(String name) throws ClassNotFoundException {
113             if (innerName.equals(name)) {
114                 return defineClass(innerName, innerClassFile, 0, innerClassFile.length);
115             } else if (outerName.equals(name)) {
116                 return defineClass(outerName, outerClassFile, 0, outerClassFile.length);
117             } else {
118                 throw new ClassNotFoundException(name);
119             }
120         }
121     }
122 
123     static class BytecodeGenerator {
124         final String innerName;
125         final String outerName;
126         final String simpleName;
127 
BytecodeGenerator(String innerName, String outerName, String simpleName)128         BytecodeGenerator(String innerName, String outerName, String simpleName) {
129             this.innerName = intl(innerName);
130             this.outerName = intl(outerName);
131             this.simpleName = simpleName;
132         }
133 
intl(String name)134         static String intl(String name) { return name.replace('.', '/'); }
135 
makeDefaultCtor(ClassWriter cw)136         static void makeDefaultCtor(ClassWriter cw) {
137             MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
138             mv.visitCode();
139             mv.visitVarInsn(ALOAD, 0);
140             mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
141             mv.visitInsn(RETURN);
142             mv.visitMaxs(1, 1);
143             mv.visitEnd();
144         }
145 
makeCtxk(ClassWriter cw, boolean isInner)146         void makeCtxk(ClassWriter cw, boolean isInner) {
147             if (isInner) {
148                 cw.visitOuterClass(outerName, "f", "()V");
149             } else {
150                 MethodVisitor mv = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "f", "()V", null, null);
151                 mv.visitCode();
152                 mv.visitInsn(RETURN);
153                 mv.visitMaxs(0, 0);
154                 mv.visitEnd();
155             }
156         }
157 
getNestedClasses(boolean isInner)158         byte[] getNestedClasses(boolean isInner) {
159             String name = (isInner ? innerName : outerName);
160             ClassWriter cw = new ClassWriter(0);
161             cw.visit(V1_7, ACC_PUBLIC + ACC_SUPER, name, null, "java/lang/Object", null);
162 
163             cw.visitInnerClass(innerName, outerName, simpleName, ACC_PUBLIC | ACC_STATIC);
164 
165             makeDefaultCtor(cw);
166             cw.visitEnd();
167             return cw.toByteArray();
168         }
169 
getInnerClasses(boolean isInner)170         byte[] getInnerClasses(boolean isInner) {
171             String name = (isInner ? innerName : outerName);
172             ClassWriter cw = new ClassWriter(0);
173             cw.visit(V1_7, ACC_PUBLIC + ACC_SUPER, name, null, "java/lang/Object", null);
174 
175             cw.visitInnerClass(innerName, outerName, simpleName, ACC_PUBLIC);
176 
177             makeDefaultCtor(cw);
178             cw.visitEnd();
179             return cw.toByteArray();
180         }
181 
getLocalClasses(boolean isInner)182         byte[] getLocalClasses(boolean isInner) {
183             String name = (isInner ? innerName : outerName);
184             ClassWriter cw = new ClassWriter(0);
185             cw.visit(V1_7, ACC_PUBLIC + ACC_SUPER, name, null, "java/lang/Object", null);
186 
187             cw.visitInnerClass(innerName, null, simpleName, ACC_PUBLIC | ACC_STATIC);
188             makeCtxk(cw, isInner);
189 
190             makeDefaultCtor(cw);
191             cw.visitEnd();
192             return cw.toByteArray();
193         }
194 
getAnonymousClasses(boolean isInner)195         byte[] getAnonymousClasses(boolean isInner) {
196             String name = (isInner ? innerName : outerName);
197             ClassWriter cw = new ClassWriter(0);
198             cw.visit(V1_7, ACC_PUBLIC + ACC_SUPER, name, null, "java/lang/Object", null);
199 
200             cw.visitInnerClass(innerName, null, null, ACC_PUBLIC | ACC_STATIC);
201             makeCtxk(cw, isInner);
202 
203             makeDefaultCtor(cw);
204             cw.visitEnd();
205             return cw.toByteArray();
206         }
207     }
208 }
209