From 49b17dd5c97bf967c01166542cfccf4b196cf8a9 Mon Sep 17 00:00:00 2001
From: Alexey Semenyuk <asemenyuk@openjdk.org>
Date: Fri, 17 Oct 2025 22:58:26 +0000
Subject: [PATCH] 8356575: Test order in which jpackage fills app image

Reviewed-by: almatvee
---
 .../internal/ApplicationImageUtils.java       |   4 +-
 .../jpackage/test/LauncherIconVerifier.java   |   3 +-
 .../helpers/jdk/jpackage/test/TKit.java       |  30 ++
 .../jpackage/share/AppImageFillOrderTest.java | 359 ++++++++++++++++++
 4 files changed, 393 insertions(+), 3 deletions(-)
 create mode 100644 test/jdk/tools/jpackage/share/AppImageFillOrderTest.java

diff --git a/src/jdk.jpackage/share/classes/jdk/jpackage/internal/ApplicationImageUtils.java b/src/jdk.jpackage/share/classes/jdk/jpackage/internal/ApplicationImageUtils.java
index 7d3250ff7b9..cda5b6c79ef 100644
--- a/src/jdk.jpackage/share/classes/jdk/jpackage/internal/ApplicationImageUtils.java
+++ b/src/jdk.jpackage/share/classes/jdk/jpackage/internal/ApplicationImageUtils.java
@@ -32,6 +32,7 @@ import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.LinkOption;
 import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
@@ -148,6 +149,7 @@ final class ApplicationImageUtils {
             }
         }
 
-        FileUtils.copyRecursive(srcDir, dstDir.toAbsolutePath(), excludes, LinkOption.NOFOLLOW_LINKS);
+        FileUtils.copyRecursive(srcDir, dstDir.toAbsolutePath(), excludes,
+                LinkOption.NOFOLLOW_LINKS, StandardCopyOption.REPLACE_EXISTING);
     }
 }
diff --git a/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/LauncherIconVerifier.java b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/LauncherIconVerifier.java
index 6285d9d93a0..278cd569bac 100644
--- a/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/LauncherIconVerifier.java
+++ b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/LauncherIconVerifier.java
@@ -24,7 +24,6 @@
 package jdk.jpackage.test;
 
 import java.io.IOException;
