From 37d0a659ed4ad4719fe22ef79790a83400ed4ebc Mon Sep 17 00:00:00 2001 From: Alexey Semenyuk Date: Thu, 2 Oct 2025 14:21:16 -0400 Subject: [PATCH] Support async test execution in jpackage test lib --- .../jdk/jpackage/test/ConfigFilesStasher.java | 10 +- .../jdk/jpackage/test/JPackageCommand.java | 60 ++- .../helpers/jdk/jpackage/test/Main.java | 4 +- .../helpers/jdk/jpackage/test/TKit.java | 343 +++++++++++++----- .../jdk/jpackage/test/TestBuilder.java | 2 +- .../jdk/jpackage/test/TestMethodSupplier.java | 2 +- .../jpackage/windows/WinNoRestartTest.java | 25 +- 7 files changed, 299 insertions(+), 147 deletions(-) diff --git a/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/ConfigFilesStasher.java b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/ConfigFilesStasher.java index e630659bdb17d..2321e4e852e3e 100644 --- a/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/ConfigFilesStasher.java +++ b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/ConfigFilesStasher.java @@ -374,8 +374,14 @@ private boolean isPathEmpty() { private static Path setupDirectory(JPackageCommand cmd, String argName) { if (!cmd.hasArgument(argName)) { - // Use absolute path as jpackage can be executed in another directory - cmd.setArgumentValue(argName, TKit.createTempDirectory("stash-script-resource-dir").toAbsolutePath()); + // Use absolute path as jpackage can be executed in another directory. + // Some tests expect a specific last argument, don't interfere with them + // and insert the argument at the beginning of the command line. + List args = new ArrayList<>(); + args.add(argName); + args.add(TKit.createTempDirectory("stash-script-resource-dir").toAbsolutePath().toString()); + args.addAll(cmd.getAllArguments()); + cmd.clearArguments().addArguments(args); } return Path.of(cmd.getArgumentValue(argName)); diff --git a/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/JPackageCommand.java b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/JPackageCommand.java index 8984450f54be2..ae9568bb844cd 100644 --- a/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/JPackageCommand.java +++ b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/JPackageCommand.java @@ -39,7 +39,6 @@ import java.security.SecureRandom; import java.util.ArrayList; import java.util.Collection; -import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.ListIterator; @@ -691,7 +690,7 @@ public boolean isPackageUnpacked() { } public static void useToolProviderByDefault(ToolProvider jpackageToolProvider) { - defaultToolProvider = Optional.of(jpackageToolProvider); + defaultToolProvider.set(Optional.of(jpackageToolProvider)); } public static void useToolProviderByDefault() { @@ -699,7 +698,7 @@ public static void useToolProviderByDefault() { } public static void useExecutableByDefault() { - defaultToolProvider = Optional.empty(); + defaultToolProvider.set(Optional.empty()); } public JPackageCommand useToolProvider(boolean v) { @@ -808,7 +807,9 @@ public JPackageCommand validateOutput(CannedFormattedString... str) { } public boolean isWithToolProvider() { - return Optional.ofNullable(withToolProvider).orElseGet(defaultToolProvider::isPresent); + return Optional.ofNullable(withToolProvider).orElseGet(() -> { + return defaultToolProvider.get().isPresent(); + }); } public JPackageCommand executePrerequisiteActions() { @@ -824,7 +825,7 @@ private Executor createExecutor() { .addArguments(args); if (isWithToolProvider()) { - exec.setToolProvider(defaultToolProvider.orElseGet(JavaTool.JPACKAGE::asToolProvider)); + exec.setToolProvider(defaultToolProvider.get().orElseGet(JavaTool.JPACKAGE::asToolProvider)); } else { exec.setExecutable(JavaTool.JPACKAGE); if (TKit.isWindows()) { @@ -1256,10 +1257,7 @@ public void assertFileNotInAppImage(Path filename) { private void assertFileInAppImage(Path filename, Path expectedPath) { if (expectedPath != null) { - if (expectedPath.isAbsolute()) { - throw new IllegalArgumentException(); - } - if (!expectedPath.getFileName().equals(filename.getFileName())) { + if (expectedPath.isAbsolute() || !expectedPath.getFileName().equals(filename.getFileName())) { throw new IllegalArgumentException(); } } @@ -1345,7 +1343,7 @@ private JPackageCommand adjustArgumentsBeforeExecution() { addArguments("--runtime-image", DEFAULT_RUNTIME_IMAGE); } - if (!hasArgument("--verbose") && TKit.VERBOSE_JPACKAGE && !ignoreDefaultVerbose) { + if (!hasArgument("--verbose") && TKit.verboseJPackage() && !ignoreDefaultVerbose) { addArgument("--verbose"); } @@ -1369,11 +1367,7 @@ public void verifyIsOfType(PackageType ... types) { final var typesSet = Stream.of(types).collect(Collectors.toSet()); if (!hasArgument("--type")) { if (!isImagePackageType()) { - if (TKit.isLinux() && typesSet.equals(PackageType.LINUX)) { - return; - } - - if (TKit.isWindows() && typesSet.equals(PackageType.WINDOWS)) { + if ((TKit.isLinux() && typesSet.equals(PackageType.LINUX)) || (TKit.isWindows() && typesSet.equals(PackageType.WINDOWS))) { return; } @@ -1523,29 +1517,21 @@ public void run() { private Set readOnlyPathAsserts = Set.of(ReadOnlyPathAssert.values()); private Set appLayoutAsserts = Set.of(AppLayoutAssert.values()); private List>> outputValidators = new ArrayList<>(); - private static Optional defaultToolProvider = Optional.empty(); - - private static final Map PACKAGE_TYPES = Functional.identity( - () -> { - Map reply = new HashMap<>(); - for (PackageType type : PackageType.values()) { - reply.put(type.getType(), type); - } - return reply; - }).get(); - - public static final Path DEFAULT_RUNTIME_IMAGE = Functional.identity(() -> { - // Set the property to the path of run-time image to speed up - // building app images and platform bundles by avoiding running jlink - // The value of the property will be automativcally appended to - // jpackage command line if the command line doesn't have - // `--runtime-image` parameter set. - String val = TKit.getConfigProperty("runtime-image"); - if (val != null) { - return Path.of(val); + private static InheritableThreadLocal> defaultToolProvider = new InheritableThreadLocal<>() { + @Override + protected Optional initialValue() { + return Optional.empty(); } - return null; - }).get(); + }; + + private static final Map PACKAGE_TYPES = Stream.of(PackageType.values()).collect(toMap(PackageType::getType, x -> x)); + + // Set the property to the path of run-time image to speed up + // building app images and platform bundles by avoiding running jlink. + // The value of the property will be automatically appended to + // jpackage command line if the command line doesn't have + // `--runtime-image` parameter set. + public static final Path DEFAULT_RUNTIME_IMAGE = Optional.ofNullable(TKit.getConfigProperty("runtime-image")).map(Path::of).orElse(null); // [HH:mm:ss.SSS] private static final Pattern TIMESTAMP_REGEXP = Pattern.compile( diff --git a/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/Main.java b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/Main.java index e7f06b0d60852..fa8fe166f5a33 100644 --- a/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/Main.java +++ b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/Main.java @@ -41,11 +41,11 @@ public final class Main { - public static void main(String args[]) throws Throwable { + public static void main(String... args) throws Throwable { main(TestBuilder.build(), args); } - public static void main(TestBuilder.Builder builder, String args[]) throws Throwable { + public static void main(TestBuilder.Builder builder, String... args) throws Throwable { boolean listTests = false; List tests = new ArrayList<>(); try (TestBuilder testBuilder = builder.testConsumer(tests::add).create()) { 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 b3f188bb371e0..497c631b4dec4 100644 --- a/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/TKit.java +++ b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/TKit.java @@ -28,7 +28,6 @@ import static jdk.jpackage.internal.util.function.ThrowingSupplier.toSupplier; import java.io.Closeable; -import java.io.FileOutputStream; import java.io.IOException; import java.io.PrintStream; import java.io.UncheckedIOException; @@ -38,6 +37,7 @@ import java.nio.file.LinkOption; import java.nio.file.Path; import java.nio.file.StandardCopyOption; +import java.nio.file.StandardOpenOption; import java.nio.file.StandardWatchEventKinds; import java.nio.file.WatchEvent; import java.nio.file.WatchKey; @@ -109,7 +109,7 @@ public final class TKit { }).get(); static void withExtraLogStream(ThrowingRunnable action) { - if (extraLogStream != null) { + if (state().extraLogStream != null) { ThrowingRunnable.toRunnable(action).run(); } else { try (PrintStream logStream = openLogStream()) { @@ -119,12 +119,44 @@ static void withExtraLogStream(ThrowingRunnable action) { } static void withExtraLogStream(ThrowingRunnable action, PrintStream logStream) { - var oldExtraLogStream = extraLogStream; + withNewState(action, stateBuilder -> { + stateBuilder.extraLogStream(logStream); + }); + } + + public static void withMainLogStream(ThrowingRunnable action, PrintStream logStream) { + withNewState(action, stateBuilder -> { + stateBuilder.mainLogStream(logStream); + }); + } + + public static void withStackTraceStream(ThrowingRunnable action, PrintStream logStream) { + withNewState(action, stateBuilder -> { + stateBuilder.stackTraceStream(logStream); + }); + } + + public static State state() { + return STATE.get(); + } + + public static void state(State v) { + STATE.set(Objects.requireNonNull(v)); + } + + private static void withNewState(ThrowingRunnable action, Consumer stateBuilderMutator) { + Objects.requireNonNull(action); + Objects.requireNonNull(stateBuilderMutator); + + var oldState = state(); + var builder = oldState.buildCopy(); + stateBuilderMutator.accept(builder); + var newState = builder.create(); try { - extraLogStream = logStream; + state(newState); ThrowingRunnable.toRunnable(action).run(); } finally { - extraLogStream = oldExtraLogStream; + state(oldState); } } @@ -141,26 +173,25 @@ static void runTests(List tests) { static void runTests(List tests, Set modes) { Objects.requireNonNull(tests); Objects.requireNonNull(modes); - if (currentTest != null) { - throw new IllegalStateException( - "Unexpected nested or concurrent Test.run() call"); + if (currentTest() != null) { + throw new IllegalStateException("Unexpected nested Test.run() call"); } withExtraLogStream(() -> { tests.stream().forEach(test -> { - currentTest = test; - try { - if (modes.contains(RunTestMode.FAIL_FAST)) { - ThrowingRunnable.toRunnable(test::run).run(); - } else { - ignoreExceptions(test).run(); - } - } finally { - currentTest = null; - if (extraLogStream != null) { - extraLogStream.flush(); + withNewState(() -> { + try { + if (modes.contains(RunTestMode.FAIL_FAST)) { + test.run(); + } else { + ignoreExceptions(test).run(); + } + } finally { + Optional.ofNullable(state().extraLogStream).ifPresent(PrintStream::flush); } - } + }, stateBuilder -> { + stateBuilder.currentTest(test); + }); }); }); } @@ -217,18 +248,18 @@ static void unbox(Throwable throwable) throws Throwable { } public static Path workDir() { - return currentTest.workDir(); + return currentTest().workDir(); } static String getCurrentDefaultAppName() { // Construct app name from swapping and joining test base name // and test function name. // Say the test name is `FooTest.testBasic`. Then app name would be `BasicFooTest`. - String appNamePrefix = currentTest.functionName(); + String appNamePrefix = currentTest().functionName(); if (appNamePrefix != null && appNamePrefix.startsWith("test")) { appNamePrefix = appNamePrefix.substring("test".length()); } - return Stream.of(appNamePrefix, currentTest.baseName()).filter( + return Stream.of(appNamePrefix, currentTest().baseName()).filter( v -> v != null && !v.isEmpty()).collect(Collectors.joining()); } @@ -256,9 +287,10 @@ private static String addTimestamp(String msg) { static void log(String v) { v = addTimestamp(v); - System.out.println(v); - if (extraLogStream != null) { - extraLogStream.println(v); + var state = state(); + state.mainLogStream.println(v); + if (state.extraLogStream != null) { + state.extraLogStream.println(v); } } @@ -308,13 +340,13 @@ public static void createPropertiesFile(Path propsFilename, } public static void trace(String v) { - if (TRACE) { + if (state().trace) { log("TRACE: " + v); } } private static void traceAssert(String v) { - if (TRACE_ASSERTS) { + if (state().traceAsserts) { log("TRACE: " + v); } } @@ -575,10 +607,14 @@ public static RuntimeException throwSkippedException(String reason) { public static RuntimeException throwSkippedException(RuntimeException ex) { trace("Skip the test: " + ex.getMessage()); - currentTest.notifySkipped(ex); + currentTest().notifySkipped(ex); throw ex; } + public static boolean isSkippedException(Throwable t) { + return JtregSkippedExceptionClass.INSTANCE.isInstance(t); + } + public static Path createRelativePathCopy(final Path file) { Path fileCopy = ThrowingSupplier.toSupplier(() -> { Path localPath = createTempFile(file.getFileName()); @@ -653,10 +689,9 @@ private static void waitForFileCreated(Path fileToWaitFor, Duration timeout) thr } static void printStackTrace(Throwable throwable) { - if (extraLogStream != null) { - throwable.printStackTrace(extraLogStream); - } - throwable.printStackTrace(); + var state = state(); + Optional.ofNullable(state.extraLogStream).ifPresent(throwable::printStackTrace); + throwable.printStackTrace(state.stackTraceStream); } private static String concatMessages(String msg, String msg2) { @@ -667,7 +702,7 @@ private static String concatMessages(String msg, String msg2) { } public static void assertEquals(long expected, long actual, String msg) { - currentTest.notifyAssert(); + currentTest().notifyAssert(); if (expected != actual) { error(concatMessages(String.format( "Expected [%d]. Actual [%d]", expected, actual), @@ -678,7 +713,7 @@ public static void assertEquals(long expected, long actual, String msg) { } public static void assertNotEquals(long expected, long actual, String msg) { - currentTest.notifyAssert(); + currentTest().notifyAssert(); if (expected == actual) { error(concatMessages(String.format("Unexpected [%d] value", actual), msg)); @@ -689,7 +724,7 @@ public static void assertNotEquals(long expected, long actual, String msg) { } public static void assertEquals(boolean expected, boolean actual, String msg) { - currentTest.notifyAssert(); + currentTest().notifyAssert(); if (expected != actual) { error(concatMessages(String.format( "Expected [%s]. Actual [%s]", expected, actual), @@ -700,7 +735,7 @@ public static void assertEquals(boolean expected, boolean actual, String msg) { } public static void assertNotEquals(boolean expected, boolean actual, String msg) { - currentTest.notifyAssert(); + currentTest().notifyAssert(); if (expected == actual) { error(concatMessages(String.format("Unexpected [%s] value", actual), msg)); @@ -712,7 +747,7 @@ public static void assertNotEquals(boolean expected, boolean actual, String msg) public static void assertEquals(Object expected, Object actual, String msg) { - currentTest.notifyAssert(); + currentTest().notifyAssert(); if ((actual != null && !actual.equals(expected)) || (expected != null && !expected.equals(actual))) { error(concatMessages(String.format( @@ -724,7 +759,7 @@ public static void assertEquals(Object expected, Object actual, String msg) { } public static void assertNotEquals(Object expected, Object actual, String msg) { - currentTest.notifyAssert(); + currentTest().notifyAssert(); if ((actual != null && !actual.equals(expected)) || (expected != null && !expected.equals(actual))) { @@ -737,7 +772,7 @@ public static void assertNotEquals(Object expected, Object actual, String msg) { } public static void assertNull(Object value, String msg) { - currentTest.notifyAssert(); + currentTest().notifyAssert(); if (value != null) { error(concatMessages(String.format("Unexpected not null value [%s]", value), msg)); @@ -747,7 +782,7 @@ public static void assertNull(Object value, String msg) { } public static void assertNotNull(Object value, String msg) { - currentTest.notifyAssert(); + currentTest().notifyAssert(); if (value == null) { error(concatMessages("Unexpected null value", msg)); } @@ -764,7 +799,7 @@ public static void assertFalse(boolean actual, String msg) { } public static void assertTrue(boolean actual, String msg, Runnable onFail) { - currentTest.notifyAssert(); + currentTest().notifyAssert(); if (!actual) { if (onFail != null) { onFail.run(); @@ -776,7 +811,7 @@ public static void assertTrue(boolean actual, String msg, Runnable onFail) { } public static void assertFalse(boolean actual, String msg, Runnable onFail) { - currentTest.notifyAssert(); + currentTest().notifyAssert(); if (actual) { if (onFail != null) { onFail.run(); @@ -853,7 +888,7 @@ public static void assertReadableFileExists(Path path) { } public static void assertUnexpected(String msg) { - currentTest.notifyAssert(); + currentTest().notifyAssert(); error(concatMessages("Unexpected", msg)); } @@ -879,7 +914,7 @@ public void match(Path ... expected) { } public void match(Set expected) { - currentTest.notifyAssert(); + currentTest().notifyAssert(); var comm = Comm.compare(content, expected); if (!comm.unique1().isEmpty() && !comm.unique2().isEmpty()) { @@ -906,7 +941,7 @@ public void contains(Path ... expected) { } public void contains(Set expected) { - currentTest.notifyAssert(); + currentTest().notifyAssert(); var comm = Comm.compare(content, expected); if (!comm.unique2().isEmpty()) { @@ -951,7 +986,7 @@ private static String format(Set paths) { public static void assertStringListEquals(List expected, List actual, String msg) { - currentTest.notifyAssert(); + currentTest().notifyAssert(); traceAssert(concatMessages("assertStringListEquals()", msg)); @@ -1177,12 +1212,13 @@ public static TextStreamVerifier assertTextStream(String what) { } private static PrintStream openLogStream() { - if (LOG_FILE == null) { - return null; - } - - return ThrowingSupplier.toSupplier(() -> new PrintStream( - new FileOutputStream(LOG_FILE.toFile(), true))).get(); + return state().logFile.map(logfile -> { + try { + return Files.newOutputStream(logfile, StandardOpenOption.CREATE, StandardOpenOption.APPEND); + } catch (IOException ex) { + throw new UncheckedIOException(ex); + } + }).map(PrintStream::new).orElse(null); } public record PathSnapshot(List contentHashes) { @@ -1226,15 +1262,6 @@ private static String hashFile(Path path) { } } - private static TestInstance currentTest; - private static PrintStream extraLogStream; - - private static final boolean TRACE; - private static final boolean TRACE_ASSERTS; - - static final boolean VERBOSE_JPACKAGE; - static final boolean VERBOSE_TEST_SETUP; - static String getConfigProperty(String propertyName) { return System.getProperty(getConfigPropertyName(propertyName)); } @@ -1262,38 +1289,19 @@ static Set tokenizeConfigProperty(String propertyName) { return tokens.stream().collect(Collectors.toSet()); } - static final Path LOG_FILE = Functional.identity(() -> { - String val = getConfigProperty("logfile"); - if (val == null) { - return null; - } - return Path.of(val); - }).get(); + private static TestInstance currentTest() { + return state().currentTest; + } - static { - Set logOptions = tokenizeConfigProperty("suppress-logging"); - if (logOptions == null) { - TRACE = true; - TRACE_ASSERTS = true; - VERBOSE_JPACKAGE = true; - VERBOSE_TEST_SETUP = true; - } else if (logOptions.contains("all")) { - TRACE = false; - TRACE_ASSERTS = false; - VERBOSE_JPACKAGE = false; - VERBOSE_TEST_SETUP = false; - } else { - Predicate> isNonOf = options -> { - return Collections.disjoint(logOptions, options); - }; + static boolean verboseJPackage() { + return state().verboseJPackage; + } - TRACE = isNonOf.test(Set.of("trace", "t")); - TRACE_ASSERTS = isNonOf.test(Set.of("assert", "a")); - VERBOSE_JPACKAGE = isNonOf.test(Set.of("jpackage", "jp")); - VERBOSE_TEST_SETUP = isNonOf.test(Set.of("init", "i")); - } + static boolean verboseTestSetup() { + return state().verboseTestSetup; } + private static final class JtregSkippedExceptionClass extends ClassLoader { @SuppressWarnings("unchecked") JtregSkippedExceptionClass() { @@ -1319,4 +1327,159 @@ private static final class JtregSkippedExceptionClass extends ClassLoader { static final Class INSTANCE = new JtregSkippedExceptionClass().clazz; } + + + public static final class State { + + private State( + Optional logFile, + TestInstance currentTest, + PrintStream mainLogStream, + PrintStream stackTraceStream, + PrintStream extraLogStream, + boolean trace, + boolean traceAsserts, + boolean verboseJPackage, + boolean verboseTestSetup) { + + Objects.requireNonNull(logFile); + Objects.requireNonNull(mainLogStream); + Objects.requireNonNull(stackTraceStream); + + this.logFile = logFile; + this.currentTest = currentTest; + this.mainLogStream = mainLogStream; + this.stackTraceStream = stackTraceStream; + this.extraLogStream = extraLogStream; + + this.trace = trace; + this.traceAsserts = traceAsserts; + + this.verboseJPackage = verboseJPackage; + this.verboseTestSetup = verboseTestSetup; + } + + + Builder buildCopy() { + return build().initFrom(this); + } + + static Builder build() { + return new Builder(); + } + + + static final class Builder { + + Builder initDefaults() { + logFile = Optional.ofNullable(getConfigProperty("logfile")).map(Path::of); + currentTest = null; + mainLogStream = System.out; + stackTraceStream = System.err; + extraLogStream = null; + + var logOptions = tokenizeConfigProperty("suppress-logging"); + if (logOptions == null) { + trace = true; + traceAsserts = true; + verboseJPackage = true; + verboseTestSetup = true; + } else if (logOptions.contains("all")) { + trace = false; + traceAsserts = false; + verboseJPackage = false; + verboseTestSetup = false; + } else { + Predicate> isNonOf = options -> { + return Collections.disjoint(logOptions, options); + }; + + trace = isNonOf.test(Set.of("trace", "t")); + traceAsserts = isNonOf.test(Set.of("assert", "a")); + verboseJPackage = isNonOf.test(Set.of("jpackage", "jp")); + verboseTestSetup = isNonOf.test(Set.of("init", "i")); + } + + return this; + } + + Builder initFrom(State state) { + logFile = state.logFile; + currentTest = state.currentTest; + mainLogStream = state.mainLogStream; + stackTraceStream = state.stackTraceStream; + extraLogStream = state.extraLogStream; + + trace = state.trace; + traceAsserts = state.traceAsserts; + + verboseJPackage = state.verboseJPackage; + verboseTestSetup = state.verboseTestSetup; + + return this; + } + + Builder logFile(Optional v) { + logFile = v; + return this; + } + + Builder currentTest(TestInstance v) { + currentTest = v; + return this; + } + + Builder mainLogStream(PrintStream v) { + mainLogStream = v; + return this; + } + + Builder stackTraceStream(PrintStream v) { + stackTraceStream = v; + return this; + } + + Builder extraLogStream(PrintStream v) { + extraLogStream = v; + return this; + } + + State create() { + return new State(logFile, currentTest, mainLogStream, stackTraceStream, extraLogStream, trace, traceAsserts, verboseJPackage, verboseTestSetup); + } + + private Optional logFile; + private TestInstance currentTest; + private PrintStream mainLogStream; + private PrintStream stackTraceStream; + private PrintStream extraLogStream; + + private boolean trace; + private boolean traceAsserts; + + private boolean verboseJPackage; + private boolean verboseTestSetup; + } + + + private final Optional logFile; + private final TestInstance currentTest; + private final PrintStream mainLogStream; + private final PrintStream stackTraceStream; + private final PrintStream extraLogStream; + + private final boolean trace; + private final boolean traceAsserts; + + private final boolean verboseJPackage; + private final boolean verboseTestSetup; + } + + + private static final InheritableThreadLocal STATE = new InheritableThreadLocal<>() { + @Override + protected State initialValue() { + return State.build().initDefaults().create(); + } + }; } diff --git a/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/TestBuilder.java b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/TestBuilder.java index 227c73bc68e4d..4009fe2f68723 100644 --- a/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/TestBuilder.java +++ b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/TestBuilder.java @@ -369,7 +369,7 @@ public String getMessage() { } static void trace(String msg) { - if (TKit.VERBOSE_TEST_SETUP) { + if (TKit.verboseTestSetup()) { TKit.log(msg); } } diff --git a/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/TestMethodSupplier.java b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/TestMethodSupplier.java index 36ae81b7db4d6..80c8b1337905c 100644 --- a/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/TestMethodSupplier.java +++ b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/TestMethodSupplier.java @@ -409,7 +409,7 @@ private static Object fromString(String value, Class toType) { } private static void trace(String msg) { - if (TKit.VERBOSE_TEST_SETUP) { + if (TKit.verboseTestSetup()) { TKit.log(msg); } } diff --git a/test/jdk/tools/jpackage/windows/WinNoRestartTest.java b/test/jdk/tools/jpackage/windows/WinNoRestartTest.java index 7f04ee2bd2ef3..909ee06b01a12 100644 --- a/test/jdk/tools/jpackage/windows/WinNoRestartTest.java +++ b/test/jdk/tools/jpackage/windows/WinNoRestartTest.java @@ -21,16 +21,15 @@ * questions. */ +import static jdk.jpackage.test.WindowsHelper.killAppLauncherProcess; + import java.io.IOException; import java.time.Duration; import java.util.List; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import jdk.jpackage.test.JPackageCommand; import jdk.jpackage.test.Annotations.Test; import jdk.jpackage.test.CfgFile; import jdk.jpackage.test.HelloApp; -import static jdk.jpackage.test.WindowsHelper.killAppLauncherProcess; +import jdk.jpackage.test.JPackageCommand; /* @test * @bug 8340311 @@ -93,18 +92,16 @@ void apply(JPackageCommand cmd, CfgFile origCfgFile) throws InterruptedException // Save updated main launcher .cfg file cfgFile.save(cmd.appLauncherCfgPath(null)); - try ( // Launch the app in a separate thread - ExecutorService exec = Executors.newSingleThreadExecutor()) { - exec.execute(() -> { - HelloApp.executeLauncher(cmd); - }); + // Launch the app in a separate thread + new Thread(() -> { + HelloApp.executeLauncher(cmd); + }).start(); - // Wait a bit to let the app start - Thread.sleep(Duration.ofSeconds(10)); + // Wait a bit to let the app start + Thread.sleep(Duration.ofSeconds(10)); - // Find the main app launcher process and kill it - killAppLauncherProcess(cmd, null, expectedNoRestarted ? 1 : 2); - } + // Find the main app launcher process and kill it + killAppLauncherProcess(cmd, null, expectedNoRestarted ? 1 : 2); } }