From e9d81d6defd07d46548f0db03fb07a36bee05702 Mon Sep 17 00:00:00 2001 From: Algent Date: Thu, 3 Sep 2026 19:43:01 +0200 Subject: [PATCH] test: characterize compiler startup --- ...ASMMixinCompilerStartupFunctionalTest.java | 167 ++++++++++++++++++ 1 file changed, 167 insertions(+) create mode 100644 src/functionalTest/java/codechicken/multipart/test/ASMMixinCompilerStartupFunctionalTest.java diff --git a/src/functionalTest/java/codechicken/multipart/test/ASMMixinCompilerStartupFunctionalTest.java b/src/functionalTest/java/codechicken/multipart/test/ASMMixinCompilerStartupFunctionalTest.java new file mode 100644 index 0000000..e3a5b37 --- /dev/null +++ b/src/functionalTest/java/codechicken/multipart/test/ASMMixinCompilerStartupFunctionalTest.java @@ -0,0 +1,167 @@ +package codechicken.multipart.test; + +import static org.junit.jupiter.api.Assertions.*; +import static org.objectweb.asm.Opcodes.*; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.net.URL; +import java.util.HashMap; +import java.util.Set; + +import net.minecraft.launchwrapper.LaunchClassLoader; + +import org.junit.jupiter.api.Test; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; + +import codechicken.multipart.asm.ASMMixinCompiler$; +import codechicken.multipart.asm.ASMMixinCompiler.ClassInfo; +import codechicken.multipart.asm.ASMMixinCompiler.MixinInfo; +import scala.collection.JavaConversions; +import scala.collection.mutable.Map; + +class ASMMixinCompilerStartupFunctionalTest { + + private static final ASMMixinCompiler$ COMPILER = ASMMixinCompiler$.MODULE$; + private static final String PREFIX = "codechicken/multipart/test/bootstrap/"; + + @Test + void bindsTheCompilerToItsActualForgeLaunchClassLoader() { + assertSame(ASMMixinCompiler$.class.getClassLoader(), COMPILER.cl()); + assertInstanceOf(LaunchClassLoader.class, COMPILER.cl()); + } + + @Test + void resolvesAndOpensTheExactJdkAndLaunchWrapperMembers() { + Method define = COMPILER.m_defineClass(); + assertEquals(ClassLoader.class, define.getDeclaringClass()); + assertEquals("defineClass", define.getName()); + assertArrayEquals(new Class[] { byte[].class, int.class, int.class }, define.getParameterTypes()); + assertEquals(Class.class, define.getReturnType()); + assertTrue(Modifier.isFinal(define.getModifiers())); + assertTrue(define.isAccessible()); + + Method transform = COMPILER.m_runTransformers(); + assertEquals(LaunchClassLoader.class, transform.getDeclaringClass()); + assertEquals("runTransformers", transform.getName()); + assertArrayEquals(new Class[] { String.class, String.class, byte[].class }, transform.getParameterTypes()); + assertEquals(byte[].class, transform.getReturnType()); + assertTrue(Modifier.isPrivate(transform.getModifiers())); + assertTrue(transform.isAccessible()); + + Field exclusions = COMPILER.f_transformerExceptions(); + assertEquals(LaunchClassLoader.class, exclusions.getDeclaringClass()); + assertEquals("transformerExceptions", exclusions.getName()); + assertEquals(Set.class, exclusions.getType()); + assertTrue(Modifier.isPrivate(exclusions.getModifiers())); + assertTrue(exclusions.isAccessible()); + } + + @Test + void openedDefineMethodDefinesExecutableBytesOnAnIndependentLoader() throws Exception { + byte[] bytes = executable(PREFIX + "Defined", 73); + try (LaunchClassLoader loader = new LaunchClassLoader(new URL[0])) { + Class defined = (Class) COMPILER.m_defineClass().invoke(loader, bytes, 0, bytes.length); + assertSame(loader, defined.getClassLoader()); + assertEquals(PREFIX.replace('/', '.') + "Defined", defined.getName()); + assertEquals(73, defined.getMethod("value").invoke(null)); + } + } + + @Test + void openedTransformerMethodUsesTheReceiverLoaderAndPreservesBytesWithNoTransformers() throws Exception { + byte[] bytes = executable(PREFIX + "Transformed", 29); + try (LaunchClassLoader loader = new LaunchClassLoader(new URL[0])) { + byte[] transformed = (byte[]) COMPILER.m_runTransformers().invoke( + loader, + PREFIX.replace('/', '.') + "Transformed", + PREFIX.replace('/', '.') + "Transformed", + bytes); + assertSame(bytes, transformed); + assertEquals(PREFIX + "Transformed", new ClassReader(transformed).getClassName()); + assertTrue(loader.getTransformers().isEmpty()); + } + } + + @Test + void openedTransformerExceptionFieldIsTheLiveSetUsedByTheCompilerLoader() throws Exception { + Field exclusions = COMPILER.f_transformerExceptions(); + @SuppressWarnings("unchecked") + Set value = (Set) exclusions.get(COMPILER.cl()); + Field direct = LaunchClassLoader.class.getDeclaredField("transformerExceptions"); + direct.setAccessible(true); + assertSame(direct.get(COMPILER.cl()), value); + String marker = PREFIX.replace('/', '.') + "excluded"; + boolean present = value.contains(marker); + try { + value.add(marker); + assertTrue(((Set) direct.get(COMPILER.cl())).contains(marker)); + } finally { + if (!present) value.remove(marker); + } + } + + @Test + void startupMapStorageUsesIndependentMutableHashMaps() throws Exception { + Map bytes = map("traitByteMap"); + Map mixins = map("mixinMap"); + Map info = map("infoCache"); + assertEquals("scala.collection.mutable.HashMap", bytes.getClass().getName()); + assertEquals(bytes.getClass(), mixins.getClass()); + assertEquals(bytes.getClass(), info.getClass()); + assertNotSame(bytes, mixins); + assertNotSame(bytes, info); + assertNotSame(mixins, info); + + java.util.Map oldBytes = new HashMap<>(JavaConversions.mapAsJavaMap(bytes)); + java.util.Map oldMixins = new HashMap<>(JavaConversions.mapAsJavaMap(mixins)); + java.util.Map oldInfo = new HashMap<>(JavaConversions.mapAsJavaMap(info)); + try { + String key = PREFIX + "independent"; + bytes.put(key, new byte[] { 1 }); + assertFalse(mixins.contains(key)); + assertFalse(info.contains(key)); + mixins.put(key, null); + assertFalse(info.contains(key)); + } finally { + bytes.clear(); + oldBytes.forEach(bytes::put); + mixins.clear(); + oldMixins.forEach(mixins::put); + info.clear(); + oldInfo.forEach(info::put); + } + } + + @Test + void sanityCheckerBytesAreAvailableThroughTheInitializedCompilerPath() throws Exception { + byte[] bytes = COMPILER.getBytes("cpw/mods/fml/common/asm/FMLSanityChecker"); + assertNotNull(bytes); + ClassReader reader = new ClassReader(bytes); + assertEquals("cpw/mods/fml/common/asm/FMLSanityChecker", reader.getClassName()); + assertEquals("java/lang/Object", reader.getSuperName()); + assertTrue(reader.getItemCount() > 1); + } + + private static byte[] executable(String name, int value) { + ClassWriter writer = new ClassWriter(0); + writer.visit(V1_6, ACC_PUBLIC, name, null, "java/lang/Object", null); + MethodVisitor method = writer.visitMethod(ACC_PUBLIC | ACC_STATIC, "value", "()I", null, null); + method.visitLdcInsn(value); + method.visitInsn(IRETURN); + method.visitMaxs(1, 0); + method.visitEnd(); + writer.visitEnd(); + return writer.toByteArray(); + } + + @SuppressWarnings("unchecked") + private static Map map(String name) throws Exception { + Field field = ASMMixinCompiler$.class.getDeclaredField(name); + field.setAccessible(true); + return (Map) field.get(COMPILER); + } +}