CachedCompilerAdditionalTest.java

/*
 * Copyright 2013-2025 chronicle.software; SPDX-License-Identifier: Apache-2.0
 */
package net.openhft.compiler;

import org.junit.jupiter.api.Test;

import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;

import static org.junit.jupiter.api.Assertions.*;

class CachedCompilerAdditionalTest {

    @Test
    void compileFromJavaReturnsBytecode() throws Exception {
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        assertNotNull(compiler, "System compiler required");

        try (StandardJavaFileManager standardManager = compiler.getStandardFileManager(null, null, null)) {
            CachedCompiler cachedCompiler = new CachedCompiler(null, null);
            MyJavaFileManager fileManager = new MyJavaFileManager(standardManager);
            Map<String, byte[]> classes = cachedCompiler.compileFromJava(
                    "coverage.Sample",
                    "package coverage; public class Sample { public int value() { return 42; } }",
                    fileManager);
            byte[] bytes = classes.get("coverage.Sample");
            assertNotNull(bytes);
            assertTrue(bytes.length > 0);
        }
    }

    @Test
    void compileFromJavaReturnsEmptyMapOnFailure() throws Exception {
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        assertNotNull(compiler, "System compiler required");
        try (StandardJavaFileManager standardManager = compiler.getStandardFileManager(null, null, null)) {
            CachedCompiler cachedCompiler = new CachedCompiler(null, null);
            MyJavaFileManager fileManager = new MyJavaFileManager(standardManager);
            Map<String, byte[]> classes = cachedCompiler.compileFromJava(
                    "coverage.Broken",
                    "package coverage; public class Broken { this does not compile }",
                    fileManager);
            assertTrue(classes.isEmpty(), "Broken source should not produce classes");
        }
    }

    @Test
    void updateFileManagerForClassLoaderInvokesConsumer() throws Exception {
        CachedCompiler compiler = new CachedCompiler(null, null);
        ClassLoader loader = new ClassLoader() {
        };
        compiler.loadFromJava(loader, "coverage.UpdateTarget", "package coverage; public class UpdateTarget {}");

        AtomicBoolean invoked = new AtomicBoolean(false);
        compiler.updateFileManagerForClassLoader(loader, fm -> invoked.set(true));
        assertTrue(invoked.get(), "Consumer should be invoked when manager exists");
    }

    @Test
    void updateFileManagerNoOpWhenClassLoaderUnknown() {
        CachedCompiler compiler = new CachedCompiler(null, null);
        AtomicBoolean invoked = new AtomicBoolean(false);
        compiler.updateFileManagerForClassLoader(new ClassLoader() {
        }, fm -> invoked.set(true));
        assertTrue(!invoked.get(), "Consumer should not be invoked when manager missing");
    }

    @Test
    void closeClosesAllManagedFileManagers() throws Exception {
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        assertNotNull(compiler, "System compiler required");
        CachedCompiler cachedCompiler = new CachedCompiler(null, null);
        AtomicBoolean closed = new AtomicBoolean(false);
        cachedCompiler.setFileManagerOverride(standard -> new TrackingFileManager(standard, closed));

        ClassLoader loader = new ClassLoader() {
        };
        cachedCompiler.loadFromJava(loader, "coverage.CloseTarget", "package coverage; public class CloseTarget {}");
        cachedCompiler.close();
        assertTrue(closed.get(), "Close should propagate to file managers");
    }

    @Test
    void createDefaultWriterFlushesOnClose() throws Exception {
        Method factory = CachedCompiler.class.getDeclaredMethod("createDefaultWriter");
        factory.setAccessible(true);
        PrintWriter writer = (PrintWriter) factory.invoke(null);
        writer.println("exercise-default-writer");
        writer.close(); // ensures the overridden close() path is covered
    }