-import java.nio.file.Files;
 import java.nio.file.Path;
 
 public final class LauncherIconVerifier {
@@ -77,7 +76,7 @@ public final class LauncherIconVerifier {
         } else {
             TKit.assertFileExists(iconPath);
             if (!verifyFileInAppImageOnly) {
-                TKit.assertTrue(-1 == Files.mismatch(expectedIcon, iconPath),
+                TKit.assertSameFileContent(expectedIcon, iconPath,
                         String.format(
                         "Check icon file [%s] of %s launcher is a copy of source icon file [%s]",
                         iconPath, label, expectedIcon));
diff --git a/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/TKit.java b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/TKit.java
index b3f188bb371..ed9c727abcc 100644
--- a/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/TKit.java
+++ b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/TKit.java
@@ -25,6 +25,7 @@ package jdk.jpackage.test;
 import static java.nio.file.StandardWatchEventKinds.ENTRY_CREATE;
 import static java.nio.file.StandardWatchEventKinds.ENTRY_MODIFY;
 import static java.util.stream.Collectors.toSet;
+import static jdk.jpackage.internal.util.function.ThrowingBiFunction.toBiFunction;
 import static jdk.jpackage.internal.util.function.ThrowingSupplier.toSupplier;
 
 import java.io.Closeable;
@@ -797,6 +798,35 @@ public final class TKit {
         }
     }
 
+    public static void assertMismatchFileContent(Path a, Path b) {
+        assertFilesMismatch(a, b, true, Optional.empty());
+    }
+
+    public static void assertMismatchFileContent(Path a, Path b, String msg) {
+        assertFilesMismatch(a, b, true, Optional.of(msg));
+    }
+
+    public static void assertSameFileContent(Path a, Path b) {
+        assertFilesMismatch(a, b, false, Optional.empty());
+    }
+
+    public static void assertSameFileContent(Path a, Path b, String msg) {
+        assertFilesMismatch(a, b, false, Optional.of(msg));
+    }
+
+    public static void assertFilesMismatch(Path a, Path b, boolean expectMismatch, Optional<String> msg) {
+        var mismatch = toBiFunction(Files::mismatch).apply(a, b) != -1;
+        if (expectMismatch) {
+            assertTrue(mismatch, msg.orElseGet(() -> {
+                return String.format("Check the content of [%s] and [%s] files mismatch", a, b);
+            }));
+        } else {
+            assertTrue(!mismatch, msg.orElseGet(() -> {
+                return String.format("Check the content of [%s] and [%s] files is the same", a, b);
+            }));
+        }
+    }
+
     public static void assertDirectoryNotEmpty(Path path) {
         assertDirectoryExists(path, Optional.of(false));
     }
diff --git a/test/jdk/tools/jpackage/share/AppImageFillOrderTest.java b/test/jdk/tools/jpackage/share/AppImageFillOrderTest.java
new file mode 100644
index 00000000000..75c0ddfc16f
--- /dev/null
+++ b/test/jdk/tools/jpackage/share/AppImageFillOrderTest.java
@@ -0,0 +1,359 @@
+/*
+ * 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.
+ */
+
+import static java.util.stream.Collectors.toMap;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.TreeMap;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.stream.Stream;
+import jdk.jpackage.test.Annotations.Parameter;
+import jdk.jpackage.test.Annotations.ParameterSupplier;
+import jdk.jpackage.test.Annotations.Test;
+import jdk.jpackage.test.AppImageFile;
+import jdk.jpackage.test.ApplicationLayout;
+import jdk.jpackage.test.JPackageCommand;
+import jdk.jpackage.test.TKit;
+
+/*
+ * @test
+ * @summary test order in which jpackage fills app image
+ * @library /test/jdk/tools/jpackage/helpers
+ * @build jdk.jpackage.test.*
+ * @compile -Xlint:all -Werror AppImageFillOrderTest.java
+ * @run main/othervm/timeout=1440 -Xmx512m
+ *  jdk.jpackage.test.Main
+ *  --jpt-run=AppImageFillOrderTest
+ */
+
+/**
+ * Test order in which overlapping items are added to the app image. jpackage
+ * defaults should go first to let user-provided content override them.
+ *
+ * <p>
+ * Custom content comes from:
+ * <ul>
+ * <li>input directory (--input)
+ * <li>app content (--app-content)
+ * <ul>
+ */
+public class AppImageFillOrderTest {
+
+    @Test
+    @ParameterSupplier
+    public void test(AppImageOverlay overlays[]) {
+        test(createJPackage().setFakeRuntime(), overlays);
+    }
+
+    /**
+     * Test they can override a file in the runtime.
+     * @param jlink
+     */
+    @Test
+    @Parameter("true")
+    @Parameter("false")
+    public void testRuntime(boolean jlink) {
+        var cmd = createJPackage();
+        if (jlink) {
+            cmd.ignoreDefaultRuntime(true);
+        } else {
+            // Configure fake runtime and create it.
+            cmd.setFakeRuntime().executePrerequisiteActions();
+
+            var runtimeDir = Path.of(cmd.getArgumentValue("--runtime-image"));
+            if (!runtimeDir.toAbsolutePath().normalize().startsWith(TKit.workDir().toAbsolutePath().normalize())) {
+                throw new IllegalStateException(String.format(
+                        "Fake runtime [%s] created outside of the test work directory [%s]",
+                        runtimeDir, TKit.workDir()));
+            }
+
+            TKit.createTextFile(runtimeDir.resolve(RUNTIME_RELEASE_FILE), List.of("Foo release"));
+        }
+
+        test(cmd, AppImageAppContentOverlay.APP_CONTENT_RUNTIME_RELEASE_FILE);
+    }
+
+    /**
+     * Test they can not override .jpackage.xml file.
+     * @throws IOException
+     */
+    @Test
+    public void testAppImageFile() throws IOException {
+
+        var cmd = createJPackage().setFakeRuntime();
+
+        var outputBundle = cmd.outputBundle();
+
+        buildOverlay(cmd, TKit.createTempDirectory("app-content"), AppImageFile.getPathInAppImage(outputBundle))
+                .textContent("This is not a valid XML content")
+                .configureCmdOptions().createOverlayFile();
+
+        // Run jpackage and verify it created valid .jpackage.xml file ignoring the overlay.
+        cmd.executeAndAssertImageCreated();
+
+        TKit.trace(String.format("Parse [%s] file...", AppImageFile.getPathInAppImage(outputBundle)));
+        AppImageFile.load(outputBundle);
+    }
+
+    private static void test(JPackageCommand cmd, AppImageOverlay... overlays) {
+        if (overlays.length == 0) {
+            throw new IllegalArgumentException();
+        }
+
+        final var outputDir = Path.of(cmd.getArgumentValue("--dest"));
+        final var noOverlaysOutputDir = Path.of(outputDir.toString() + "-no-overlay");
+        cmd.setArgumentValue("--dest", noOverlaysOutputDir);
+
+        // Run the command without overlays with redirected output directory.
+        cmd.execute();
+
+        final Optional<Path> appContentRoot;
+        if (Stream.of(overlays).anyMatch(AppImageAppContentOverlay.class::isInstance)) {
+            appContentRoot = Optional.of(TKit.createTempDirectory("app-content"));
+        } else {
+            appContentRoot = Optional.empty();
+        }
+
+        // Apply overlays to the command.
+        var fileCopies = Stream.of(overlays).map(overlay -> {
+            switch (overlay) {
+                case AppImageDefaultOverlay v -> {
+                    return v.addOverlay(cmd);
+                }
+                case AppImageAppContentOverlay v -> {
+                    return v.addOverlay(cmd, appContentRoot.orElseThrow());
+                }
+            }
+        }).flatMap(Collection::stream).collect(toMap(FileCopy::out, x -> x, (a, b) -> {
+            return b;
+        }, TreeMap::new)).values().stream().toList();
+
+        // Collect paths in the app image that will be affected by overlays.
+        var noOverlayOutputPaths = fileCopies.stream().map(FileCopy::out).toList();
+
+        fileCopies = fileCopies.stream().map(v -> {
+            return new FileCopy(v.in(), outputDir.resolve(noOverlaysOutputDir.relativize(v.out())));
+        }).toList();
+
+        // Restore the original output directory for the command and execute it.
+        cmd.setArgumentValue("--dest", outputDir).execute();
+
+        for (var i = 0; i != fileCopies.size(); i++) {
+            var noOverlayPath = noOverlayOutputPaths.get(i);
+            var fc = fileCopies.get(i);
+            TKit.assertSameFileContent(fc.in(), fc.out());
+            TKit.assertMismatchFileContent(noOverlayPath, fc.out());
+        }
+    }
+
+    public static Collection<Object[]> test() {
+        return Stream.of(
+
+                // Overwrite main launcher .cfg file from the input dir.
+                List.of(AppImageDefaultOverlay.INPUT_MAIN_LAUNCHER_CFG),
+
+                // Overwrite main launcher .cfg file from the app content dir.
+                List.of(AppImageAppContentOverlay.APP_CONTENT_MAIN_LAUNCHER_CFG),
+
+                // Overwrite main launcher .cfg file from the input dir and from the app content dir.
+                // The one from app content should win.
+                List.<AppImageOverlay>of(
+                        AppImageDefaultOverlay.INPUT_MAIN_LAUNCHER_CFG,
+                        AppImageAppContentOverlay.APP_CONTENT_MAIN_LAUNCHER_CFG
+                ),
+
+                // Overwrite main jar from the app content dir.
+                List.of(AppImageAppContentOverlay.APP_CONTENT_MAIN_JAR)
+        ).map(args -> {
+            return args.toArray(AppImageOverlay[]::new);
+        }).map(args -> {
+            return new Object[] {args};
+        }).toList();
+    }
+
+
+    public sealed interface AppImageOverlay {
+    }
+
+
+    private enum AppImageDefaultOverlay implements AppImageOverlay {
+        INPUT_MAIN_LAUNCHER_CFG(AppImageFillOrderTest::replaceMainLauncherCfgFile),
+        ;
+
+        AppImageDefaultOverlay(Function<JPackageCommand, FileCopy> func) {
+            Objects.requireNonNull(func);
+            this.func = cmd -> {
+                return List.of(func.apply(cmd));
+            };
+        }
+
+        Collection<FileCopy> addOverlay(JPackageCommand cmd) {
+            return func.apply(cmd);
+        }
+
+        private final Function<JPackageCommand, Collection<FileCopy>> func;
+    }
+
+
+    private enum AppImageAppContentOverlay implements AppImageOverlay {
+        // Replace the standard main launcher .cfg file with the custom one from the app content.
+        APP_CONTENT_MAIN_LAUNCHER_CFG((cmd, appContentRoot) -> {
+            return buildOverlay(cmd, appContentRoot, cmd.appLauncherCfgPath(null))
+                    .textContent("!Olleh")
+                    .configureCmdOptions().createOverlayFile();
+        }),
+
+        // Replace the jar file that jpackage will pick up from the input directory with the custom one.
+        APP_CONTENT_MAIN_JAR((cmd, appContentRoot) -> {
+            return buildOverlay(cmd, appContentRoot, cmd.appLayout().appDirectory().resolve(cmd.getArgumentValue("--main-jar")))
+                    .textContent("Surprise!")
+                    .configureCmdOptions().createOverlayFile();
+        }),
+
+        // Replace "release" file in the runtime directory.
+        APP_CONTENT_RUNTIME_RELEASE_FILE((cmd, appContentRoot) -> {
+            return buildOverlay(cmd, appContentRoot, cmd.appLayout().runtimeHomeDirectory().resolve("release"))
+                    .textContent("blob")
+                    .configureCmdOptions().createOverlayFile();
+        }),
+        ;
+
+        AppImageAppContentOverlay(BiFunction<JPackageCommand, Path, FileCopy> func) {
+            Objects.requireNonNull(func);
+            this.func = (cmd, appContentRoot) -> {
+                return List.of(func.apply(cmd, appContentRoot));
+            };
+        }
+
+        Collection<FileCopy> addOverlay(JPackageCommand cmd, Path appContentRoot) {
+            return func.apply(cmd, appContentRoot);
+        }
+
+        private final BiFunction<JPackageCommand, Path, Collection<FileCopy>> func;
+    }
+
+
+    private record FileCopy(Path in, Path out) {
+        FileCopy {
+            Objects.requireNonNull(in);
+            Objects.requireNonNull(out);
+        }
+    }
+
+
+    private static FileCopy replaceMainLauncherCfgFile(JPackageCommand cmd) {
+        // Replace the standard main launcher .cfg file with the custom one from the input dir.
+        final var outputFile = cmd.appLauncherCfgPath(null);
+
+        final var inputDir = Path.of(cmd.getArgumentValue("--input"));
+
+        final var file = inputDir.resolve(outputFile.getFileName());
+
+        TKit.createTextFile(file, List.of("Hello!"));
+
+        return new FileCopy(file, outputFile);
+    }
+
+    private static AppContentOverlayFileBuilder buildOverlay(JPackageCommand cmd, Path appContentRoot, Path outputFile) {
+        return new AppContentOverlayFileBuilder(cmd, appContentRoot, outputFile);
+    }
+
+
+    private static final class AppContentOverlayFileBuilder {
+
+        AppContentOverlayFileBuilder(JPackageCommand cmd, Path appContentRoot, Path outputFile) {
+            if (outputFile.isAbsolute()) {
+                throw new IllegalArgumentException();
+            }
+
+            if (!outputFile.startsWith(cmd.outputBundle())) {
+                throw new IllegalArgumentException();
+            }
+
+            this.cmd = Objects.requireNonNull(cmd);
+            this.outputFile = Objects.requireNonNull(outputFile);
+            this.appContentRoot = Objects.requireNonNull(appContentRoot);
+        }
+
+        FileCopy createOverlayFile() {
+            final var file = appContentRoot.resolve(pathInAppContentDirectory());
+
+            try {
+                Files.createDirectories(file.getParent());
+            } catch (IOException ex) {
+                throw new UncheckedIOException(ex);
+            }
+            fileContentInitializer.accept(file);
+
+            return new FileCopy(file, outputFile);
+        }
+
+        AppContentOverlayFileBuilder configureCmdOptions() {
+            cmd.addArguments("--app-content", appContentRoot.resolve(pathInAppContentDirectory().getName(0)));
+            return this;
+        }
+
+        AppContentOverlayFileBuilder content(Consumer<Path> v) {
+            fileContentInitializer = v;
+            return this;
+        }
+
+        AppContentOverlayFileBuilder textContent(String... lines) {
+            return content(path -> {
+                TKit.createTextFile(path, List.of(lines));
+            });
+        }
+
+        private Path pathInAppContentDirectory() {
+            return APP_IMAGE_LAYOUT.resolveAt(cmd.outputBundle()).contentDirectory().relativize(outputFile);
+        }
+
+        private Consumer<Path> fileContentInitializer;
+        private final JPackageCommand cmd;
+        private final Path outputFile;
+        private final Path appContentRoot;
+    }
+
+
+    private static JPackageCommand createJPackage() {
+        // With short name.
+        var cmd = JPackageCommand.helloAppImage().setArgumentValue("--name", "Foo");
+
+        // Clean leftovers in the input dir from the previous test run if any.
+        TKit.deleteDirectoryContentsRecursive(cmd.inputDir());
+
+        return cmd;
+    }
+
+    private static final ApplicationLayout APP_IMAGE_LAYOUT = ApplicationLayout.platformAppImage();
+    private static final Path RUNTIME_RELEASE_FILE = Path.of("release");
+}