jdk/test/langtools/tools/javac/processing/filer/TestNoOverwriteJarFiles.java

/*
 * Copyright (c) 2025, 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 8338675
 * @summary javac shouldn't silently change .jar files on the classpath
 * @library /tools/lib /tools/javac/lib
 * @modules jdk.compiler/com.sun.tools.javac.api
 *          jdk.compiler/com.sun.tools.javac.main
 * @build toolbox.ToolBox toolbox.JarTask toolbox.JavacTask
 * @run junit TestNoOverwriteJarFiles
 */

import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.parallel.Execution;
import toolbox.JavacTask;
import toolbox.ToolBox;

import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.element.TypeElement;
import javax.tools.FileObject;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URI;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.FileTime;
import java.time.Instant;
import java.util.Set;
import java.util.jar.JarOutputStream;
import java.util.zip.ZipEntry;

import static javax.tools.StandardLocation.CLASS_OUTPUT;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.parallel.ExecutionMode.SAME_THREAD;

/**
 * Tests that javac cannot unexpectedly modify contents of JAR files on the
 * class path.
 * <p>
 * Consider the following javac behaviours:
 * <ol>
 * <li>If there is no source path, javac searches the classpath for sources,
 * including inside JAR files.
 * <li>If a Java source file was modified more recently that an existing class
 * file, or if no class file exists, javac will compile it from the source.
 * <li>If there is no output directory specified, javac will put compiled class
 * files next to their corresponding sources.
 * </ol>
 * Taken together, this suggests that a newly compiled class file should be
 * written back into the JAR in which its source was found, possibly overwriting
 * an existing class file entry. This would be very problematic.
 * <p>
 * This test ensures javac will not modify JAR files on the classpath, even if
 * it compiles sources contained within them. Instead, the class file will be
 * written into the current working directory, which mimics the JDK 8 behavior.
 *
 * <h2>Important</h2>
 *
 * This test creates files from Java compilation and annotation processing, and
 * relies on files being written to the current working directory. Since jtreg
 * currently offers no way to run each test case in its own directory, or clean
 * the test directory between test cases, we must be careful to:
 * <ul>
 *     <li>Use {@code @Execution(SAME_THREAD)} to run test cases sequentially.
 *     <li>Clean up the test directory ourselves between test cases (via
 *     {@code @BeforeEach}).
 * </ul>
 * The alternative approach would be to compile the test classes in a specified
 * working directory unique to each test case, but this is currently only
 * possible using a subprocess via {@code Task.Mode.EXEC} , and this has two
 * serious disadvantages:
 * <ul>
 *     <li>It significantly complicates compilation setup.
 *     <li>It prevents step-through debugging of the annotation processor.
 * </ul>
 */
@Execution(SAME_THREAD)
public class TestNoOverwriteJarFiles {
    private static final String LIB_SOURCE_FILE_NAME = "lib/LibClass.java";
    private static final String LIB_CLASS_FILE_NAME = "lib/LibClass.class";
    private static final String LIB_CLASS_TYPE_NAME = "lib.LibClass";

    private static final Path TEST_LIB_JAR = Path.of("lib.jar");
    private static final Path OUTPUT_CLASS_FILE = Path.of("LibClass.class");

    // Source which can only compile against the Java source in the test library.
    public static final String TARGET_SOURCE =
            """
            class TargetClass {
                static final String VALUE = lib.LibClass.NEW_FIELD;
            }
            """;

    // Not expensive to create, but conceptually a singleton.
    private static final ToolBox toolBox = new ToolBox();

    @BeforeAll
    public static void ensureEmptyTestDirectory() throws IOException {
        try (var files = Files.walk(Path.of("."), 1)) {
            // Always includes the given path as the first returned element, so skip it.
            if (files.skip(1).findFirst().isPresent()) {
                throw new IllegalStateException("Test working directory must be empty.");
            }
        }
    }

    @BeforeEach
    public void cleanUpTestDirectory() throws IOException {
        toolBox.cleanDirectory(Path.of("."));
    }

    @Test
    public void jarFileNotModifiedOrdinaryCompilation() throws IOException {
        byte[] originalJarBytes = compileTestLibJar();

        new JavacTask(toolBox)
                .sources(TARGET_SOURCE)
                .classpath(TEST_LIB_JAR)
                .run()
                .writeAll();

        // Assertion 1: The JAR is unchanged.
        assertArrayEquals(originalJarBytes, Files.readAllBytes(TEST_LIB_JAR), "Jar file was modified.");
        // Assertion 2: An output class file was written to the current directory.
        assertTrue(Files.exists(OUTPUT_CLASS_FILE), "Output class file missing.");
    }

    // As above, but the JAR is added to the source path instead (with same results).
    @Test
    public void jarFileNotModifiedForSourcePath() throws IOException {
        byte[] originalJarBytes = compileTestLibJar();

        new JavacTask(toolBox)
                .sources(TARGET_SOURCE)
                .sourcepath(TEST_LIB_JAR)
                .run()
                .writeAll();

        // Assertion 1: The JAR is unchanged.
        assertArrayEquals(originalJarBytes, Files.readAllBytes(TEST_LIB_JAR), "Jar file was modified.");
        // Assertion 2: An output class file was written to the current directory.
        assertTrue(Files.exists(OUTPUT_CLASS_FILE), "Output class file missing.");
    }

