/* * Copyright (c) 2015, 2024, 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 8057919 * @summary Class.getSimpleName() should work for non-JLS compliant class names */ import java.lang.classfile.ClassBuilder; import java.lang.classfile.ClassFile; import java.lang.classfile.CodeBuilder; import java.lang.classfile.attribute.EnclosingMethodAttribute; import java.lang.classfile.attribute.InnerClassInfo; import java.lang.classfile.attribute.InnerClassesAttribute; import java.lang.constant.ClassDesc; import java.lang.reflect.AccessFlag; import java.util.Optional; import static java.lang.classfile.ClassFile.ACC_PUBLIC; import static java.lang.classfile.ClassFile.ACC_STATIC; import static java.lang.constant.ConstantDescs.CD_Object; import static java.lang.constant.ConstantDescs.INIT_NAME; import static java.lang.constant.ConstantDescs.MTD_void; public class GetSimpleNameTest { static class NestedClass {} class InnerClass {} static Class f1() { class LocalClass {} return LocalClass.class; } public static void main(String[] args) throws Exception { assertEquals(NestedClass.class.getSimpleName(), "NestedClass"); assertEquals( InnerClass.class.getSimpleName(), "InnerClass"); assertEquals( f1().getSimpleName(), "LocalClass"); java.io.Serializable anon = new java.io.Serializable() {}; assertEquals(anon.getClass().getSimpleName(), ""); // Java class names, prepended enclosing class name. testNested("p.Outer$Nested", "p.Outer", "Nested"); testInner( "p.Outer$Inner", "p.Inner", "Inner"); testLocal( "p.Outer$1Local", "p.Outer", "Local"); testAnon( "p.Outer$1", "p.Outer", ""); // Non-Java class names, prepended enclosing class name. testNested("p.$C1$Nested", "p.$C1$", "Nested"); testInner( "p.$C1$Inner", "p.$C1$", "Inner"); testLocal( "p.$C1$Local", "p.$C1$", "Local"); testAnon( "p.$C1$1", "p.$C1$", ""); // Non-Java class names, unrelated class names. testNested("p1.$Nested$", "p2.$C1$", "Nested"); testInner( "p1.$Inner$", "p2.$C1$", "Inner"); testLocal( "p1.$Local$", "p2.$C1$", "Local"); testAnon( "p1.$anon$", "p2.$C1$", ""); } static void testNested(String innerName, String outerName, String simpleName) throws Exception { BytecodeGenerator bg = new BytecodeGenerator(innerName, outerName, simpleName); CustomCL cl = new CustomCL(innerName, outerName, bg.getNestedClasses(true), bg.getNestedClasses(false)); assertEquals(cl.loadClass(innerName).getSimpleName(), simpleName); } static void testInner(String innerName, String outerName, String simpleName) throws Exception { BytecodeGenerator bg = new BytecodeGenerator(innerName, outerName, simpleName); CustomCL cl = new CustomCL(innerName, outerName, bg.getInnerClasses(true), bg.getInnerClasses(false)); assertEquals(cl.loadClass(innerName).getSimpleName(), simpleName); } static void testLocal(String innerName, String outerName, String simpleName) throws Exception { BytecodeGenerator bg = new BytecodeGenerator(innerName, outerName, simpleName); CustomCL cl = new CustomCL(innerName, outerName, bg.getLocalClasses(true), bg.getLocalClasses(false)); assertEquals(cl.loadClass(innerName).getSimpleName(), simpleName); } static void testAnon(String innerName, String outerName, String simpleName) throws Exception { BytecodeGenerator bg = new BytecodeGenerator(innerName, outerName, simpleName); CustomCL cl = new CustomCL(innerName, outerName, bg.getAnonymousClasses(true), bg.getAnonymousClasses(false)); assertEquals(cl.loadClass(innerName).getSimpleName(), simpleName); } static void assertEquals(Object o1, Object o2) { if (!java.util.Objects.equals(o1, o2)) { throw new AssertionError(o1 + " != " + o2); } } static class CustomCL extends ClassLoader { final String innerName; final String outerName; final byte[] innerClassFile; final byte[] outerClassFile; CustomCL(String innerName, String outerName, byte[] innerClassFile, byte[] outerClassFile) { this.innerName = innerName; this.outerName = outerName; this.innerClassFile = innerClassFile; this.outerClassFile = outerClassFile; } @Override protected Class findClass(String name) throws ClassNotFoundException { if (innerName.equals(name)) { return defineClass(innerName, innerClassFile, 0, innerClassFile.length); } else if (outerName.equals(name)) { return defineClass(outerName, outerClassFile, 0, outerClassFile.length); } else { throw new ClassNotFoundException(name); } } } static class BytecodeGenerator { final ClassDesc innerName; final ClassDesc outerName; final String simpleName; BytecodeGenerator(String innerName, String outerName, String simpleName) { this.innerName = ClassDesc.of(innerName); this.outerName = ClassDesc.of(outerName); this.simpleName = simpleName; } static void makeDefaultCtor(ClassBuilder clb) { clb.withMethodBody(INIT_NAME, MTD_void, ACC_PUBLIC, cb -> { cb.aload(0); cb.invokespecial(CD_Object, INIT_NAME, MTD_void); cb.return_(); }); } void makeCtxk(ClassBuilder clb, boolean isInner) { if (isInner) { clb.with(EnclosingMethodAttribute.of(outerName, Optional.of("f"), Optional.of(MTD_void))); } else { clb.withMethodBody("f", MTD_void, ACC_PUBLIC | ACC_STATIC, CodeBuilder::return_); } } byte[] getNestedClasses(boolean isInner) { var name = (isInner ? innerName : outerName); return ClassFile.of().build(name, clb -> { clb.withSuperclass(CD_Object); clb.withFlags(AccessFlag.PUBLIC, AccessFlag.SUPER); clb.with(InnerClassesAttribute.of( InnerClassInfo.of(innerName, Optional.of(outerName), Optional.of(simpleName)))); makeDefaultCtor(clb); }); } byte[] getInnerClasses(boolean isInner) { var name = (isInner ? innerName : outerName); return ClassFile.of().build(name, clb -> { clb.withSuperclass(CD_Object); clb.withFlags(AccessFlag.PUBLIC, AccessFlag.SUPER); clb.with(InnerClassesAttribute.of( InnerClassInfo.of(innerName, Optional.of(outerName), Optional.of(simpleName), AccessFlag.PUBLIC))); makeDefaultCtor(clb); }); } byte[] getLocalClasses(boolean isInner) { var name = (isInner ? innerName : outerName); return ClassFile.of().build(name, clb -> { clb.withSuperclass(CD_Object); clb.withFlags(AccessFlag.PUBLIC, AccessFlag.SUPER); clb.with(InnerClassesAttribute.of( InnerClassInfo.of(innerName, Optional.empty(), Optional.of(simpleName), AccessFlag.PUBLIC, AccessFlag.STATIC))); makeDefaultCtor(clb); makeCtxk(clb, isInner); }); } byte[] getAnonymousClasses(boolean isInner) { var name = (isInner ? innerName : outerName); return ClassFile.of().build(name, clb -> { clb.withSuperclass(CD_Object); clb.withFlags(AccessFlag.PUBLIC, AccessFlag.SUPER); clb.with(InnerClassesAttribute.of( InnerClassInfo.of(innerName, Optional.empty(), Optional.empty(), AccessFlag.PUBLIC, AccessFlag.STATIC))); makeDefaultCtor(clb); makeCtxk(clb, isInner); }); } } }