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 return cmd.appInstallationDirectory().resolve("share/doc/copyright");
114 }
115
116 private static void verifyLicenseFileInLinuxPackage(JPackageCommand cmd,
117 Path expectedLicensePath) {
118 Test.assertTrue(LinuxHelper.getPackageFiles(cmd).filter(path -> path.equals(
119 expectedLicensePath)).findFirst().orElse(null) != null,
120 String.format("Check license file [%s] is in %s package",
121 expectedLicensePath, LinuxHelper.getPackageName(cmd)));
122 }
123
124 private static void verifyLicenseFileInstalledRpm(Path licenseFile) {
125 Test.assertTrue(Files.isReadable(licenseFile), String.format(
126 "Check license file [%s] is readable", licenseFile));
127 try {
128 Test.assertTrue(Files.readAllLines(licenseFile).equals(
129 Files.readAllLines(LICENSE_FILE)), String.format(
130 "Check contents of package license file [%s] are the same as contents of source license file [%s]",
131 licenseFile, LICENSE_FILE));
132 } catch (IOException ex) {
133 throw new RuntimeException(ex);
134 }
135 }
136
137 private static void verifyLicenseFileInstalledDebian(Path licenseFile) {
138 Test.assertTrue(Files.isReadable(licenseFile), String.format(
139 "Check license file [%s] is readable", licenseFile));
140
141 Function<List<String>, List<String>> stripper = (lines) -> Arrays.asList(
142 String.join("\n", lines).stripTrailing().split("\n"));
143
144 try {
145 List<String> actualLines = Files.readAllLines(licenseFile).stream().dropWhile(
146 line -> !line.startsWith("License:")).collect(
147 Collectors.toList());
148 // Remove leading `License:` followed by the whitespace from the first text line.
149 actualLines.set(0, actualLines.get(0).split("\\s+", 2)[1]);
150
151 actualLines = stripper.apply(actualLines);
152
153 Test.assertNotEquals(0, String.join("\n", actualLines).length(),
154 "Check stripped license text is not empty");
155
156 Test.assertTrue(actualLines.equals(
157 stripper.apply(Files.readAllLines(LICENSE_FILE))),
158 String.format(
159 "Check subset of package license file [%s] is a match of the source license file [%s]",
160 licenseFile, LICENSE_FILE));
161 } catch (IOException ex) {
162 throw new RuntimeException(ex);
163 }
164 }
165
166 private static void verifyLicenseFileNotInstalledLinux(Path licenseFile) {
167 Test.assertDirectoryExists(licenseFile.getParent(), false);
168 }
169
170 private static final Path LICENSE_FILE = Test.TEST_SRC_ROOT.resolve(
171 Path.of("resources", "license.txt"));
172 }
|
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.ArrayList;
29 import java.util.Arrays;
30 import java.util.function.Function;
31 import java.util.stream.Collectors;
32 import jdk.jpackage.test.JPackageCommand;
33 import jdk.jpackage.test.PackageType;
34 import jdk.jpackage.test.PackageTest;
35 import jdk.jpackage.test.LinuxHelper;
36 import jdk.jpackage.test.Executor;
37 import jdk.jpackage.test.Test;
38
39 /**
40 * Test --license-file parameter. Output of the test should be licensetest*.*
41 * package bundle. The output package should provide the same functionality as
42 * the default package and also incorporate license information from
43 * test/jdk/tools/jpackage/resources/license.txt file from OpenJDK repo.
44 *
45 * deb:
46 *
47 * Package should install license file /usr/share/doc/licensetest/copyright
48 * file.
49 *
50 * rpm:
51 *
52 * Package should install license file in
53 * %{_defaultlicensedir}/licensetest-1.0/license.txt file.
54 *
55 * Mac:
56 *
57 * Windows
58 *
59 * Installer should display license text matching contents of the license file
60 * during installation.
61 */
62
63 /*
64 * @test
65 * @summary jpackage with --license-file
66 * @library ../helpers
67 * @modules jdk.jpackage/jdk.jpackage.internal
68 * @run main/othervm/timeout=360 -Xmx512m LicenseTest testCommon
69 */
70
71 /*
72 * @test
73 * @summary jpackage with --license-file
74 * @library ../helpers
75 * @modules jdk.jpackage/jdk.jpackage.internal
76 * @requires (os.family == "linux")
77 * @run main/othervm/timeout=360 -Xmx512m LicenseTest testCustomDebianCopyright
78 * @run main/othervm/timeout=360 -Xmx512m LicenseTest testCustomDebianCopyrightSubst
79 */
80
81 public class LicenseTest {
82 public static void main(String[] args) {
83 Test.run(args, () -> {
84 String testFuncName = args[0];
85 Test.trace(String.format("Running %s...", testFuncName));
86 Test.getTestClass().getDeclaredMethod(testFuncName).invoke(null);
87 });
88 }
89
90 public static void testCommon() {
91 new PackageTest().configureHelloApp()
92 .addInitializer(cmd -> {
93 cmd.addArguments("--license-file", LICENSE_FILE);
94 })
95 .forTypes(PackageType.LINUX)
96 .addBundleVerifier(cmd -> {
97 verifyLicenseFileInLinuxPackage(cmd, linuxLicenseFile(cmd));
98 })
99 .addInstallVerifier(cmd -> {
100 Test.assertReadableFileExists(linuxLicenseFile(cmd));
101 })
102 .addUninstallVerifier(cmd -> {
103 verifyLicenseFileNotInstalledLinux(linuxLicenseFile(cmd));
104 })
105 .forTypes(PackageType.LINUX_DEB)
106 .addInstallVerifier(cmd -> {
107 verifyLicenseFileInstalledDebian(debLicenseFile(cmd));
108 })
109 .forTypes(PackageType.LINUX_RPM)
110 .addInstallVerifier(cmd -> {
111 verifyLicenseFileInstalledRpm(rpmLicenseFile(cmd));
112 })
113 .run();
114 }
115
116 public static void testCustomDebianCopyright() {
117 new CustomDebianCopyrightTest().run();
118 }
119
120 public static void testCustomDebianCopyrightSubst() {
121 new CustomDebianCopyrightTest().withSubstitution(true).run();
122 }
123
124 private static Path rpmLicenseFile(JPackageCommand cmd) {
125 final Path licenseRoot = Path.of(
126 new Executor()
127 .setExecutable("rpm")
128 .addArguments("--eval", "%{_defaultlicensedir}")
129 .executeAndGetFirstLineOfOutput());
130 final Path licensePath = licenseRoot.resolve(String.format("%s-%s",
131 LinuxHelper.getPackageName(cmd), cmd.version())).resolve(
132 LICENSE_FILE.getFileName());
133 return licensePath;
134 }
135
136 private static Path linuxLicenseFile(JPackageCommand cmd) {
137 cmd.verifyIsOfType(PackageType.LINUX);
138 switch (cmd.packageType()) {
139 case LINUX_DEB:
140 return debLicenseFile(cmd);
141
142 case LINUX_RPM:
143 return rpmLicenseFile(cmd);
144
145 default:
146 return null;
147 }
148 }
149
150 private static Path debLicenseFile(JPackageCommand cmd) {
151 return cmd.appInstallationDirectory().resolve("share/doc/copyright");
152 }
153
154 private static void verifyLicenseFileInLinuxPackage(JPackageCommand cmd,
155 Path expectedLicensePath) {
156 Test.assertTrue(LinuxHelper.getPackageFiles(cmd).filter(path -> path.equals(
157 expectedLicensePath)).findFirst().orElse(null) != null,
158 String.format("Check license file [%s] is in %s package",
159 expectedLicensePath, LinuxHelper.getPackageName(cmd)));
160 }
161
162 private static void verifyLicenseFileInstalledRpm(Path licenseFile) throws
163 IOException {
164 Test.assertStringListEquals(Files.readAllLines(LICENSE_FILE),
165 Files.readAllLines(licenseFile), String.format(
166 "Check contents of package license file [%s] are the same as contents of source license file [%s]",
167 licenseFile, LICENSE_FILE));
168 }
169
170 private static void verifyLicenseFileInstalledDebian(Path licenseFile)
171 throws IOException {
172
173 List<String> actualLines = Files.readAllLines(licenseFile).stream().dropWhile(
174 line -> !line.startsWith("License:")).collect(
175 Collectors.toList());
176 // Remove leading `License:` followed by the whitespace from the first text line.
177 actualLines.set(0, actualLines.get(0).split("\\s+", 2)[1]);
178
179 actualLines = DEBIAN_COPYRIGT_FILE_STRIPPER.apply(actualLines);
180
181 Test.assertNotEquals(0, String.join("\n", actualLines).length(),
182 "Check stripped license text is not empty");
183
184 Test.assertStringListEquals(DEBIAN_COPYRIGT_FILE_STRIPPER.apply(
185 Files.readAllLines(LICENSE_FILE)), actualLines, String.format(
186 "Check subset of package license file [%s] is a match of the source license file [%s]",
187 licenseFile, LICENSE_FILE));
188 }
189
190 private static void verifyLicenseFileNotInstalledLinux(Path licenseFile) {
191 Test.assertPathExists(licenseFile.getParent(), false);
192 }
193
194 private static class CustomDebianCopyrightTest {
195 CustomDebianCopyrightTest() {
196 withSubstitution(false);
197 }
198
199 private List<String> licenseFileText(String copyright, String licenseText) {
200 List<String> lines = new ArrayList(List.of(
201 String.format("Copyright=%s", copyright),
202 "Foo",
203 "Bar",
204 "Buz"));
205 lines.addAll(List.of(licenseText.split("\\R", -1)));
206 return lines;
207 }
208
209 private List<String> licenseFileText() {
210 if (withSubstitution) {
211 return licenseFileText("APPLICATION_COPYRIGHT",
212 "APPLICATION_LICENSE_TEXT");
213 } else {
214 return expetedLicenseFileText();
215 }
216 }
217
218 private List<String> expetedLicenseFileText() {
219 return licenseFileText(copyright, licenseText);
220 }
221
222 CustomDebianCopyrightTest withSubstitution(boolean v) {
223 withSubstitution = v;
224 // Different values just to make easy to figure out from the test log which test was executed.
225 if (v) {
226 copyright = "Duke (C)";
227 licenseText = "The quick brown fox\n jumps over the lazy dog";
228 } else {
229 copyright = "Java (C)";
230 licenseText = "How vexingly quick daft zebras jump!";
231 }
232 return this;
233 }
234
235 void run() {
236 final Path srcLicenseFile = Test.workDir().resolve("license");
237 new PackageTest().configureHelloApp().forTypes(PackageType.LINUX_DEB)
238 .addInitializer(cmd -> {
239 // Create source license file.
240 Files.write(srcLicenseFile, List.of(
241 licenseText.split("\\R", -1)));
242
243 cmd.setFakeRuntime();
244 cmd.setArgumentValue("--name", String.format("%s%s",
245 withSubstitution ? "CustomDebianCopyrightWithSubst" : "CustomDebianCopyright",
246 cmd.name()));
247 cmd.addArguments("--license-file", srcLicenseFile);
248 cmd.addArguments("--copyright", copyright);
249 cmd.addArguments("--resource-dir", RESOURCE_DIR);
250
251 // Create copyright template file in a resource dir.
252 Files.createDirectories(RESOURCE_DIR);
253 Files.write(RESOURCE_DIR.resolve("copyright"),
254 licenseFileText());
255 })
256 .addInstallVerifier(cmd -> {
257 Path installedLicenseFile = debLicenseFile(cmd);
258 Test.assertStringListEquals(expetedLicenseFileText(),
259 DEBIAN_COPYRIGT_FILE_STRIPPER.apply(Files.readAllLines(
260 installedLicenseFile)), String.format(
261 "Check contents of package license file [%s] are the same as contents of source license file [%s]",
262 installedLicenseFile, srcLicenseFile));
263 })
264 .run();
265 }
266
267 private boolean withSubstitution;
268 private String copyright;
269 private String licenseText;
270
271 private final Path RESOURCE_DIR = Test.workDir().resolve("resources");
272 }
273
274 private static final Path LICENSE_FILE = Test.TEST_SRC_ROOT.resolve(
275 Path.of("resources", "license.txt"));
276
277 private static final Function<List<String>, List<String>> DEBIAN_COPYRIGT_FILE_STRIPPER = (lines) -> Arrays.asList(
278 String.join("\n", lines).stripTrailing().split("\n"));
279 }
|