import java.io.IOException;

import java.nio.file.Files;

import java.util.Arrays;

import java.util.List;

import java.util.Set;

import java.util.function.Function;

        Stream<String> lines = exec.executeAndGetOutput().stream();

    static long getInstalledPackageSizeKB(JPackageCommand cmd) {

        cmd.verifyIsOfType(PackageType.LINUX);

        final Path packageFile = cmd.outputBundle();

        switch (cmd.packageType()) {

            case LINUX_DEB:

                return Long.parseLong(getDebBundleProperty(packageFile,

                        "Installed-Size"));

            case LINUX_RPM:

                return Long.parseLong(getRpmBundleProperty(packageFile, "Size")) >> 10;

        }

        return 0;

    }

                .executeAndGetFirstLineOfOutput();

    static String getRpmBundleProperty(Path bundle, String fieldName) {

                .executeAndGetFirstLineOfOutput();

    }

    static void addDebBundleDesktopIntegrationVerifier(PackageTest test,

            boolean integrated) {

        Function<List<String>, String> verifier = (lines) -> {

            // Lookup for xdg commands

            return lines.stream().filter(line -> {

                Set<String> words = Set.of(line.split("\\s+"));

                return words.contains("xdg-desktop-menu") || words.contains(

                        "xdg-mime") || words.contains("xdg-icon-resource");

            }).findFirst().orElse(null);

        };

        test.addBundleVerifier(cmd -> {

            Test.withTempDirectory(tempDir -> {

                try {

                    // Extract control Debian package files into temporary directory

                    new Executor()

                    .setExecutable("dpkg")

                    .addArguments(

                            "-e",

                            cmd.outputBundle().toString(),

                            tempDir.toString()

                    ).execute().assertExitCodeIsZero();

                    Path controlFile = Path.of("postinst");

                    // Lookup for xdg commands in postinstall script

                    String lineWithXsdCommand = verifier.apply(

                            Files.readAllLines(tempDir.resolve(controlFile)));

                    String assertMsg = String.format(

                            "Check if %s@%s control file uses xdg commands",

                            cmd.outputBundle(), controlFile);

                    if (integrated) {

                        Test.assertNotNull(lineWithXsdCommand, assertMsg);

                    } else {

                        Test.assertNull(lineWithXsdCommand, assertMsg);

                    }

                } catch (IOException ex) {

                    throw new RuntimeException(ex);

                }

            });

        });

    }

    static void initFileAssociationsTestFile(Path testFile) {

        try {

            // Write something in test file.

            // On Ubuntu and Oracle Linux empty files are considered

            // plain text. Seems like a system bug.

            //

            // $ >foo.jptest1

            // $ xdg-mime query filetype foo.jptest1

            // text/plain

            // $ echo > foo.jptest1

            // $ xdg-mime query filetype foo.jptest1

            // application/x-jpackage-jptest1

            //

            Files.write(testFile, Arrays.asList(""));

        } catch (IOException ex) {

            throw new RuntimeException(ex);

        }

    }

    private static Path getSystemDesktopFilesFolder() {

        return Stream.of("/usr/share/applications",

                "/usr/local/share/applications").map(Path::of).filter(dir -> {

            return Files.exists(dir.resolve("defaults.list"));

        }).findFirst().orElseThrow(() -> new RuntimeException(

                "Failed to locate system .desktop files folder"));

    }

    static void addFileAssociationsVerifier(PackageTest test, FileAssociations fa) {

        test.addInstallVerifier(cmd -> {

            Test.withTempFile(fa.getSuffix(), testFile -> {

                initFileAssociationsTestFile(testFile);

                String mimeType = queryFileMimeType(testFile);

                Test.assertEquals(fa.getMime(), mimeType, String.format(

                        "Check mime type of [%s] file", testFile));

                String desktopFileName = queryMimeTypeDefaultHandler(mimeType);

                Path desktopFile = getSystemDesktopFilesFolder().resolve(

                        desktopFileName);

                Test.assertFileExists(desktopFile, true);

                Test.trace(String.format("Reading [%s] file...", desktopFile));

                String mimeHandler = null;

                try {

                    mimeHandler = Files.readAllLines(desktopFile).stream().peek(

                            v -> Test.trace(v)).filter(

                                    v -> v.startsWith("Exec=")).map(

                                    v -> v.split("=", 2)[1]).findFirst().orElseThrow();

                } catch (IOException ex) {

                    throw new RuntimeException(ex);

                }

                Test.trace(String.format("Done"));

                Test.assertEquals(cmd.launcherInstallationPath().toString(),

                        mimeHandler, String.format(

                                "Check mime type handler is the main application launcher"));

            });

        });

        test.addUninstallVerifier(cmd -> {

            Test.withTempFile(fa.getSuffix(), testFile -> {

                initFileAssociationsTestFile(testFile);

                String mimeType = queryFileMimeType(testFile);

                Test.assertNotEquals(fa.getMime(), mimeType, String.format(

                        "Check mime type of [%s] file", testFile));

                String desktopFileName = queryMimeTypeDefaultHandler(fa.getMime());

                Test.assertNull(desktopFileName, String.format(

                        "Check there is no default handler for [%s] mime type",

                        fa.getMime()));

            });

        });

    }

    private static String queryFileMimeType(Path file) {

        return new Executor()

                .setExecutable("xdg-mime")

                .addArguments("query", "filetype", file.toString())

                .executeAndGetFirstLineOfOutput();

    }

    private static String queryMimeTypeDefaultHandler(String mimeType) {

        return new Executor()

                .setExecutable("xdg-mime")

                .addArguments("query", "default", mimeType)

                .executeAndGetFirstLineOfOutput();

            arch = exec.executeAndGetFirstLineOfOutput();