import java.util.ArrayList;

 * @run main/othervm/timeout=360 -Xmx512m LicenseTest testCommon

/*

 * @test

 * @summary jpackage with --license-file

 * @library ../helpers

 * @modules jdk.jpackage/jdk.jpackage.internal

 * @requires (os.family == "linux")

 * @run main/othervm/timeout=360 -Xmx512m LicenseTest testCustomDebianCopyright

 * @run main/othervm/timeout=360 -Xmx512m LicenseTest testCustomDebianCopyrightSubst

 */

            String testFuncName = args[0];

            Test.trace(String.format("Running %s...", testFuncName));

            Test.getTestClass().getDeclaredMethod(testFuncName).invoke(null);

    }

    public static void testCommon() {

        new PackageTest().configureHelloApp()

        .addInitializer(cmd -> {

            cmd.addArguments("--license-file", LICENSE_FILE);

        })

        .forTypes(PackageType.LINUX)

        .addBundleVerifier(cmd -> {

            verifyLicenseFileInLinuxPackage(cmd, linuxLicenseFile(cmd));

        })

        .addInstallVerifier(cmd -> {

            Test.assertReadableFileExists(linuxLicenseFile(cmd));

        })

        .addUninstallVerifier(cmd -> {

            verifyLicenseFileNotInstalledLinux(linuxLicenseFile(cmd));

        })

        .forTypes(PackageType.LINUX_DEB)

        .addInstallVerifier(cmd -> {

            verifyLicenseFileInstalledDebian(debLicenseFile(cmd));

        })

        .forTypes(PackageType.LINUX_RPM)

        .addInstallVerifier(cmd -> {

            verifyLicenseFileInstalledRpm(rpmLicenseFile(cmd));

        })

        .run();

    }

    public static void testCustomDebianCopyright() {

        new CustomDebianCopyrightTest().run();

    }

    public static void testCustomDebianCopyrightSubst() {

        new CustomDebianCopyrightTest().withSubstitution(true).run();

    }

    private static Path linuxLicenseFile(JPackageCommand cmd) {

        cmd.verifyIsOfType(PackageType.LINUX);

        switch (cmd.packageType()) {

            case LINUX_DEB:

                return debLicenseFile(cmd);

            case LINUX_RPM:

                return rpmLicenseFile(cmd);

            default:

                return null;

        }

    }

    private static void verifyLicenseFileInstalledRpm(Path licenseFile) throws

            IOException {

        Test.assertStringListEquals(Files.readAllLines(LICENSE_FILE),

                Files.readAllLines(licenseFile), String.format(

                "Check contents of package license file [%s] are the same as contents of source license file [%s]",

                licenseFile, LICENSE_FILE));

    private static void verifyLicenseFileInstalledDebian(Path licenseFile)

            throws IOException {

        List<String> actualLines = Files.readAllLines(licenseFile).stream().dropWhile(

                line -> !line.startsWith("License:")).collect(

                        Collectors.toList());

        // Remove leading `License:` followed by the whitespace from the first text line.

        actualLines.set(0, actualLines.get(0).split("\\s+", 2)[1]);

        actualLines = DEBIAN_COPYRIGT_FILE_STRIPPER.apply(actualLines);

        Test.assertNotEquals(0, String.join("\n", actualLines).length(),

                "Check stripped license text is not empty");

        Test.assertStringListEquals(DEBIAN_COPYRIGT_FILE_STRIPPER.apply(

                Files.readAllLines(LICENSE_FILE)), actualLines, String.format(

                "Check subset of package license file [%s] is a match of the source license file [%s]",

                licenseFile, LICENSE_FILE));

        Test.assertPathExists(licenseFile.getParent(), false);

    }

    private static class CustomDebianCopyrightTest {

        CustomDebianCopyrightTest() {

            withSubstitution(false);

        }

        private List<String> licenseFileText(String copyright, String licenseText) {

            List<String> lines = new ArrayList(List.of(

                    String.format("Copyright=%s", copyright),

                    "Foo",

                    "Bar",

                    "Buz"));

            lines.addAll(List.of(licenseText.split("\\R", -1)));

            return lines;

        }

        private List<String> licenseFileText() {

            if (withSubstitution) {

                return licenseFileText("APPLICATION_COPYRIGHT",

                        "APPLICATION_LICENSE_TEXT");

            } else {

                return expetedLicenseFileText();

            }

        }

        private List<String> expetedLicenseFileText() {

            return licenseFileText(copyright, licenseText);

        }

        CustomDebianCopyrightTest withSubstitution(boolean v) {

            withSubstitution = v;

            // Different values just to make easy to figure out from the test log which test was executed.

            if (v) {

                copyright = "Duke (C)";

                licenseText = "The quick brown fox\n jumps over the lazy dog";

            } else {

                copyright = "Java (C)";

                licenseText = "How vexingly quick daft zebras jump!";

            }

            return this;

        }

        void run() {

            final Path srcLicenseFile = Test.workDir().resolve("license");

            new PackageTest().configureHelloApp().forTypes(PackageType.LINUX_DEB)

            .addInitializer(cmd -> {

                // Create source license file.

                Files.write(srcLicenseFile, List.of(

                        licenseText.split("\\R", -1)));

                cmd.setFakeRuntime();

                cmd.setArgumentValue("--name", String.format("%s%s",

                        withSubstitution ? "CustomDebianCopyrightWithSubst" : "CustomDebianCopyright",

                        cmd.name()));

                cmd.addArguments("--license-file", srcLicenseFile);

                cmd.addArguments("--copyright", copyright);

                cmd.addArguments("--resource-dir", RESOURCE_DIR);

                // Create copyright template file in a resource dir.

                Files.createDirectories(RESOURCE_DIR);

                Files.write(RESOURCE_DIR.resolve("copyright"),

                        licenseFileText());

            })

            .addInstallVerifier(cmd -> {

                Path installedLicenseFile = debLicenseFile(cmd);

                Test.assertStringListEquals(expetedLicenseFileText(),

                        DEBIAN_COPYRIGT_FILE_STRIPPER.apply(Files.readAllLines(

                                installedLicenseFile)), String.format(

                                "Check contents of package license file [%s] are the same as contents of source license file [%s]",

                                installedLicenseFile, srcLicenseFile));

            })

            .run();

        }

        private boolean withSubstitution;

        private String copyright;

        private String licenseText;

        private final Path RESOURCE_DIR = Test.workDir().resolve("resources");

    private static final Function<List<String>, List<String>> DEBIAN_COPYRIGT_FILE_STRIPPER = (lines) -> Arrays.asList(

            String.join("\n", lines).stripTrailing().split("\n"));