7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 import java.io.IOException;
  25 import java.nio.file.Files;
  26 import java.nio.file.Path;
  27 import java.io.File;



  28 import jdk.jpackage.test.JPackageCommand;
  29 import jdk.jpackage.test.PackageTest;
  30 import jdk.jpackage.test.PackageType;

  31 import jdk.jpackage.test.LinuxHelper;
  32 import jdk.jpackage.test.Executor;
  33 import jdk.jpackage.test.Test;
  34 
  35 /**
  36  * Test --license-file parameter. Output of the test should be licensetest*.*
  37  * package bundle. The output package should provide the same functionality as
  38  * the default package and also incorporate license information from
  39  * test/jdk/tools/jpackage/resources/license.txt file from OpenJDK repo.
  40  *
  41  * deb:
  42  *
  43  * Package should install license file /usr/share/doc/licensetest/copyright
  44  * file.
  45  *
  46  * rpm:
  47  *
  48  * Package should install license file in
  49  * %{_defaultlicensedir}/licensetest-1.0/license.txt file.
  50  *
  51  * Mac:
  52  *
  53  * Windows
  54  *
  55  * Installer should display license text matching contents of the license file
  56  * during installation.
  57  */
  58 
  59 /*
  60  * @test
  61  * @summary jpackage with --license-file
  62  * @library ../helpers
  63  * @modules jdk.jpackage/jdk.jpackage.internal
  64  * @run main/othervm/timeout=360 -Xmx512m LicenseTest
  65  */
  66 public class LicenseTest {
  67     public static void main(String[] args) throws Exception {

  68         new PackageTest().configureHelloApp()
  69         .addInitializer(cmd -> {
  70             cmd.addArguments("--license-file", LICENSE_FILE.toString());
  71         })
  72         .forTypes(PackageType.LINUX_DEB)
  73         .addBundleVerifier(cmd -> {
  74             verifyLicenseFileInLinuxPackage(cmd, debLicenseFile(cmd));
  75         })
  76         .addInstallVerifier(cmd -> {
  77             verifyLicenseFileInstalledLinux(debLicenseFile(cmd));
  78         })
  79         .addUninstallVerifier(cmd -> {
  80             verifyLicenseFileNotInstalledLinux(debLicenseFile(cmd));
  81         })
  82         .forTypes(PackageType.LINUX_RPM)
  83         .addBundleVerifier(cmd -> {
  84             verifyLicenseFileInLinuxPackage(cmd,rpmLicenseFile(cmd));
  85         })
  86         .addInstallVerifier(cmd -> {
  87             verifyLicenseFileInstalledLinux(rpmLicenseFile(cmd));
  88         })
  89         .addUninstallVerifier(cmd -> {
  90             verifyLicenseFileNotInstalledLinux(rpmLicenseFile(cmd));
  91         })
  92         .run();

  93     }
  94 
  95     private static Path rpmLicenseFile(JPackageCommand cmd) {
  96         final Path licenseRoot = Path.of(
  97                 new Executor()
  98                 .setExecutable("rpm")
  99                 .addArguments("--eval", "%{_defaultlicensedir}")
 100                 .saveFirstLineOfOutput()
 101                 .execute()
 102                 .assertExitCodeIsZero().getFirstLineOfOutput());
 103         final Path licensePath = licenseRoot.resolve(String.format("%s-%s",
 104                 LinuxHelper.getPackageName(cmd), cmd.version())).resolve(
 105                 LICENSE_FILE.getFileName());
 106         return licensePath;
 107     }
 108 
 109     private static Path debLicenseFile(JPackageCommand cmd) {
 110         final Path licensePath = Path.of("/usr", "share", "doc",
 111                 LinuxHelper.getPackageName(cmd), "copyright");
 112         return licensePath;
 113     }
 114 
 115     private static void verifyLicenseFileInLinuxPackage(JPackageCommand cmd,
 116             Path expectedLicensePath) {
 117         Test.assertTrue(LinuxHelper.getPackageFiles(cmd).filter(path -> path.equals(
 118                 expectedLicensePath)).findFirst().orElse(null) != null,
 119                 String.format("Check license file [%s] is in %s package",
 120                         expectedLicensePath, LinuxHelper.getPackageName(cmd)));
 121     }
 122 
 123     private static void verifyLicenseFileInstalledLinux(Path licenseFile) {
 124         Test.assertTrue(Files.isReadable(licenseFile), String.format(
 125                 "Check license file [%s] is readable", licenseFile));
 126         try {
 127             Test.assertTrue(Files.readAllLines(licenseFile).equals(
 128                     Files.readAllLines(LICENSE_FILE)), String.format(
 129                     "Check contents of package license file [%s] are the same as contents of source license file [%s]",
 130                     licenseFile, LICENSE_FILE));





























 131         } catch (IOException ex) {
 132             throw new RuntimeException(ex);
 133         }
 134     }
 135 
 136     private static void verifyLicenseFileNotInstalledLinux(Path licenseFile) {
 137         Test.assertDirectoryExists(licenseFile.getParent(), false);
 138     }
 139 
 140     private static final Path LICENSE_FILE = Test.TEST_SRC_ROOT.resolve(
 141             Path.of("resources", "license.txt"));
 142 }

   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 import java.io.IOException;
  25 import java.nio.file.Files;
  26 import java.nio.file.Path;
  27 import java.util.List;
  28 import java.util.Arrays;
  29 import java.util.function.Function;
  30 import java.util.stream.Collectors;
  31 import jdk.jpackage.test.JPackageCommand;

  32 import jdk.jpackage.test.PackageType;
  33 import jdk.jpackage.test.PackageTest;
  34 import jdk.jpackage.test.LinuxHelper;
  35 import jdk.jpackage.test.Executor;
  36 import jdk.jpackage.test.Test;
  37 
  38 /**
  39  * Test --license-file parameter. Output of the test should be licensetest*.*
  40  * package bundle. The output package should provide the same functionality as
  41  * the default package and also incorporate license information from
  42  * test/jdk/tools/jpackage/resources/license.txt file from OpenJDK repo.
  43  *
  44  * deb:
  45  *
  46  * Package should install license file /usr/share/doc/licensetest/copyright
  47  * file.
  48  *
  49  * rpm:
  50  *
  51  * Package should install license file in
  52  * %{_defaultlicensedir}/licensetest-1.0/license.txt file.
  53  *
  54  * Mac:
  55  *
  56  * Windows
  57  *
  58  * Installer should display license text matching contents of the license file
  59  * during installation.
  60  */
  61 
  62 /*
  63  * @test
  64  * @summary jpackage with --license-file
  65  * @library ../helpers
  66  * @modules jdk.jpackage/jdk.jpackage.internal
  67  * @run main/othervm/timeout=360 -Xmx512m LicenseTest
  68  */
  69 public class LicenseTest {
  70     public static void main(String[] args) {
  71         Test.run(args, () -> {
  72             new PackageTest().configureHelloApp()
  73             .addInitializer(cmd -> {
  74                 cmd.addArguments("--license-file", LICENSE_FILE);
  75             })
  76             .forTypes(PackageType.LINUX_DEB)
  77             .addBundleVerifier(cmd -> {
  78                 verifyLicenseFileInLinuxPackage(cmd, debLicenseFile(cmd));
  79             })
  80             .addInstallVerifier(cmd -> {
  81                 verifyLicenseFileInstalledDebian(debLicenseFile(cmd));
  82             })
  83             .addUninstallVerifier(cmd -> {
  84                 verifyLicenseFileNotInstalledLinux(debLicenseFile(cmd));
  85             })
  86             .forTypes(PackageType.LINUX_RPM)
  87             .addBundleVerifier(cmd -> {
  88                 verifyLicenseFileInLinuxPackage(cmd,rpmLicenseFile(cmd));
  89             })
  90             .addInstallVerifier(cmd -> {
  91                 verifyLicenseFileInstalledRpm(rpmLicenseFile(cmd));
  92             })
  93             .addUninstallVerifier(cmd -> {
  94                 verifyLicenseFileNotInstalledLinux(rpmLicenseFile(cmd));
  95             })
  96             .run();
  97         });
  98      }
  99 
 100     private static Path rpmLicenseFile(JPackageCommand cmd) {
 101         final Path licenseRoot = Path.of(
 102                 new Executor()
 103                 .setExecutable("rpm")
 104                 .addArguments("--eval", "%{_defaultlicensedir}")
 105                 .executeAndGetFirstLineOfOutput());


 106         final Path licensePath = licenseRoot.resolve(String.format("%s-%s",
 107                 LinuxHelper.getPackageName(cmd), cmd.version())).resolve(
 108                 LICENSE_FILE.getFileName());
 109         return licensePath;
 110     }
 111 
 112     private static Path debLicenseFile(JPackageCommand cmd) {
 113         final Path licensePath = Path.of("/usr", "share", "doc",
 114                 LinuxHelper.getPackageName(cmd), "copyright");
 115         return licensePath;
 116     }
 117 
 118     private static void verifyLicenseFileInLinuxPackage(JPackageCommand cmd,
 119             Path expectedLicensePath) {
 120         Test.assertTrue(LinuxHelper.getPackageFiles(cmd).filter(path -> path.equals(
 121                 expectedLicensePath)).findFirst().orElse(null) != null,
 122                 String.format("Check license file [%s] is in %s package",
 123                         expectedLicensePath, LinuxHelper.getPackageName(cmd)));
 124     }
 125 
 126     private static void verifyLicenseFileInstalledRpm(Path licenseFile) {
 127         Test.assertTrue(Files.isReadable(licenseFile), String.format(
 128                 "Check license file [%s] is readable", licenseFile));
 129         try {
 130             Test.assertTrue(Files.readAllLines(licenseFile).equals(
 131                     Files.readAllLines(LICENSE_FILE)), String.format(
 132                     "Check contents of package license file [%s] are the same as contents of source license file [%s]",
 133                     licenseFile, LICENSE_FILE));
 134         } catch (IOException ex) {
 135             throw new RuntimeException(ex);
 136         }
 137     }
 138 
 139     private static void verifyLicenseFileInstalledDebian(Path licenseFile) {
 140         Test.assertTrue(Files.isReadable(licenseFile), String.format(
 141                 "Check license file [%s] is readable", licenseFile));
 142 
 143         Function<List<String>, List<String>> stripper = (lines) -> Arrays.asList(
 144                 String.join("\n", lines).stripTrailing().split("\n"));
 145 
 146         try {
 147             List<String> actualLines = Files.readAllLines(licenseFile).stream().dropWhile(
 148                     line -> !line.startsWith("License:")).collect(
 149                             Collectors.toList());
 150             // Remove leading `License:` followed by the whitespace from the first text line.
 151             actualLines.set(0, actualLines.get(0).split("\\s+", 2)[1]);
 152 
 153             actualLines = stripper.apply(actualLines);
 154 
 155             Test.assertNotEquals(0, String.join("\n", actualLines).length(),
 156                     "Check stripped license text is not empty");
 157 
 158             Test.assertTrue(actualLines.equals(
 159                     stripper.apply(Files.readAllLines(LICENSE_FILE))),
 160                     String.format(
 161                             "Check subset of package license file [%s] is a match of the source license file [%s]",
 162                             licenseFile, LICENSE_FILE));
 163         } catch (IOException ex) {
 164             throw new RuntimeException(ex);
 165         }
 166     }
 167 
 168     private static void verifyLicenseFileNotInstalledLinux(Path licenseFile) {
 169         Test.assertDirectoryExists(licenseFile.getParent(), false);
 170     }
 171 
 172     private static final Path LICENSE_FILE = Test.TEST_SRC_ROOT.resolve(
 173             Path.of("resources", "license.txt"));
 174 }