    @Test
    public void jarFileNotModifiedAnnotationProcessing() throws IOException {
        byte[] originalJarBytes = compileTestLibJar();

        new JavacTask(toolBox)
                .sources(TARGET_SOURCE)
                .classpath(TEST_LIB_JAR)
                .processors(new TestAnnotationProcessor())
                // Use "-implicit:none" to avoid writing the library class file.
                .options("-implicit:none", "-g:source,lines,vars")
                .run()
                .writeAll();

        // Assertion 1: The JAR is unchanged.
        assertArrayEquals(originalJarBytes, Files.readAllBytes(TEST_LIB_JAR), "Jar file was modified.");
        // Assertion 2: All expected output files were written to the current directory.
        assertDummyFile("DummySource.java");
        assertDummyFile("DummyClass.class");
        assertDummyFile("DummyResource.txt");
        // Assertion 3: The class file itself wasn't written (because we used "-implicit:none").
        assertFalse(Files.exists(OUTPUT_CLASS_FILE), "Unexpected class file in working directory.");
    }

    static class TestAnnotationProcessor extends JavacTestingAbstractProcessor {
        @Override
        public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment env) {
            // Only run this once (in the final pass), or else we get spurious failures about
            // trying to recreate file objects (not allowed during annotation processing).
            if (!env.processingOver()) {
                return false;
            }

            TypeElement libClass = elements.getTypeElement(LIB_CLASS_TYPE_NAME);
            try {
                // Note: A generated Java source file must be legal Java, but a generated class
                // file that's unreferenced will never be loaded, so can contain any bytes.
                writeFileObject(
                        filer.createSourceFile("DummySource", libClass),
                        "DummySource.java",
                        "class DummySource {}");
                writeFileObject(
                        filer.createClassFile("DummyClass", libClass),
                        "DummyClass.class",
                        "<<DummyClass Bytes>>");
                writeFileObject(
                        filer.createResource(CLASS_OUTPUT, "", "DummyResource.txt", libClass),
                        "DummyResource.txt",
                        "Dummy Resource Bytes");
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            return false;
        }
    }

    static void writeFileObject(FileObject file, String expectedName, String contents)
            throws IOException {
        URI fileUri = file.toUri();
        // Check that the file URI doesn't look like it is associated with a JAR.
        assertTrue(fileUri.getSchemeSpecificPart().endsWith("/" + expectedName));
        // The JAR file system would have a scheme of "jar", not "file".
        assertEquals("file", fileUri.getScheme());
        // Testing a negative is fragile, but a JAR URI would be expected to contain "jar!".
        assertFalse(fileUri.getSchemeSpecificPart().contains("jar!"));
        // Write dummy data (which should end up in the test working directory).
        try (OutputStream os = file.openOutputStream()) {
            os.write(contents.getBytes());
        }
    }

    static void assertDummyFile(String filename) throws IOException {
        Path path = Path.of(filename);
        assertTrue(Files.exists(path), "Output file missing: " + filename);
        assertTrue(Files.readString(path).contains("Dummy"), "Unexpected file contents: " + filename);
    }

    // Compiles and writes the test library JAR (LIB_JAR) into the current directory.
    static byte[] compileTestLibJar() throws IOException {
        Path libDir = Path.of("lib");
        toolBox.createDirectories(libDir);
        try {
            toolBox.writeFile(LIB_SOURCE_FILE_NAME,
                    """
                    package lib;
                    public class LibClass {
                        public static final String OLD_FIELD = "This will not compile with Target";
                    }
                    """);

            // Compile the old (broken) source and then store the class file in the JAR.
            // The class file is generated in the lib/ directory, which we delete after
            // making the JAR. This ensures that when compiling the target class, it's
            // the source file being read from the JAR,
            new JavacTask(toolBox)
                    .files(LIB_SOURCE_FILE_NAME)
                    .run()
                    .writeAll();

            // If timestamps are equal JAR file resolution of classes is ambiguous
            // (currently "last one wins"), so give the source we want to be used a
            // newer timestamp.
            Instant now = Instant.now();
            try (OutputStream jos = Files.newOutputStream(Path.of("lib.jar"))) {
                JarOutputStream jar = new JarOutputStream(jos);
                writeEntry(jar,
                        LIB_SOURCE_FILE_NAME,
                        """
                        package lib;
                        public class LibClass {
                            public static final String NEW_FIELD = "This will compile with Target";
                        }
                        """.getBytes(StandardCharsets.UTF_8),
                        now.plusSeconds(1));
                writeEntry(jar,
                        LIB_CLASS_FILE_NAME,
                        Files.readAllBytes(Path.of(LIB_CLASS_FILE_NAME)),
                        now);
                jar.close();
            }
            // Return the JAR file bytes for comparison later.
            return Files.readAllBytes(TEST_LIB_JAR);
        } finally {
            toolBox.cleanDirectory(libDir);
            toolBox.deleteFiles(libDir);
        }
    }

    // Note: JarOutputStream only writes modification time, not creation time, but
    // that's what Javac uses to determine "newness" so it's fine.
    private static void writeEntry(JarOutputStream jar, String name, byte[] bytes, Instant timestamp)
            throws IOException {
        ZipEntry e = new ZipEntry(name);
        e.setLastModifiedTime(FileTime.from(timestamp));
        jar.putNextEntry(e);
        jar.write(bytes);
        jar.closeEntry();
    }
}