8350601: Miscellaneous updates to jpackage test lib

Reviewed-by: almatvee

Author: Alexey Semenyuk

test/jdk/tools/jpackage/helpers-test/jdk/jpackage/test/TKitTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2024, 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
@@ -26,19 +26,24 @@
 import static jdk.jpackage.internal.util.function.ThrowingSupplier.toSupplier;
 
 import java.lang.reflect.Method;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
+import java.util.Optional;
+import java.util.function.Consumer;
 import java.util.stream.Stream;
+import jdk.jpackage.internal.util.function.ThrowingFunction;
 import jdk.jpackage.internal.util.function.ThrowingRunnable;
 import jdk.jpackage.test.Annotations.ParameterSupplier;
 import jdk.jpackage.test.Annotations.Test;
 
 public class TKitTest extends JUnitAdapter {
 
-    public static Collection<Object[]> assertTestsData() {
+    public static Collection<Object[]> test() {
         List<MethodCallConfig> data = new ArrayList<>();
 
         var assertFunc = MethodCallConfig.build("assertTrue", boolean.class, String.class);
@@ -57,6 +62,12 @@ public static Collection<Object[]> assertTestsData() {
         data.addAll(List.of(assertFunc.args(7, 7).pass().expectLog("assertEquals(7)").createForMessage("Owl")));
         data.addAll(List.of(assertFunc.args(7, 10).fail().expectLog("Expected [7]. Actual [10]").createForMessage("Owl")));
 
+        assertFunc = MethodCallConfig.build("assertEquals", boolean.class, boolean.class, String.class);
+        data.addAll(List.of(assertFunc.args(true, true).pass().expectLog("assertEquals(true)").createForMessage("Emu")));
+        data.addAll(List.of(assertFunc.args(false, false).pass().expectLog("assertEquals(false)").createForMessage("Emu")));
+        data.addAll(List.of(assertFunc.args(true, false).fail().expectLog("Expected [true]. Actual [false]").createForMessage("Emu")));
+        data.addAll(List.of(assertFunc.args(false, true).fail().expectLog("Expected [false]. Actual [true]").createForMessage("Emu")));
+
         assertFunc = MethodCallConfig.build("assertNotEquals", String.class, String.class, String.class);
         data.addAll(List.of(assertFunc.args("a", "b").pass().expectLog("assertNotEquals(a, b)").createForMessage("Tit")));
         data.addAll(List.of(assertFunc.args("a", "a").fail().expectLog("Unexpected [a] value").createForMessage("Tit")));
@@ -65,6 +76,12 @@ public static Collection<Object[]> assertTestsData() {
         data.addAll(List.of(assertFunc.args(7, 10).pass().expectLog("assertNotEquals(7, 10)").createForMessage("Duck")));
         data.addAll(List.of(assertFunc.args(7, 7).fail().expectLog("Unexpected [7] value").createForMessage("Duck")));
 
+        assertFunc = MethodCallConfig.build("assertNotEquals", boolean.class, boolean.class, String.class);
+        data.addAll(List.of(assertFunc.args(true, false).pass().expectLog("assertNotEquals(true, false)").createForMessage("Sparrow")));
+        data.addAll(List.of(assertFunc.args(false, true).pass().expectLog("assertNotEquals(false, true)").createForMessage("Sparrow")));
+        data.addAll(List.of(assertFunc.args(true, true).fail().expectLog("Unexpected [true] value").createForMessage("Sparrow")));
+        data.addAll(List.of(assertFunc.args(false, false).fail().expectLog("Unexpected [false] value").createForMessage("Sparrow")));
+
         assertFunc = MethodCallConfig.build("assertNull", Object.class, String.class);
         data.addAll(List.of(assertFunc.args((Object) null).pass().expectLog("assertNull()").createForMessage("Ibis")));
         data.addAll(List.of(assertFunc.args("v").fail().expectLog("Unexpected not null value [v]").createForMessage("Ibis")));
@@ -186,13 +203,136 @@ Builder withAutoExpectLogPrefix(boolean v) {
     }
 
     @Test
-    @ParameterSupplier("assertTestsData")
+    @ParameterSupplier
     public void test(MethodCallConfig methodCall) {
         runAssertWithExpectedLogOutput(() -> {
             methodCall.method.invoke(null, methodCall.args);
         }, methodCall.expectFail, methodCall.expectLog);
     }
 
+    @Test
+    @ParameterSupplier("testCreateTempPath")
+    public void testCreateTempFile(CreateTempTestSpec testSpec) throws Throwable {
+        testSpec.test(TKit::createTempFile, TKit::assertFileExists);
+    }
+
+    @Test
+    @ParameterSupplier("testCreateTempPath")
+    public void testCreateTempDirectory(CreateTempTestSpec testSpec) throws Throwable {
+        testSpec.test(TKit::createTempDirectory, TKit::assertDirectoryEmpty);
+    }
+
+    record CreateTempTestSpec(String role, Path expectedPath, List<Path> existingFiles,
+            Class<? extends Exception> expectedExceptionClass) {
+
+        CreateTempTestSpec {
+            Objects.requireNonNull(existingFiles);
+            if ((expectedExceptionClass == null) == (expectedPath == null)) {
+                throw new IllegalArgumentException("Only one of `expectedPath` and `expectedExceptionClass` should be set");
+            }
+        }
+
+        void test(ThrowingFunction<String, Path> createTempPath, Consumer<Path> assertTempPathExists) throws Throwable {
+            for (var existingFile : existingFiles) {
+                existingFile = TKit.workDir().resolve(existingFile);
+
+                Files.createDirectories(existingFile.getParent());
+                Files.createFile(existingFile);
+            }
+
+            if (expectedExceptionClass != null) {
+                try {
+                    createTempPath.apply(role);
+                    TKit.assertUnexpected("Exception expected");
+                } catch (Exception ex) {
+                    TKit.assertTrue(expectedExceptionClass.isInstance(ex),
+                            String.format("Check exception [%s] is instance of %s", ex, expectedExceptionClass));
+                }
+            } else {
+                final var tempPath = createTempPath.apply(role);
+
+                assertTempPathExists.accept(tempPath);
+                TKit.assertTrue(tempPath.startsWith(TKit.workDir()), "Check temp path created in the work directory");
+
+                final var relativeTempPath = TKit.workDir().relativize(tempPath);
+                TKit.assertTrue(expectedPath.equals(relativeTempPath),
+                        String.format("Check [%s]=[%s]", expectedPath, relativeTempPath));
+            }
+        }
+
+        @Override
+        public String toString() {
+            final var sb = new StringBuilder();
+            sb.append("role=").append(role);
+            if (expectedPath != null) {
+                sb.append("; expected=").append(expectedPath);
+            }
+            if (!existingFiles.isEmpty()) {
+                sb.append("; exits=").append(existingFiles);
+            }
+            if (expectedExceptionClass != null) {
+                sb.append("; exception=").append(expectedExceptionClass);
+            }
+            return sb.toString();
+        }
+
+        static Builder role(String role) {
+            return new Builder(role);
+        }
+
+        final static class Builder {
+
+            private Builder(String role) {
+                this.role = role;
+            }
+
+            CreateTempTestSpec create() {
+                return new CreateTempTestSpec(role, expectedPath, existingFiles, expectedExceptionClass);
+            }
+
+            Builder expectedPath(String v) {
+                expectedPath = Optional.of(v).map(Path::of).orElse(null);
+                return this;
+            }
+
+            Builder existingFiles(String ...v) {
+                existingFiles.addAll(Stream.of(v).map(Path::of).toList());
+                return this;
+            }
+
+            Builder expectedExceptionClass(Class<? extends Exception> v) {
+                expectedExceptionClass = v;
+                return this;
+            }
+
+            private final String role;
+            private Path expectedPath;
+            private final List<Path> existingFiles = new ArrayList<>();
+            private Class<? extends Exception> expectedExceptionClass;
+        }
+    }
+
+    public static Collection<Object[]> testCreateTempPath() {
+        return Stream.of(
+                CreateTempTestSpec.role("foo").expectedPath("foo"),
+                CreateTempTestSpec.role("foo.b").expectedPath("foo.b"),
+                CreateTempTestSpec.role("foo").expectedPath("foo-0").existingFiles("foo"),
+                CreateTempTestSpec.role("foo.b").expectedPath("foo-0.b").existingFiles("foo.b"),
+                CreateTempTestSpec.role("foo..b").expectedPath("foo.-0.b").existingFiles("foo..b"),
+                CreateTempTestSpec.role("a.b.c.d").expectedPath("a.b.c-0.d").existingFiles("a.b.c.d"),
+                CreateTempTestSpec.role("foo").expectedPath("foo-1").existingFiles("foo", "foo-0"),
+                CreateTempTestSpec.role("foo/bar/buz").expectedPath("foo/bar/buz"),
+                CreateTempTestSpec.role("foo/bar/buz").expectedPath("foo/bar/buz-0").existingFiles("foo/bar/buz"),
+                CreateTempTestSpec.role("foo/bar/buz.tmp").expectedPath("foo/bar/buz-0.tmp").existingFiles("foo/bar/buz.tmp"),
+                CreateTempTestSpec.role("foo/bar").expectedPath("foo/bar-0").existingFiles("foo/bar/buz"),
+                CreateTempTestSpec.role(Path.of("").toAbsolutePath().toString()).expectedExceptionClass(IllegalArgumentException.class),
+                CreateTempTestSpec.role(null).expectedExceptionClass(NullPointerException.class),
+                CreateTempTestSpec.role("").expectedExceptionClass(IllegalArgumentException.class)
+        ).map(CreateTempTestSpec.Builder::create).map(testSpec -> {
+            return new Object[] { testSpec };
+        }).toList();
+    }
+
     private static void runAssertWithExpectedLogOutput(ThrowingRunnable action,
             boolean expectFail, String... expectLogStrings) {
         runWithExpectedLogOutput(() -> {

test/jdk/tools/jpackage/helpers/jdk/jpackage/test/AdditionalLauncher.java

@@ -186,21 +186,10 @@ static PropertyFile getAdditionalLauncherProperties(
         return Optional.of(shell[0]).get();
     }
 
-    private void initialize(JPackageCommand cmd) {
-        Path propsFile = TKit.workDir().resolve(name + ".properties");
-        if (Files.exists(propsFile)) {
-            // File with the given name exists, pick another name that
-            // will not reference existing file.
-            try {
-                propsFile = TKit.createTempFile(propsFile);
-                TKit.deleteIfExists(propsFile);
-            } catch (IOException ex) {
-                rethrowUnchecked(ex);
-            }
-        }
+    private void initialize(JPackageCommand cmd) throws IOException {
+        final Path propsFile = TKit.createTempFile(name + ".properties");
 
-        cmd.addArguments("--add-launcher", String.format("%s=%s", name,
-                    propsFile));
+        cmd.addArguments("--add-launcher", String.format("%s=%s", name, propsFile));
 
         List<Map.Entry<String, String>> properties = new ArrayList<>();
         if (defaultArguments != null) {

test/jdk/tools/jpackage/helpers/jdk/jpackage/test/JPackageCommand.java

@@ -252,11 +252,7 @@ public JPackageCommand setDefaultInputOutput() {
 
     public JPackageCommand setInputToEmptyDirectory() {
         if (Files.exists(inputDir())) {
-            try {
-                setArgumentValue("--input", TKit.createTempDirectory("input"));
-            } catch (IOException ex) {
-                throw new RuntimeException(ex);
-            }
+            setArgumentValue("--input", TKit.createTempDirectory("input"));
         }
         return this;
     }
@@ -841,6 +837,11 @@ public static enum AppLayoutAssert {
                 TKit.assertFileExists(cmd.appLauncherCfgPath(null));
             }
         }),
+        MAIN_JAR_FILE(cmd -> {
+            Optional.ofNullable(cmd.getArgumentValue("--main-jar", () -> null)).ifPresent(mainJar -> {
+                TKit.assertFileExists(cmd.appLayout().appDirectory().resolve(mainJar));
+            });
+        }),
         RUNTIME_DIRECTORY(cmd -> {
             TKit.assertDirectoryExists(cmd.appRuntimeDirectory());
             if (TKit.isOSX()) {