    @Test
    void validateClassNameAllowsDescriptorForms() throws Exception {
        Method validate = CachedCompiler.class.getDeclaredMethod("validateClassName", String.class);
        validate.setAccessible(true);

        validate.invoke(null, "module-info");
        validate.invoke(null, "example.package-info");
        validate.invoke(null, "example.deep.package-info");

        InvocationTargetException trailingHyphen = assertThrows(InvocationTargetException.class,
                () -> validate.invoke(null, "example.Invalid-"));
        assertTrue(trailingHyphen.getCause() instanceof IllegalArgumentException);

        InvocationTargetException emptySegment = assertThrows(InvocationTargetException.class,
                () -> validate.invoke(null, "example..impl"));
        assertTrue(emptySegment.getCause() instanceof IllegalArgumentException);

        InvocationTargetException invalidCharacter = assertThrows(InvocationTargetException.class,
                () -> validate.invoke(null, "example.Invalid?Name"));
        assertTrue(invalidCharacter.getCause() instanceof IllegalArgumentException);
    }

    @Test
    void safeResolvePreventsPathTraversal() throws Exception {
        Method method = CachedCompiler.class.getDeclaredMethod("safeResolve", File.class, String.class);
        method.setAccessible(true);
        Path root = Files.createTempDirectory("cached-compiler-safe");
        try {
            File resolved = (File) method.invoke(null, root.toFile(), "valid/Name.class");
            assertTrue(resolved.toPath().startsWith(root));

            InvocationTargetException traversal = assertThrows(InvocationTargetException.class,
                    () -> method.invoke(null, root.toFile(), "../escape"));
            assertTrue(traversal.getCause() instanceof IllegalArgumentException);
        } finally {
            deleteRecursively(root);
        }
    }

    @Test
    void writesSourceAndClassFilesWhenDirectoriesProvided() throws Exception {
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        assertNotNull(compiler, "System compiler required");

        Path sourceDir = Files.createTempDirectory("cached-compiler-src");
        Path classDir = Files.createTempDirectory("cached-compiler-classes");
        try {
            CachedCompiler firstPass = new CachedCompiler(sourceDir.toFile(), classDir.toFile());

            String className = "coverage.FileOutput";
            String versionOne = "package coverage; public class FileOutput { public String value() { return \"v1\"; } }";
            ClassLoader loaderOne = new ClassLoader() {
            };
            firstPass.loadFromJava(loaderOne, className, versionOne);
            firstPass.close();

            Path sourceFile = sourceDir.resolve("coverage/FileOutput.java");
            Path classFile = classDir.resolve("coverage/FileOutput.class");
            assertTrue(Files.exists(sourceFile), "Source file should be emitted");
            assertTrue(Files.exists(classFile), "Class file should be emitted");
            byte[] firstBytes = Files.readAllBytes(classFile);

            CachedCompiler secondPass = new CachedCompiler(sourceDir.toFile(), classDir.toFile());
            String versionTwo = "package coverage; public class FileOutput { public String value() { return \"v2\"; } }";
            ClassLoader loaderTwo = new ClassLoader() {
            };
            secondPass.loadFromJava(loaderTwo, className, versionTwo);
            secondPass.close();

            byte[] updatedBytes = Files.readAllBytes(classFile);
            assertTrue(!Arrays.equals(firstBytes, updatedBytes), "Updating the source should change emitted bytecode");

            Path backupFile = classDir.resolve("coverage/FileOutput.class.bak");
            assertTrue(!Files.exists(backupFile), "Backup should be cleaned up");
        } finally {
            deleteRecursively(classDir);
            deleteRecursively(sourceDir);
        }
    }

    private static void deleteRecursively(Path root) throws IOException {
        if (root == null || Files.notExists(root)) {
            return;
        }
        Files.walk(root)
                .sorted(Comparator.reverseOrder())
                .map(Path::toFile)
                .forEach(File::delete);
    }

    private static final class TrackingFileManager extends MyJavaFileManager {
        private final AtomicBoolean closedFlag;

        TrackingFileManager(StandardJavaFileManager delegate, AtomicBoolean closedFlag) {
            super(delegate);
            this.closedFlag = closedFlag;
        }

        @Override
        public void close() throws IOException {
            closedFlag.set(true);
            super.close();
        }
    }
}