1 /**
2 * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
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 /*
25 * @test
26 * @library /lib/testlibrary
27 * @modules jdk.compiler
28 * jdk.jlink
29 * @build jdk.testlibrary.FileUtils CompilerUtils
30 * @run testng JmodTest
31 * @summary Basic test for jmod
32 */
33
34 import java.io.*;
35 import java.lang.module.ModuleDescriptor;
36 import java.lang.reflect.Method;
37 import java.nio.file.*;
38 import java.util.*;
39 import java.util.function.Consumer;
40 import java.util.regex.Pattern;
41 import java.util.spi.ToolProvider;
42 import java.util.stream.Stream;
43 import jdk.testlibrary.FileUtils;
44 import org.testng.annotations.BeforeTest;
45 import org.testng.annotations.Test;
46
47 import static java.io.File.pathSeparator;
48 import static java.lang.module.ModuleDescriptor.Version;
49 import static java.nio.charset.StandardCharsets.UTF_8;
50 import static java.util.stream.Collectors.toSet;
51 import static org.testng.Assert.*;
52
53 public class JmodTest {
54
55 static final ToolProvider JMOD_TOOL = ToolProvider.findFirst("jmod").get();
56
57 static final String TEST_SRC = System.getProperty("test.src", ".");
58 static final Path SRC_DIR = Paths.get(TEST_SRC, "src");
59 static final Path EXPLODED_DIR = Paths.get("build");
60 static final Path MODS_DIR = Paths.get("jmods");
61
62 static final String CLASSES_PREFIX = "classes/";
63 static final String CMDS_PREFIX = "bin/";
64 static final String LIBS_PREFIX = "native/";
65 static final String CONFIGS_PREFIX = "conf/";
66
67 @BeforeTest
68 public void buildExplodedModules() throws IOException {
69 if (Files.exists(EXPLODED_DIR))
70 FileUtils.deleteFileTreeWithRetry(EXPLODED_DIR);
71
72 for (String name : new String[] { "foo"/*, "bar", "baz"*/ } ) {
73 Path dir = EXPLODED_DIR.resolve(name);
74 assertTrue(compileModule(name, dir.resolve("classes")));
75 createCmds(dir.resolve("bin"));
76 createLibs(dir.resolve("lib"));
77 createConfigs(dir.resolve("conf"));
78 }
79
80 if (Files.exists(MODS_DIR))
81 FileUtils.deleteFileTreeWithRetry(MODS_DIR);
82 Files.createDirectories(MODS_DIR);
83 }
84
85 @Test
86 public void testList() throws IOException {
87 String cp = EXPLODED_DIR.resolve("foo").resolve("classes").toString();
88 jmod("create",
89 "--class-path", cp,
90 MODS_DIR.resolve("foo.jmod").toString())
91 .assertSuccess();
92
93 jmod("list",
94 MODS_DIR.resolve("foo.jmod").toString())
95 .assertSuccess()
96 .resultChecker(r -> {
97 // asserts dependent on the exact contents of foo
98 assertContains(r.output, CLASSES_PREFIX + "module-info.class");
99 assertContains(r.output, CLASSES_PREFIX + "jdk/test/foo/Foo.class");
100 assertContains(r.output, CLASSES_PREFIX + "jdk/test/foo/internal/Message.class");
101 });
102 }
103
104 @Test
105 public void testMainClass() throws IOException {
106 Path jmod = MODS_DIR.resolve("fooMainClass.jmod");
107 FileUtils.deleteFileIfExistsWithRetry(jmod);
108 String cp = EXPLODED_DIR.resolve("foo").resolve("classes").toString();
109
110 jmod("create",
111 "--class-path", cp,
112 "--main-class", "jdk.test.foo.Foo",
113 jmod.toString())
114 .assertSuccess()
115 .resultChecker(r -> {
116 Optional<String> omc = getModuleDescriptor(jmod).mainClass();
117 assertTrue(omc.isPresent());
118 assertEquals(omc.get(), "jdk.test.foo.Foo");
119 });
120 }
121
122 @Test
123 public void testModuleVersion() throws IOException {
124 Path jmod = MODS_DIR.resolve("fooVersion.jmod");
125 FileUtils.deleteFileIfExistsWithRetry(jmod);
126 String cp = EXPLODED_DIR.resolve("foo").resolve("classes").toString();
127
128 jmod("create",
129 "--class-path", cp,
130 "--module-version", "5.4.3",
131 jmod.toString())
132 .assertSuccess()
133 .resultChecker(r -> {
134 Optional<Version> ov = getModuleDescriptor(jmod).version();
135 assertTrue(ov.isPresent());
136 assertEquals(ov.get().toString(), "5.4.3");
137 });
138 }
139
140 @Test
141 public void testConfig() throws IOException {
142 Path jmod = MODS_DIR.resolve("fooConfig.jmod");
143 FileUtils.deleteFileIfExistsWithRetry(jmod);
144 Path cp = EXPLODED_DIR.resolve("foo").resolve("classes");
145 Path cf = EXPLODED_DIR.resolve("foo").resolve("conf");
146
147 jmod("create",
148 "--class-path", cp.toString(),
149 "--config", cf.toString(),
150 jmod.toString())
151 .assertSuccess()
152 .resultChecker(r -> {
153 try (Stream<String> s1 = findFiles(cf).map(p -> CONFIGS_PREFIX + p);
154 Stream<String> s2 = findFiles(cp).map(p -> CLASSES_PREFIX + p)) {
155 Set<String> expectedFilenames = Stream.concat(s1, s2)
156 .collect(toSet());
157 assertJmodContent(jmod, expectedFilenames);
158 }
159 });
160 }
161
162 @Test
163 public void testCmds() throws IOException {
164 Path jmod = MODS_DIR.resolve("fooCmds.jmod");
165 FileUtils.deleteFileIfExistsWithRetry(jmod);
166 Path cp = EXPLODED_DIR.resolve("foo").resolve("classes");
167 Path bp = EXPLODED_DIR.resolve("foo").resolve("bin");
168
169 jmod("create",
170 "--cmds", bp.toString(),
171 "--class-path", cp.toString(),
172 jmod.toString())
173 .assertSuccess()
174 .resultChecker(r -> {
175 try (Stream<String> s1 = findFiles(bp).map(p -> CMDS_PREFIX + p);
176 Stream<String> s2 = findFiles(cp).map(p -> CLASSES_PREFIX + p)) {
177 Set<String> expectedFilenames = Stream.concat(s1,s2)
178 .collect(toSet());
179 assertJmodContent(jmod, expectedFilenames);
180 }
181 });
182 }
183
184 @Test
185 public void testLibs() throws IOException {
186 Path jmod = MODS_DIR.resolve("fooLibs.jmod");
187 FileUtils.deleteFileIfExistsWithRetry(jmod);
188 Path cp = EXPLODED_DIR.resolve("foo").resolve("classes");
189 Path lp = EXPLODED_DIR.resolve("foo").resolve("lib");
190
191 jmod("create",
192 "--libs=", lp.toString(),
193 "--class-path", cp.toString(),
194 jmod.toString())
195 .assertSuccess()
196 .resultChecker(r -> {
197 try (Stream<String> s1 = findFiles(lp).map(p -> LIBS_PREFIX + p);
198 Stream<String> s2 = findFiles(cp).map(p -> CLASSES_PREFIX + p)) {
199 Set<String> expectedFilenames = Stream.concat(s1,s2)
200 .collect(toSet());
201 assertJmodContent(jmod, expectedFilenames);
202 }
203 });
204 }
205
206 @Test
207 public void testAll() throws IOException {
208 Path jmod = MODS_DIR.resolve("fooAll.jmod");
209 FileUtils.deleteFileIfExistsWithRetry(jmod);
210 Path cp = EXPLODED_DIR.resolve("foo").resolve("classes");
211 Path bp = EXPLODED_DIR.resolve("foo").resolve("bin");
212 Path lp = EXPLODED_DIR.resolve("foo").resolve("lib");
213 Path cf = EXPLODED_DIR.resolve("foo").resolve("conf");
214
215 jmod("create",
216 "--conf", cf.toString(),
217 "--cmds=", bp.toString(),
218 "--libs=", lp.toString(),
219 "--class-path", cp.toString(),
220 jmod.toString())
221 .assertSuccess()
222 .resultChecker(r -> {
223 try (Stream<String> s1 = findFiles(lp).map(p -> LIBS_PREFIX + p);
224 Stream<String> s2 = findFiles(cp).map(p -> CLASSES_PREFIX + p);
225 Stream<String> s3 = findFiles(bp).map(p -> CMDS_PREFIX + p);
226 Stream<String> s4 = findFiles(cf).map(p -> CONFIGS_PREFIX + p)) {
227 Set<String> expectedFilenames = Stream.concat(Stream.concat(s1,s2),
228 Stream.concat(s3, s4))
229 .collect(toSet());
230 assertJmodContent(jmod, expectedFilenames);
231 }
232 });
233 }
234
235 @Test
236 public void testExcludes() throws IOException {
237 Path jmod = MODS_DIR.resolve("fooLibs.jmod");
238 FileUtils.deleteFileIfExistsWithRetry(jmod);
239 Path cp = EXPLODED_DIR.resolve("foo").resolve("classes");
240 Path lp = EXPLODED_DIR.resolve("foo").resolve("lib");
241
242 jmod("create",
243 "--libs=", lp.toString(),
244 "--class-path", cp.toString(),
245 "--exclude", "**internal**",
246 "--exclude", "first.so",
247 jmod.toString())
248 .assertSuccess()
249 .resultChecker(r -> {
250 Set<String> expectedFilenames = new HashSet<>();
251 expectedFilenames.add(CLASSES_PREFIX + "module-info.class");
252 expectedFilenames.add(CLASSES_PREFIX + "jdk/test/foo/Foo.class");
253 expectedFilenames.add(LIBS_PREFIX + "second.so");
254 expectedFilenames.add(LIBS_PREFIX + "third/third.so");
255 assertJmodContent(jmod, expectedFilenames);
256
257 Set<String> unexpectedFilenames = new HashSet<>();
258 unexpectedFilenames.add(CLASSES_PREFIX + "jdk/test/foo/internal/Message.class");
259 unexpectedFilenames.add(LIBS_PREFIX + "first.so");
260 assertJmodDoesNotContain(jmod, unexpectedFilenames);
261 });
262 }
263
264 @Test
265 public void describe() throws IOException {
266 String cp = EXPLODED_DIR.resolve("foo").resolve("classes").toString();
267 jmod("create",
268 "--class-path", cp,
269 MODS_DIR.resolve("describeFoo.jmod").toString())
270 .assertSuccess();
271
272 jmod("describe",
273 MODS_DIR.resolve("describeFoo.jmod").toString())
274 .assertSuccess()
275 .resultChecker(r -> {
276 // Expect similar output: "foo, requires mandated java.base
277 // exports jdk.test.foo, conceals jdk.test.foo.internal"
278 Pattern p = Pattern.compile("\\s+foo\\s+requires\\s+mandated\\s+java.base");
279 assertTrue(p.matcher(r.output).find(),
280 "Expecting to find \"foo, requires java.base\"" +
281 "in output, but did not: [" + r.output + "]");
282 p = Pattern.compile(
283 "exports\\s+jdk.test.foo\\s+conceals\\s+jdk.test.foo.internal");
284 assertTrue(p.matcher(r.output).find(),
285 "Expecting to find \"exports ..., conceals ...\"" +
286 "in output, but did not: [" + r.output + "]");
287 });
288 }
289
290 @Test
291 public void testDuplicateEntries() throws IOException {
292 Path jmod = MODS_DIR.resolve("testDuplicates.jmod");
293 FileUtils.deleteFileIfExistsWithRetry(jmod);
294 String cp = EXPLODED_DIR.resolve("foo").resolve("classes").toString();
295 Path lp = EXPLODED_DIR.resolve("foo").resolve("lib");
296
297 jmod("create",
298 "--class-path", cp + pathSeparator + cp,
299 jmod.toString())
300 .assertSuccess()
301 .resultChecker(r ->
302 assertContains(r.output, "Warning: ignoring duplicate entry")
303 );
304
305 FileUtils.deleteFileIfExistsWithRetry(jmod);
306 jmod("create",
307 "--class-path", cp,
308 "--libs", lp.toString() + pathSeparator + lp.toString(),
309 jmod.toString())
310 .assertSuccess()
311 .resultChecker(r ->
312 assertContains(r.output, "Warning: ignoring duplicate entry")
313 );
314 }
315
316 @Test
317 public void testIgnoreModuleInfoInOtherSections() throws IOException {
318 Path jmod = MODS_DIR.resolve("testIgnoreModuleInfoInOtherSections.jmod");
319 FileUtils.deleteFileIfExistsWithRetry(jmod);
320 String cp = EXPLODED_DIR.resolve("foo").resolve("classes").toString();
321
322 jmod("create",
323 "--class-path", cp,
324 "--libs", cp,
325 jmod.toString())
326 .assertSuccess()
327 .resultChecker(r ->
328 assertContains(r.output, "Warning: ignoring entry")
329 );
330
331 FileUtils.deleteFileIfExistsWithRetry(jmod);
332 jmod("create",
333 "--class-path", cp,
334 "--cmds", cp,
335 jmod.toString())
336 .assertSuccess()
337 .resultChecker(r ->
338 assertContains(r.output, "Warning: ignoring entry")
339 );
340 }
341
342 @Test
343 public void testVersion() {
344 jmod("--version")
345 .assertSuccess()
346 .resultChecker(r -> {
347 assertContains(r.output, System.getProperty("java.version"));
348 });
349 }
350
351 @Test
352 public void testHelp() {
353 jmod("--help")
354 .assertSuccess()
355 .resultChecker(r ->
356 assertTrue(r.output.startsWith("Usage: jmod"), "Help not printed")
357 );
358 }
359
360 @Test
361 public void testTmpFileAlreadyExists() throws IOException {
362 // Implementation detail: jmod tool creates <jmod-file>.tmp
363 // Ensure that there are no problems if existing
364
365 Path jmod = MODS_DIR.resolve("testTmpFileAlreadyExists.jmod");
366 Path tmp = MODS_DIR.resolve("testTmpFileAlreadyExists.jmod.tmp");
367 FileUtils.deleteFileIfExistsWithRetry(jmod);
368 FileUtils.deleteFileIfExistsWithRetry(tmp);
369 Files.createFile(tmp);
370 String cp = EXPLODED_DIR.resolve("foo").resolve("classes").toString();
371
372 jmod("create",
373 "--class-path", cp,
374 jmod.toString())
375 .assertSuccess()
376 .resultChecker(r ->
377 assertTrue(Files.notExists(tmp), "Unexpected tmp file:" + tmp)
378 );
379 }
380
381 @Test
382 public void testTmpFileRemoved() throws IOException {
383 // Implementation detail: jmod tool creates <jmod-file>.tmp
384 // Ensure that it is removed in the event of a failure.
385 // The failure in this case is a class in the unnamed package.
386
387 Path jmod = MODS_DIR.resolve("testTmpFileRemoved.jmod");
388 Path tmp = MODS_DIR.resolve("testTmpFileRemoved.jmod.tmp");
389 FileUtils.deleteFileIfExistsWithRetry(jmod);
390 FileUtils.deleteFileIfExistsWithRetry(tmp);
391 String cp = EXPLODED_DIR.resolve("foo").resolve("classes") + File.pathSeparator +
392 EXPLODED_DIR.resolve("foo").resolve("classes")
393 .resolve("jdk").resolve("test").resolve("foo").toString();
394
395 jmod("create",
396 "--class-path", cp,
397 jmod.toString())
398 .assertFailure()
399 .resultChecker(r -> {
400 assertContains(r.output, "unnamed package");
401 assertTrue(Files.notExists(tmp), "Unexpected tmp file:" + tmp);
402 });
403 }
404
405 // ---
406
407 static boolean compileModule(String name, Path dest) throws IOException {
408 return CompilerUtils.compile(SRC_DIR.resolve(name), dest);
409 }
410
411 static void assertContains(String output, String subString) {
412 if (output.contains(subString))
413 assertTrue(true);
414 else
415 assertTrue(false,"Expected to find [" + subString + "], in output ["
416 + output + "]" + "\n");
417 }
418
419 static ModuleDescriptor getModuleDescriptor(Path jmod) {
420 ClassLoader cl = ClassLoader.getSystemClassLoader();
421 try (FileSystem fs = FileSystems.newFileSystem(jmod, cl)) {
422 String p = "/classes/module-info.class";
423 try (InputStream is = Files.newInputStream(fs.getPath(p))) {
424 return ModuleDescriptor.read(is);
425 }
426 } catch (IOException ioe) {
427 throw new UncheckedIOException(ioe);
428 }
429 }
430
431 static Stream<String> findFiles(Path dir) {
432 try {
433 return Files.find(dir, Integer.MAX_VALUE, (p, a) -> a.isRegularFile())
434 .map(dir::relativize)
435 .map(Path::toString)
436 .map(p -> p.replace(File.separator, "/"));
437 } catch (IOException x) {
438 throw new UncheckedIOException(x);
439 }
440 }
441
442 static Set<String> getJmodContent(Path jmod) {
443 JmodResult r = jmod("list", jmod.toString()).assertSuccess();
444 return Stream.of(r.output.split("\r?\n")).collect(toSet());
445 }
446
447 static void assertJmodContent(Path jmod, Set<String> expected) {
448 Set<String> actual = getJmodContent(jmod);
449 if (!Objects.equals(actual, expected)) {
450 Set<String> unexpected = new HashSet<>(actual);
451 unexpected.removeAll(expected);
452 Set<String> notFound = new HashSet<>(expected);
453 notFound.removeAll(actual);
454 StringBuilder sb = new StringBuilder();
455 sb.append("Unexpected but found:\n");
456 unexpected.forEach(s -> sb.append("\t" + s + "\n"));
457 sb.append("Expected but not found:\n");
458 notFound.forEach(s -> sb.append("\t" + s + "\n"));
459 assertTrue(false, "Jmod content check failed.\n" + sb.toString());
460 }
461 }
462
463 static void assertJmodDoesNotContain(Path jmod, Set<String> unexpectedNames) {
464 Set<String> actual = getJmodContent(jmod);
465 Set<String> unexpected = new HashSet<>();
466 for (String name : unexpectedNames) {
467 if (actual.contains(name))
468 unexpected.add(name);
469 }
470 if (!unexpected.isEmpty()) {
471 StringBuilder sb = new StringBuilder();
472 for (String s : unexpected)
473 sb.append("Unexpected but found: " + s + "\n");
474 sb.append("In :");
475 for (String s : actual)
476 sb.append("\t" + s + "\n");
477 assertTrue(false, "Jmod content check failed.\n" + sb.toString());
478 }
479 }
480
481 static JmodResult jmod(String... args) {
482 ByteArrayOutputStream baos = new ByteArrayOutputStream();
483 PrintStream ps = new PrintStream(baos);
484 System.out.println("jmod " + Arrays.asList(args));
485 int ec = JMOD_TOOL.run(ps, ps, args);
486 return new JmodResult(ec, new String(baos.toByteArray(), UTF_8));
487 }
488
489 static class JmodResult {
490 final int exitCode;
491 final String output;
492
493 JmodResult(int exitValue, String output) {
494 this.exitCode = exitValue;
495 this.output = output;
496 }
497 JmodResult assertSuccess() { assertTrue(exitCode == 0, output); return this; }
498 JmodResult assertFailure() { assertTrue(exitCode != 0, output); return this; }
499 JmodResult resultChecker(Consumer<JmodResult> r) { r.accept(this); return this; }
500 }
501
502 static void createCmds(Path dir) throws IOException {
503 List<String> files = Arrays.asList(
504 "first", "second", "third" + File.separator + "third");
505 createFiles(dir, files);
506 }
507
508 static void createLibs(Path dir) throws IOException {
509 List<String> files = Arrays.asList(
510 "first.so", "second.so", "third" + File.separator + "third.so");
511 createFiles(dir, files);
512 }
513
514 static void createConfigs(Path dir) throws IOException {
515 List<String> files = Arrays.asList(
516 "first.cfg", "second.cfg", "third" + File.separator + "third.cfg");
517 createFiles(dir, files);
518 }
519
520 static void createFiles(Path dir, List<String> filenames) throws IOException {
521 for (String name : filenames) {
522 Path file = dir.resolve(name);
523 Files.createDirectories(file.getParent());
524 Files.createFile(file);
525 try (OutputStream os = Files.newOutputStream(file)) {
526 os.write("blahblahblah".getBytes(UTF_8));
527 }
528 }
529 }
530
531 // Standalone entry point.
532 public static void main(String[] args) throws Throwable {
533 JmodTest test = new JmodTest();
534 test.buildExplodedModules();
535 for (Method m : JmodTest.class.getDeclaredMethods()) {
536 if (m.getAnnotation(Test.class) != null) {
537 System.out.println("Invoking " + m.getName());
538 m.invoke(test);
539 }
540 }
541 }
542 }