< prev index next >
test/jdk/tools/jpackage/helpers/jdk/jpackage/test/PackageTest.java
Print this page
*** 26,71 ****
import java.awt.GraphicsEnvironment;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.*;
! import java.util.function.BiConsumer;
! import java.util.function.Consumer;
! import java.util.function.Predicate;
! import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import jdk.jpackage.test.Functional.ThrowingConsumer;
import jdk.incubator.jpackage.internal.AppImageFile;
import static jdk.jpackage.test.PackageType.*;
/**
* Instance of PackageTest is for configuring and running a single jpackage
* command to produce platform specific package bundle.
*
* Provides methods to hook up custom configuration of jpackage command and
* verification of the output bundle.
*/
! public final class PackageTest {
- /**
- * Default test configuration for jpackage command. Default jpackage command
- * initialization includes:
- * <li>Set --input and --dest parameters.
- * <li>Set --name parameter. Value of the parameter is the name of the first
- * class with main function found in the callers stack. Defaults can be
- * overridden with custom initializers set with subsequent addInitializer()
- * function calls.
- */
public PackageTest() {
- action = DEFAULT_ACTION;
excludeTypes = new HashSet<>();
forTypes();
setExpectedExitCode(0);
- handlers = new HashMap<>();
namedInitializers = new HashSet<>();
! currentTypes.forEach(v -> handlers.put(v, new Handler(v)));
}
public PackageTest excludeTypes(PackageType... types) {
excludeTypes.addAll(Stream.of(types).collect(Collectors.toSet()));
return forTypes(currentTypes);
--- 26,61 ----
import java.awt.GraphicsEnvironment;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.*;
! import java.util.function.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import jdk.jpackage.test.Functional.ThrowingConsumer;
import jdk.incubator.jpackage.internal.AppImageFile;
+ import jdk.jpackage.test.Functional.ThrowingBiConsumer;
+ import jdk.jpackage.test.Functional.ThrowingRunnable;
import static jdk.jpackage.test.PackageType.*;
/**
* Instance of PackageTest is for configuring and running a single jpackage
* command to produce platform specific package bundle.
*
* Provides methods to hook up custom configuration of jpackage command and
* verification of the output bundle.
*/
! public final class PackageTest extends RunnablePackageTest {
public PackageTest() {
excludeTypes = new HashSet<>();
forTypes();
setExpectedExitCode(0);
namedInitializers = new HashSet<>();
! handlers = currentTypes.stream()
! .collect(Collectors.toMap(v -> v, v -> new Handler()));
! packageHandlers = createDefaultPackageHandlers();
}
public PackageTest excludeTypes(PackageType... types) {
excludeTypes.addAll(Stream.of(types).collect(Collectors.toSet()));
return forTypes(currentTypes);
*** 115,187 ****
return this;
}
namedInitializers.add(id);
}
! currentTypes.stream().forEach(type -> handlers.get(type).addInitializer(
ThrowingConsumer.toConsumer(v)));
return this;
}
public PackageTest addInitializer(ThrowingConsumer<JPackageCommand> v) {
return addInitializer(v, null);
}
public PackageTest addBundleVerifier(
! BiConsumer<JPackageCommand, Executor.Result> v) {
! currentTypes.stream().forEach(
! type -> handlers.get(type).addBundleVerifier(v));
return this;
}
public PackageTest addBundleVerifier(ThrowingConsumer<JPackageCommand> v) {
return addBundleVerifier(
(cmd, unused) -> ThrowingConsumer.toConsumer(v).accept(cmd));
}
public PackageTest addBundlePropertyVerifier(String propertyName,
! BiConsumer<String, String> pred) {
return addBundleVerifier(cmd -> {
! pred.accept(propertyName,
! LinuxHelper.getBundleProperty(cmd, propertyName));
});
}
public PackageTest addBundlePropertyVerifier(String propertyName,
String expectedPropertyValue) {
! return addBundlePropertyVerifier(propertyName, (unused, v) -> {
! TKit.assertEquals(expectedPropertyValue, v, String.format(
! "Check value of %s property is [%s]", propertyName, v));
! });
}
public PackageTest addBundleDesktopIntegrationVerifier(boolean integrated) {
forTypes(LINUX, () -> {
LinuxHelper.addBundleDesktopIntegrationVerifier(this, integrated);
});
return this;
}
public PackageTest addInstallVerifier(ThrowingConsumer<JPackageCommand> v) {
! currentTypes.stream().forEach(
! type -> handlers.get(type).addInstallVerifier(
ThrowingConsumer.toConsumer(v)));
return this;
}
public PackageTest addUninstallVerifier(ThrowingConsumer<JPackageCommand> v) {
! currentTypes.stream().forEach(
! type -> handlers.get(type).addUninstallVerifier(
ThrowingConsumer.toConsumer(v)));
return this;
}
static void withTestFileAssociationsFile(FileAssociations fa,
ThrowingConsumer<Path> consumer) {
! final String testFileDefaultName = String.join(".", "test",
! fa.getSuffix());
! TKit.withTempFile(testFileDefaultName, fa.getSuffix(), testFile -> {
if (TKit.isLinux()) {
LinuxHelper.initFileAssociationsTestFile(testFile);
}
consumer.accept(testFile);
});
--- 105,217 ----
return this;
}
namedInitializers.add(id);
}
! currentTypes.forEach(type -> handlers.get(type).addInitializer(
ThrowingConsumer.toConsumer(v)));
return this;
}
+ private PackageTest addRunOnceInitializer(ThrowingRunnable v, String id) {
+ return addInitializer(new ThrowingConsumer<JPackageCommand>() {
+ @Override
+ public void accept(JPackageCommand unused) throws Throwable {
+ if (!executed) {
+ executed = true;
+ v.run();
+ }
+ }
+
+ private boolean executed;
+ }, id);
+ }
+
public PackageTest addInitializer(ThrowingConsumer<JPackageCommand> v) {
return addInitializer(v, null);
}
+ public PackageTest addRunOnceInitializer(ThrowingRunnable v) {
+ return addRunOnceInitializer(v, null);
+ }
+
public PackageTest addBundleVerifier(
! ThrowingBiConsumer<JPackageCommand, Executor.Result> v) {
! currentTypes.forEach(type -> handlers.get(type).addBundleVerifier(
! ThrowingBiConsumer.toBiConsumer(v)));
return this;
}
public PackageTest addBundleVerifier(ThrowingConsumer<JPackageCommand> v) {
return addBundleVerifier(
(cmd, unused) -> ThrowingConsumer.toConsumer(v).accept(cmd));
}
public PackageTest addBundlePropertyVerifier(String propertyName,
! Predicate<String> pred, String predLabel) {
return addBundleVerifier(cmd -> {
! final String value;
! if (TKit.isLinux()) {
! value = LinuxHelper.getBundleProperty(cmd, propertyName);
! } else if (TKit.isWindows()) {
! value = WindowsHelper.getMsiProperty(cmd, propertyName);
! } else {
! throw new IllegalStateException();
! }
! TKit.assertTrue(pred.test(value), String.format(
! "Check value of %s property %s [%s]", propertyName,
! predLabel, value));
});
}
public PackageTest addBundlePropertyVerifier(String propertyName,
String expectedPropertyValue) {
! return addBundlePropertyVerifier(propertyName,
! expectedPropertyValue::equals, "is");
}
public PackageTest addBundleDesktopIntegrationVerifier(boolean integrated) {
forTypes(LINUX, () -> {
LinuxHelper.addBundleDesktopIntegrationVerifier(this, integrated);
});
return this;
}
public PackageTest addInstallVerifier(ThrowingConsumer<JPackageCommand> v) {
! currentTypes.forEach(type -> handlers.get(type).addInstallVerifier(
ThrowingConsumer.toConsumer(v)));
return this;
}
public PackageTest addUninstallVerifier(ThrowingConsumer<JPackageCommand> v) {
! currentTypes.forEach(type -> handlers.get(type).addUninstallVerifier(
ThrowingConsumer.toConsumer(v)));
return this;
}
+ public PackageTest setPackageInstaller(Consumer<JPackageCommand> v) {
+ currentTypes.forEach(
+ type -> packageHandlers.get(type).installHandler = v);
+ return this;
+ }
+
+ public PackageTest setPackageUnpacker(
+ BiFunction<JPackageCommand, Path, Path> v) {
+ currentTypes.forEach(type -> packageHandlers.get(type).unpackHandler = v);
+ return this;
+ }
+
+ public PackageTest setPackageUninstaller(Consumer<JPackageCommand> v) {
+ currentTypes.forEach(
+ type -> packageHandlers.get(type).uninstallHandler = v);
+ return this;
+ }
+
static void withTestFileAssociationsFile(FileAssociations fa,
ThrowingConsumer<Path> consumer) {
! final Path testFileDefaultName = Path.of("test" + fa.getSuffix());
! TKit.withTempFile(testFileDefaultName, testFile -> {
if (TKit.isLinux()) {
LinuxHelper.initFileAssociationsTestFile(testFile);
}
consumer.accept(testFile);
});
*** 190,210 ****
PackageTest addHelloAppFileAssociationsVerifier(FileAssociations fa,
String... faLauncherDefaultArgs) {
// Setup test app to have valid jpackage command line before
// running check of type of environment.
! addInitializer(cmd -> new HelloApp(null).addTo(cmd), "HelloApp");
String noActionMsg = "Not running file associations test";
if (GraphicsEnvironment.isHeadless()) {
TKit.trace(String.format(
"%s because running in headless environment", noActionMsg));
return this;
}
addInstallVerifier(cmd -> {
! if (cmd.isFakeRuntime(noActionMsg)) {
return;
}
withTestFileAssociationsFile(fa, testFile -> {
testFile = testFile.toAbsolutePath().normalize();
--- 220,240 ----
PackageTest addHelloAppFileAssociationsVerifier(FileAssociations fa,
String... faLauncherDefaultArgs) {
// Setup test app to have valid jpackage command line before
// running check of type of environment.
! addHelloAppInitializer(null);
String noActionMsg = "Not running file associations test";
if (GraphicsEnvironment.isHeadless()) {
TKit.trace(String.format(
"%s because running in headless environment", noActionMsg));
return this;
}
addInstallVerifier(cmd -> {
! if (cmd.isFakeRuntime(noActionMsg) || cmd.isPackageUnpacked(noActionMsg)) {
return;
}
withTestFileAssociationsFile(fa, testFile -> {
testFile = testFile.toAbsolutePath().normalize();
*** 223,244 ****
expectedArgs.add(testFile.toString());
// Wait a little bit after file has been created to
// make sure there are no pending writes into it.
Thread.sleep(3000);
! HelloApp.verifyOutputFile(appOutput, expectedArgs);
});
});
forTypes(PackageType.LINUX, () -> {
LinuxHelper.addFileAssociationsVerifier(this, fa);
});
return this;
}
! PackageTest forTypes(Collection<PackageType> types, Runnable action) {
Set<PackageType> oldTypes = Set.of(currentTypes.toArray(
PackageType[]::new));
try {
forTypes(types);
action.run();
--- 253,275 ----
expectedArgs.add(testFile.toString());
// Wait a little bit after file has been created to
// make sure there are no pending writes into it.
Thread.sleep(3000);
! HelloApp.verifyOutputFile(appOutput, expectedArgs,
! Collections.emptyMap());
});
});
forTypes(PackageType.LINUX, () -> {
LinuxHelper.addFileAssociationsVerifier(this, fa);
});
return this;
}
! public PackageTest forTypes(Collection<PackageType> types, Runnable action) {
Set<PackageType> oldTypes = Set.of(currentTypes.toArray(
PackageType[]::new));
try {
forTypes(types);
action.run();
*** 246,322 ****
forTypes(oldTypes);
}
return this;
}
! PackageTest forTypes(PackageType type, Runnable action) {
return forTypes(List.of(type), action);
}
! PackageTest notForTypes(Collection<PackageType> types, Runnable action) {
Set<PackageType> workset = new HashSet<>(currentTypes);
workset.removeAll(types);
return forTypes(workset, action);
}
! PackageTest notForTypes(PackageType type, Runnable action) {
return notForTypes(List.of(type), action);
}
public PackageTest configureHelloApp() {
return configureHelloApp(null);
}
! public PackageTest configureHelloApp(String encodedName) {
! addInitializer(
! cmd -> new HelloApp(JavaAppDesc.parse(encodedName)).addTo(cmd));
addInstallVerifier(HelloApp::executeLauncherAndVerifyOutput);
return this;
}
! public void run() {
! List<Handler> supportedHandlers = handlers.values().stream()
! .filter(entry -> !entry.isVoid())
.collect(Collectors.toList());
! if (supportedHandlers.isEmpty()) {
! // No handlers with initializers found. Nothing to do.
return;
}
! Supplier<JPackageCommand> initializer = new Supplier<>() {
! @Override
! public JPackageCommand get() {
! JPackageCommand cmd = new JPackageCommand().setDefaultInputOutput();
! if (bundleOutputDir != null) {
! cmd.setArgumentValue("--dest", bundleOutputDir.toString());
}
! cmd.setDefaultAppName();
! return cmd;
}
- };
! supportedHandlers.forEach(handler -> handler.accept(initializer.get()));
}
! public PackageTest setAction(Action value) {
! action = value;
! return this;
}
! public Action getAction() {
! return action;
}
! private class Handler implements Consumer<JPackageCommand> {
! Handler(PackageType type) {
! if (!PackageType.NATIVE.contains(type)) {
! throw new IllegalArgumentException(
! "Attempt to configure a test for image packaging");
}
! this.type = type;
initializers = new ArrayList<>();
bundleVerifiers = new ArrayList<>();
installVerifiers = new ArrayList<>();
uninstallVerifiers = new ArrayList<>();
}
--- 277,465 ----
forTypes(oldTypes);
}
return this;
}
! public PackageTest forTypes(PackageType type, Runnable action) {
return forTypes(List.of(type), action);
}
! public PackageTest notForTypes(Collection<PackageType> types, Runnable action) {
Set<PackageType> workset = new HashSet<>(currentTypes);
workset.removeAll(types);
return forTypes(workset, action);
}
! public PackageTest notForTypes(PackageType type, Runnable action) {
return notForTypes(List.of(type), action);
}
public PackageTest configureHelloApp() {
return configureHelloApp(null);
}
! public PackageTest configureHelloApp(String javaAppDesc) {
! addHelloAppInitializer(javaAppDesc);
addInstallVerifier(HelloApp::executeLauncherAndVerifyOutput);
return this;
}
! public final static class Group extends RunnablePackageTest {
! public Group(PackageTest... tests) {
! handlers = Stream.of(tests)
! .map(PackageTest::createPackageTypeHandlers)
! .flatMap(List<Consumer<Action>>::stream)
! .collect(Collectors.toUnmodifiableList());
! }
!
! @Override
! protected void runAction(Action... action) {
! if (Set.of(action).contains(Action.UNINSTALL)) {
! ListIterator<Consumer<Action>> listIterator = handlers.listIterator(
! handlers.size());
! while (listIterator.hasPrevious()) {
! var handler = listIterator.previous();
! List.of(action).forEach(handler::accept);
! }
! } else {
! handlers.forEach(handler -> List.of(action).forEach(handler::accept));
! }
! }
!
! private final List<Consumer<Action>> handlers;
! }
!
! final static class PackageHandlers {
! Consumer<JPackageCommand> installHandler;
! Consumer<JPackageCommand> uninstallHandler;
! BiFunction<JPackageCommand, Path, Path> unpackHandler;
! }
!
! @Override
! protected void runActions(List<Action[]> actions) {
! createPackageTypeHandlers().forEach(
! handler -> actions.forEach(
! action -> List.of(action).forEach(handler::accept)));
! }
!
! @Override
! protected void runAction(Action... action) {
! throw new UnsupportedOperationException();
! }
!
! private void addHelloAppInitializer(String javaAppDesc) {
! addInitializer(
! cmd -> new HelloApp(JavaAppDesc.parse(javaAppDesc)).addTo(cmd),
! "HelloApp");
! }
!
! private List<Consumer<Action>> createPackageTypeHandlers() {
! return PackageType.NATIVE.stream()
! .map(type -> {
! Handler handler = handlers.entrySet().stream()
! .filter(entry -> !entry.getValue().isVoid())
! .filter(entry -> entry.getKey() == type)
! .map(entry -> entry.getValue())
! .findAny().orElse(null);
! Map.Entry<PackageType, Handler> result = null;
! if (handler != null) {
! result = Map.entry(type, handler);
! }
! return result;
! })
! .filter(Objects::nonNull)
! .map(entry -> createPackageTypeHandler(
! entry.getKey(), entry.getValue()))
.collect(Collectors.toList());
+ }
+
+ private Consumer<Action> createPackageTypeHandler(
+ PackageType type, Handler handler) {
+ return ThrowingConsumer.toConsumer(new ThrowingConsumer<Action>() {
+ @Override
+ public void accept(Action action) throws Throwable {
+ if (action == Action.FINALIZE) {
+ if (unpackDir != null && Files.isDirectory(unpackDir)
+ && !unpackDir.startsWith(TKit.workDir())) {
+ TKit.deleteDirectoryRecursive(unpackDir);
+ }
+ }
! if (aborted) {
return;
}
! final JPackageCommand curCmd;
! if (Set.of(Action.INITIALIZE, Action.CREATE).contains(action)) {
! curCmd = cmd;
! } else {
! curCmd = cmd.createImmutableCopy();
}
!
! switch (action) {
! case UNPACK: {
! var handler = packageHandlers.get(type).unpackHandler;
! if (!(aborted = (handler == null))) {
! unpackDir = TKit.createTempDirectory(
! String.format("unpacked-%s",
! type.getName()));
! unpackDir = handler.apply(cmd, unpackDir);
! cmd.setUnpackedPackageLocation(unpackDir);
! }
! break;
}
! case INSTALL: {
! var handler = packageHandlers.get(type).installHandler;
! if (!(aborted = (handler == null))) {
! handler.accept(curCmd);
! }
! break;
}
! case UNINSTALL: {
! var handler = packageHandlers.get(type).uninstallHandler;
! if (!(aborted = (handler == null))) {
! handler.accept(curCmd);
! }
! break;
}
! case CREATE:
! handler.accept(action, curCmd);
! aborted = (expectedJPackageExitCode != 0);
! return;
!
! default:
! handler.accept(action, curCmd);
! break;
}
! if (aborted) {
! TKit.trace(
! String.format("Aborted [%s] action of %s command",
! action, cmd.getPrintableCommandLine()));
! }
! }
! private Path unpackDir;
! private boolean aborted;
! private final JPackageCommand cmd = Functional.identity(() -> {
! JPackageCommand result = new JPackageCommand();
! result.setDefaultInputOutput().setDefaultAppName();
! if (BUNDLE_OUTPUT_DIR != null) {
! result.setArgumentValue("--dest", BUNDLE_OUTPUT_DIR.toString());
! }
! type.applyTo(result);
! return result;
! }).get();
! });
}
!
! private class Handler implements BiConsumer<Action, JPackageCommand> {
!
! Handler() {
initializers = new ArrayList<>();
bundleVerifiers = new ArrayList<>();
installVerifiers = new ArrayList<>();
uninstallVerifiers = new ArrayList<>();
}
*** 340,376 ****
void addUninstallVerifier(Consumer<JPackageCommand> v) {
uninstallVerifiers.add(v);
}
@Override
! public void accept(JPackageCommand cmd) {
! type.applyTo(cmd);
!
! initializers.stream().forEach(v -> v.accept(cmd));
cmd.executePrerequisiteActions();
- switch (action) {
case CREATE:
! Executor.Result result = cmd.execute();
! result.assertExitCodeIs(expectedJPackageExitCode);
if (expectedJPackageExitCode == 0) {
TKit.assertFileExists(cmd.outputBundle());
} else {
TKit.assertPathExists(cmd.outputBundle(), false);
}
! verifyPackageBundle(cmd.createImmutableCopy(), result);
break;
case VERIFY_INSTALL:
if (expectedJPackageExitCode == 0) {
! verifyPackageInstalled(cmd.createImmutableCopy());
}
break;
case VERIFY_UNINSTALL:
if (expectedJPackageExitCode == 0) {
! verifyPackageUninstalled(cmd.createImmutableCopy());
}
break;
}
}
--- 483,521 ----
void addUninstallVerifier(Consumer<JPackageCommand> v) {
uninstallVerifiers.add(v);
}
@Override
! public void accept(Action action, JPackageCommand cmd) {
! switch (action) {
! case INITIALIZE:
! initializers.forEach(v -> v.accept(cmd));
! if (cmd.isImagePackageType()) {
! throw new UnsupportedOperationException();
! }
cmd.executePrerequisiteActions();
+ break;
case CREATE:
! Executor.Result result = cmd.execute(expectedJPackageExitCode);
if (expectedJPackageExitCode == 0) {
TKit.assertFileExists(cmd.outputBundle());
} else {
TKit.assertPathExists(cmd.outputBundle(), false);
}
! verifyPackageBundle(cmd, result);
break;
case VERIFY_INSTALL:
if (expectedJPackageExitCode == 0) {
! verifyPackageInstalled(cmd);
}
break;
case VERIFY_UNINSTALL:
if (expectedJPackageExitCode == 0) {
! verifyPackageUninstalled(cmd);
}
break;
}
}
*** 379,487 ****
if (expectedJPackageExitCode == 0) {
if (PackageType.LINUX.contains(cmd.packageType())) {
LinuxHelper.verifyPackageBundleEssential(cmd);
}
}
! bundleVerifiers.stream().forEach(v -> v.accept(cmd, result));
}
private void verifyPackageInstalled(JPackageCommand cmd) {
! TKit.trace(String.format("Verify installed: %s",
! cmd.getPrintableCommandLine()));
TKit.assertDirectoryExists(cmd.appRuntimeDirectory());
if (!cmd.isRuntime()) {
TKit.assertExecutableFileExists(cmd.appLauncherPath());
! if (PackageType.WINDOWS.contains(cmd.packageType())) {
! new WindowsHelper.AppVerifier(cmd);
}
}
TKit.assertPathExists(AppImageFile.getPathInAppImage(
cmd.appInstallationDirectory()), false);
! installVerifiers.stream().forEach(v -> v.accept(cmd));
}
private void verifyPackageUninstalled(JPackageCommand cmd) {
TKit.trace(String.format("Verify uninstalled: %s",
cmd.getPrintableCommandLine()));
if (!cmd.isRuntime()) {
TKit.assertPathExists(cmd.appLauncherPath(), false);
if (PackageType.WINDOWS.contains(cmd.packageType())) {
! new WindowsHelper.AppVerifier(cmd);
}
}
TKit.assertPathExists(cmd.appInstallationDirectory(), false);
! uninstallVerifiers.stream().forEach(v -> v.accept(cmd));
}
- private final PackageType type;
private final List<Consumer<JPackageCommand>> initializers;
private final List<BiConsumer<JPackageCommand, Executor.Result>> bundleVerifiers;
private final List<Consumer<JPackageCommand>> installVerifiers;
private final List<Consumer<JPackageCommand>> uninstallVerifiers;
}
private Collection<PackageType> currentTypes;
private Set<PackageType> excludeTypes;
private int expectedJPackageExitCode;
private Map<PackageType, Handler> handlers;
private Set<String> namedInitializers;
! private Action action;
!
! /**
! * Test action.
! */
! static public enum Action {
! /**
! * Create bundle.
! */
! CREATE,
! /**
! * Verify bundle installed.
! */
! VERIFY_INSTALL,
! /**
! * Verify bundle uninstalled.
! */
! VERIFY_UNINSTALL;
! @Override
! public String toString() {
! return name().toLowerCase().replace('_', '-');
! }
! };
! private final static Action DEFAULT_ACTION;
! private final static File bundleOutputDir;
static {
final String propertyName = "output";
String val = TKit.getConfigProperty(propertyName);
if (val == null) {
! bundleOutputDir = null;
} else {
! bundleOutputDir = new File(val).getAbsoluteFile();
! if (!bundleOutputDir.isDirectory()) {
! throw new IllegalArgumentException(String.format(
! "Invalid value of %s sytem property: [%s]. Should be existing directory",
TKit.getConfigPropertyName(propertyName),
! bundleOutputDir));
}
}
}
-
- static {
- final String propertyName = "action";
- String action = Optional.ofNullable(TKit.getConfigProperty(propertyName)).orElse(
- Action.CREATE.toString()).toLowerCase();
- DEFAULT_ACTION = Stream.of(Action.values()).filter(
- a -> a.toString().equals(action)).findFirst().orElseThrow(
- () -> new IllegalArgumentException(String.format(
- "Unrecognized value of %s property: [%s]",
- TKit.getConfigPropertyName(propertyName), action)));
- }
}
--- 524,624 ----
if (expectedJPackageExitCode == 0) {
if (PackageType.LINUX.contains(cmd.packageType())) {
LinuxHelper.verifyPackageBundleEssential(cmd);
}
}
! bundleVerifiers.forEach(v -> v.accept(cmd, result));
}
private void verifyPackageInstalled(JPackageCommand cmd) {
! final String formatString;
! if (cmd.isPackageUnpacked()) {
! formatString = "Verify unpacked: %s";
! } else {
! formatString = "Verify installed: %s";
! }
! TKit.trace(String.format(formatString, cmd.getPrintableCommandLine()));
!
TKit.assertDirectoryExists(cmd.appRuntimeDirectory());
if (!cmd.isRuntime()) {
TKit.assertExecutableFileExists(cmd.appLauncherPath());
! if (PackageType.WINDOWS.contains(cmd.packageType())
! && !cmd.isPackageUnpacked(
! "Not verifying desktop integration")) {
! new WindowsHelper.DesktopIntegrationVerifier(cmd);
}
}
TKit.assertPathExists(AppImageFile.getPathInAppImage(
cmd.appInstallationDirectory()), false);
! installVerifiers.forEach(v -> v.accept(cmd));
}
private void verifyPackageUninstalled(JPackageCommand cmd) {
TKit.trace(String.format("Verify uninstalled: %s",
cmd.getPrintableCommandLine()));
if (!cmd.isRuntime()) {
TKit.assertPathExists(cmd.appLauncherPath(), false);
if (PackageType.WINDOWS.contains(cmd.packageType())) {
! new WindowsHelper.DesktopIntegrationVerifier(cmd);
}
}
TKit.assertPathExists(cmd.appInstallationDirectory(), false);
! uninstallVerifiers.forEach(v -> v.accept(cmd));
}
private final List<Consumer<JPackageCommand>> initializers;
private final List<BiConsumer<JPackageCommand, Executor.Result>> bundleVerifiers;
private final List<Consumer<JPackageCommand>> installVerifiers;
private final List<Consumer<JPackageCommand>> uninstallVerifiers;
}
+ private static Map<PackageType, PackageHandlers> createDefaultPackageHandlers() {
+ HashMap<PackageType, PackageHandlers> handlers = new HashMap<>();
+ if (TKit.isLinux()) {
+ handlers.put(PackageType.LINUX_DEB, LinuxHelper.createDebPackageHandlers());
+ handlers.put(PackageType.LINUX_RPM, LinuxHelper.createRpmPackageHandlers());
+ }
+
+ if (TKit.isWindows()) {
+ handlers.put(PackageType.WIN_MSI, WindowsHelper.createMsiPackageHandlers());
+ handlers.put(PackageType.WIN_EXE, WindowsHelper.createExePackageHandlers());
+ }
+
+ if (TKit.isOSX()) {
+ handlers.put(PackageType.MAC_DMG, MacHelper.createDmgPackageHandlers());
+ handlers.put(PackageType.MAC_PKG, MacHelper.createPkgPackageHandlers());
+ }
+
+ return handlers;
+ }
+
private Collection<PackageType> currentTypes;
private Set<PackageType> excludeTypes;
private int expectedJPackageExitCode;
private Map<PackageType, Handler> handlers;
private Set<String> namedInitializers;
! private Map<PackageType, PackageHandlers> packageHandlers;
! private final static File BUNDLE_OUTPUT_DIR;
static {
final String propertyName = "output";
String val = TKit.getConfigProperty(propertyName);
if (val == null) {
! BUNDLE_OUTPUT_DIR = null;
} else {
! BUNDLE_OUTPUT_DIR = new File(val).getAbsoluteFile();
! if (!BUNDLE_OUTPUT_DIR.isDirectory()) {
! throw new IllegalArgumentException(String.format("Invalid value of %s sytem property: [%s]. Should be existing directory",
TKit.getConfigPropertyName(propertyName),
! BUNDLE_OUTPUT_DIR));
}
}
}
}
< prev index next >