1 /*
2 * Copyright (c) 2015, 2017, 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 import java.io.*;
25 import java.lang.module.ModuleDescriptor;
26 import java.lang.reflect.Method;
27 import java.nio.file.*;
28 import java.nio.file.attribute.BasicFileAttributes;
29 import java.util.*;
30 import java.util.function.Consumer;
31 import java.util.jar.JarEntry;
32 import java.util.jar.JarFile;
33 import java.util.jar.JarInputStream;
34 import java.util.jar.Manifest;
35 import java.util.regex.Pattern;
36 import java.util.stream.Collectors;
37 import java.util.stream.Stream;
38
39 import jdk.testlibrary.FileUtils;
40 import jdk.testlibrary.JDKToolFinder;
41 import org.testng.annotations.BeforeTest;
42 import org.testng.annotations.DataProvider;
43 import org.testng.annotations.Test;
44
45 import static java.lang.String.format;
46 import static java.lang.System.out;
47
48 /*
49 * @test
50 * @bug 8167328 8171830 8165640 8174248 8176772
51 * @library /lib/testlibrary
52 * @modules jdk.compiler
53 * jdk.jartool
54 * @build jdk.testlibrary.FileUtils jdk.testlibrary.JDKToolFinder
55 * @compile Basic.java
56 * @run testng Basic
57 * @summary Tests for plain Modular jars & Multi-Release Modular jars
58 */
59
60 public class Basic {
61 static final Path TEST_SRC = Paths.get(System.getProperty("test.src", "."));
62 static final Path TEST_CLASSES = Paths.get(System.getProperty("test.classes", "."));
63 static final Path MODULE_CLASSES = TEST_CLASSES.resolve("build");
64 static final Path MRJAR_DIR = MODULE_CLASSES.resolve("mrjar");
65
66 static final String VM_OPTIONS = System.getProperty("test.vm.opts", "");
67 static final String TOOL_VM_OPTIONS = System.getProperty("test.tool.vm.opts", "");
68 static final String JAVA_OPTIONS = System.getProperty("test.java.opts", "");
69
70 // Details based on the checked in module source
71 static TestModuleData FOO = new TestModuleData("foo",
72 "1.123",
73 "jdk.test.foo.Foo",
74 "Hello World!!!",
75 null, // no hashes
76 Set.of("java.base"),
77 Set.of("jdk.test.foo"),
78 null, // no uses
79 null, // no provides
80 Set.of("jdk.test.foo.internal",
81 "jdk.test.foo.resources"));
82 static TestModuleData BAR = new TestModuleData("bar",
83 "4.5.6.7",
84 "jdk.test.bar.Bar",
85 "Hello from Bar!",
86 null, // no hashes
87 Set.of("java.base", "foo"),
88 null, // no exports
89 null, // no uses
90 null, // no provides
91 Set.of("jdk.test.bar",
92 "jdk.test.bar.internal"));
93
94 static class TestModuleData {
95 final String moduleName;
96 final Set<String> requires;
97 final Set<String> exports;
98 final Set<String> uses;
99 final Set<String> provides;
100 final String mainClass;
101 final String version;
102 final String message;
103 final String hashes;
104 final Set<String> packages;
105
106 TestModuleData(String mn, String v, String mc, String m, String h,
107 Set<String> requires, Set<String> exports, Set<String> uses,
108 Set<String> provides, Set<String> contains) {
109 moduleName = mn; mainClass = mc; version = v; message = m; hashes = h;
110 this.requires = requires != null ? requires : Collections.emptySet();
111 this.exports = exports != null ? exports : Collections.emptySet();
112 this.uses = uses != null ? uses : Collections.emptySet();;
113 this.provides = provides != null ? provides : Collections.emptySet();
114 this.packages = Stream.concat(this.exports.stream(), contains.stream())
115 .collect(Collectors.toSet());
116 }
117 static TestModuleData from(String s) {
118 try {
119 BufferedReader reader = new BufferedReader(new StringReader(s));
120 String line;
121 String message = null;
122 String name = null, version = null, mainClass = null;
123 String hashes = null;
124 Set<String> requires, exports, uses, provides, conceals;
125 requires = exports = uses = provides = conceals = null;
126 while ((line = reader.readLine()) != null) {
127 if (line.startsWith("message:")) {
128 message = line.substring("message:".length());
129 } else if (line.startsWith("nameAndVersion:")) {
130 line = line.substring("nameAndVersion:".length());
131 int i = line.indexOf('@');
132 if (i != -1) {
133 name = line.substring(0, i);
134 version = line.substring(i + 1, line.length());
135 } else {
136 name = line;
137 }
138 } else if (line.startsWith("mainClass:")) {
139 mainClass = line.substring("mainClass:".length());
140 } else if (line.startsWith("requires:")) {
141 line = line.substring("requires:".length());
142 requires = stringToSet(line);
143 } else if (line.startsWith("exports:")) {
144 line = line.substring("exports:".length());
145 exports = stringToSet(line);
146 } else if (line.startsWith("uses:")) {
147 line = line.substring("uses:".length());
148 uses = stringToSet(line);
149 } else if (line.startsWith("provides:")) {
150 line = line.substring("provides:".length());
151 provides = stringToSet(line);
152 } else if (line.startsWith("hashes:")) {
153 hashes = line.substring("hashes:".length());
154 } else if (line.startsWith("contains:")) {
155 line = line.substring("contains:".length());
156 conceals = stringToSet(line);
157 } else {
158 throw new AssertionError("Unknown value " + line);
159 }
160 }
161
162 return new TestModuleData(name, version, mainClass, message,
163 hashes, requires, exports, uses,
164 provides, conceals);
165 } catch (IOException x) {
166 throw new UncheckedIOException(x);
167 }
168 }
169 static Set<String> stringToSet(String commaList) {
170 Set<String> s = new HashSet<>();
171 int i = commaList.indexOf(',');
172 if (i != -1) {
173 String[] p = commaList.split(",");
174 Stream.of(p).forEach(s::add);
175 } else {
176 s.add(commaList);
177 }
178 return s;
179 }
180 }
181
182 static void assertModuleData(Result r, TestModuleData expected) {
183 //out.printf("%s%n", r.output);
184 TestModuleData received = TestModuleData.from(r.output);
185 if (expected.message != null)
186 assertTrue(expected.message.equals(received.message),
187 "Expected message:", expected.message, ", got:", received.message);
188 assertTrue(expected.moduleName.equals(received.moduleName),
189 "Expected moduleName: ", expected.moduleName, ", got:", received.moduleName);
190 assertTrue(expected.version.equals(received.version),
191 "Expected version: ", expected.version, ", got:", received.version);
192 assertTrue(expected.mainClass.equals(received.mainClass),
193 "Expected mainClass: ", expected.mainClass, ", got:", received.mainClass);
194 assertSetsEqual(expected.requires, received.requires);
195 assertSetsEqual(expected.exports, received.exports);
196 assertSetsEqual(expected.uses, received.uses);
197 assertSetsEqual(expected.provides, received.provides);
198 assertSetsEqual(expected.packages, received.packages);
199 }
200
201 static void assertSetsEqual(Set<String> s1, Set<String> s2) {
202 if (!s1.equals(s2)) {
203 org.testng.Assert.assertTrue(false, s1 + " vs " + s2);
204 }
205 }
206
207 @BeforeTest
208 public void compileModules() throws Exception {
209 compileModule(FOO.moduleName);
210 compileModule(BAR.moduleName, MODULE_CLASSES);
211 compileModule("baz"); // for service provider consistency checking
212
213 // copy resources
214 copyResource(TEST_SRC.resolve("src").resolve(FOO.moduleName),
215 MODULE_CLASSES.resolve(FOO.moduleName),
216 "jdk/test/foo/resources/foo.properties");
217
218 setupMRJARModuleInfo(FOO.moduleName);
219 setupMRJARModuleInfo(BAR.moduleName);
220 setupMRJARModuleInfo("baz");
221 }
222
223 @Test
224 public void createFoo() throws IOException {
225 Path mp = Paths.get("createFoo");
226 createTestDir(mp);
227 Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);
228 Path modularJar = mp.resolve(FOO.moduleName + ".jar");
229
230 jar("--create",
231 "--file=" + modularJar.toString(),
232 "--main-class=" + FOO.mainClass,
233 "--module-version=" + FOO.version,
234 "--no-manifest",
235 "-C", modClasses.toString(), ".")
236 .assertSuccess();
237
238 assertSetsEqual(readPackagesAttribute(modularJar),
239 Set.of("jdk.test.foo",
240 "jdk.test.foo.resources",
241 "jdk.test.foo.internal"));
242
243 java(mp, FOO.moduleName + "/" + FOO.mainClass)
244 .assertSuccess()
245 .resultChecker(r -> assertModuleData(r, FOO));
246 try (InputStream fis = Files.newInputStream(modularJar);
247 JarInputStream jis = new JarInputStream(fis)) {
248 assertTrue(!jarContains(jis, "./"),
249 "Unexpected ./ found in ", modularJar.toString());
250 }
251 }
252
253 /** Similar to createFoo, but with a Multi-Release Modular jar. */
254 @Test
255 public void createMRMJarFoo() throws IOException {
256 Path mp = Paths.get("createMRMJarFoo");
257 createTestDir(mp);
258 Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);
259 Path mrjarDir = MRJAR_DIR.resolve(FOO.moduleName);
260 Path modularJar = mp.resolve(FOO.moduleName + ".jar");
261
262 // Positive test, create
263 jar("--create",
264 "--file=" + modularJar.toString(),
265 "--main-class=" + FOO.mainClass,
266 "--module-version=" + FOO.version,
267 "-m", mrjarDir.resolve("META-INF/MANIFEST.MF").toRealPath().toString(),
268 "-C", mrjarDir.toString(), "META-INF/versions/9/module-info.class",
269 "-C", modClasses.toString(), ".")
270 .assertSuccess();
271 java(mp, FOO.moduleName + "/" + FOO.mainClass)
272 .assertSuccess()
273 .resultChecker(r -> assertModuleData(r, FOO));
274 }
275
276
277 @Test
278 public void updateFoo() throws IOException {
279 Path mp = Paths.get("updateFoo");
280 createTestDir(mp);
281 Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);
282 Path modularJar = mp.resolve(FOO.moduleName + ".jar");
283
284 jar("--create",
285 "--file=" + modularJar.toString(),
286 "--no-manifest",
287 "-C", modClasses.toString(), "jdk")
288 .assertSuccess();
289 jar("--update",
290 "--file=" + modularJar.toString(),
291 "--main-class=" + FOO.mainClass,
292 "--module-version=" + FOO.version,
293 "--no-manifest",
294 "-C", modClasses.toString(), "module-info.class")
295 .assertSuccess();
296 java(mp, FOO.moduleName + "/" + FOO.mainClass)
297 .assertSuccess()
298 .resultChecker(r -> assertModuleData(r, FOO));
299 }
300
301 @Test
302 public void updateMRMJarFoo() throws IOException {
303 Path mp = Paths.get("updateMRMJarFoo");
304 createTestDir(mp);
305 Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);
306 Path mrjarDir = MRJAR_DIR.resolve(FOO.moduleName);
307 Path modularJar = mp.resolve(FOO.moduleName + ".jar");
308
309 jar("--create",
310 "--file=" + modularJar.toString(),
311 "--no-manifest",
312 "-C", modClasses.toString(), "jdk")
313 .assertSuccess();
314 jar("--update",
315 "--file=" + modularJar.toString(),
316 "--main-class=" + FOO.mainClass,
317 "--module-version=" + FOO.version,
318 "-m", mrjarDir.resolve("META-INF/MANIFEST.MF").toRealPath().toString(),
319 "-C", mrjarDir.toString(), "META-INF/versions/9/module-info.class",
320 "-C", modClasses.toString(), "module-info.class")
321 .assertSuccess();
322 java(mp, FOO.moduleName + "/" + FOO.mainClass)
323 .assertSuccess()
324 .resultChecker(r -> assertModuleData(r, FOO));
325 }
326
327 @Test
328 public void partialUpdateFooMainClass() throws IOException {
329 Path mp = Paths.get("partialUpdateFooMainClass");
330 createTestDir(mp);
331 Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);
332 Path modularJar = mp.resolve(FOO.moduleName + ".jar");
333
334 // A "bad" main class in first create ( and no version )
335 jar("--create",
336 "--file=" + modularJar.toString(),
337 "--main-class=" + "jdk.test.foo.IAmNotTheEntryPoint",
338 "--no-manifest",
339 "-C", modClasses.toString(), ".") // includes module-info.class
340 .assertSuccess();
341 jar("--update",
342 "--file=" + modularJar.toString(),
343 "--main-class=" + FOO.mainClass,
344 "--module-version=" + FOO.version,
345 "--no-manifest")
346 .assertSuccess();
347 java(mp, FOO.moduleName + "/" + FOO.mainClass)
348 .assertSuccess()
349 .resultChecker(r -> assertModuleData(r, FOO));
350 }
351
352 @Test
353 public void partialUpdateFooVersion() throws IOException {
354 Path mp = Paths.get("partialUpdateFooVersion");
355 createTestDir(mp);
356 Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);
357 Path modularJar = mp.resolve(FOO.moduleName + ".jar");
358
359 // A "bad" version in first create ( and no main class )
360 jar("--create",
361 "--file=" + modularJar.toString(),
362 "--module-version=" + "100000000",
363 "--no-manifest",
364 "-C", modClasses.toString(), ".") // includes module-info.class
365 .assertSuccess();
366 jar("--update",
367 "--file=" + modularJar.toString(),
368 "--main-class=" + FOO.mainClass,
369 "--module-version=" + FOO.version,
370 "--no-manifest")
371 .assertSuccess();
372 java(mp, FOO.moduleName + "/" + FOO.mainClass)
373 .assertSuccess()
374 .resultChecker(r -> assertModuleData(r, FOO));
375 }
376
377 @Test
378 public void partialUpdateFooNotAllFiles() throws IOException {
379 Path mp = Paths.get("partialUpdateFooNotAllFiles");
380 createTestDir(mp);
381 Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);
382 Path modularJar = mp.resolve(FOO.moduleName + ".jar");
383
384 // Not all files, and none from non-exported packages,
385 // i.e. no concealed list in first create
386 jar("--create",
387 "--file=" + modularJar.toString(),
388 "--no-manifest",
389 "-C", modClasses.toString(), "module-info.class",
390 "-C", modClasses.toString(), "jdk/test/foo/Foo.class",
391 "-C", modClasses.toString(), "jdk/test/foo/resources/foo.properties")
392 .assertSuccess();
393 jar("--update",
394 "--file=" + modularJar.toString(),
395 "--main-class=" + FOO.mainClass,
396 "--module-version=" + FOO.version,
397 "--no-manifest",
398 "-C", modClasses.toString(), "jdk/test/foo/internal/Message.class")
399 .assertSuccess();
400 java(mp, FOO.moduleName + "/" + FOO.mainClass)
401 .assertSuccess()
402 .resultChecker(r -> assertModuleData(r, FOO));
403 }
404
405 @Test
406 public void partialUpdateMRMJarFooNotAllFiles() throws IOException {
407 Path mp = Paths.get("partialUpdateMRMJarFooNotAllFiles");
408 createTestDir(mp);
409 Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);
410 Path mrjarDir = MRJAR_DIR.resolve(FOO.moduleName);
411 Path modularJar = mp.resolve(FOO.moduleName + ".jar");
412
413 jar("--create",
414 "--file=" + modularJar.toString(),
415 "--module-version=" + FOO.version,
416 "-C", modClasses.toString(), ".")
417 .assertSuccess();
418 jar("--update",
419 "--file=" + modularJar.toString(),
420 "--main-class=" + FOO.mainClass,
421 "--module-version=" + FOO.version,
422 "-m", mrjarDir.resolve("META-INF/MANIFEST.MF").toRealPath().toString(),
423 "-C", mrjarDir.toString(), "META-INF/versions/9/module-info.class")
424 .assertSuccess();
425 java(mp, FOO.moduleName + "/" + FOO.mainClass)
426 .assertSuccess()
427 .resultChecker(r -> assertModuleData(r, FOO));
428 }
429
430 @Test
431 public void partialUpdateFooAllFilesAndAttributes() throws IOException {
432 Path mp = Paths.get("partialUpdateFooAllFilesAndAttributes");
433 createTestDir(mp);
434 Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);
435 Path modularJar = mp.resolve(FOO.moduleName + ".jar");
436
437 // all attributes and files
438 jar("--create",
439 "--file=" + modularJar.toString(),
440 "--main-class=" + FOO.mainClass,
441 "--module-version=" + FOO.version,
442 "--no-manifest",
443 "-C", modClasses.toString(), ".")
444 .assertSuccess();
445 jar("--update",
446 "--file=" + modularJar.toString(),
447 "--main-class=" + FOO.mainClass,
448 "--module-version=" + FOO.version,
449 "--no-manifest",
450 "-C", modClasses.toString(), ".")
451 .assertSuccess();
452 java(mp, FOO.moduleName + "/" + FOO.mainClass)
453 .assertSuccess()
454 .resultChecker(r -> assertModuleData(r, FOO));
455 }
456
457 @Test
458 public void partialUpdateFooModuleInfo() throws IOException {
459 Path mp = Paths.get("partialUpdateFooModuleInfo");
460 createTestDir(mp);
461 Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);
462 Path modularJar = mp.resolve(FOO.moduleName + ".jar");
463 Path barModInfo = MODULE_CLASSES.resolve(BAR.moduleName);
464
465 jar("--create",
466 "--file=" + modularJar.toString(),
467 "--main-class=" + FOO.mainClass,
468 "--module-version=" + FOO.version,
469 "--no-manifest",
470 "-C", modClasses.toString(), ".")
471 .assertSuccess();
472 jar("--update",
473 "--file=" + modularJar.toString(),
474 "--no-manifest",
475 "-C", barModInfo.toString(), "module-info.class") // stuff in bar's info
476 .assertSuccess();
477 jar("-d",
478 "--file=" + modularJar.toString())
479 .assertSuccess()
480 .resultChecker(r -> {
481 // Expect "bar jar:file:/.../!module-info.class"
482 // conceals jdk.test.foo, conceals jdk.test.foo.internal"
483 String uri = "jar:" + modularJar.toUri().toString() + "/!module-info.class";
484 assertTrue(r.output.contains("bar " + uri),
485 "Expecting to find \"bar " + uri + "\"",
486 "in output, but did not: [" + r.output + "]");
487 Pattern p = Pattern.compile(
488 "contains\\s+jdk.test.foo\\s+contains\\s+jdk.test.foo.internal");
489 assertTrue(p.matcher(r.output).find(),
490 "Expecting to find \"contains jdk.test.foo,...\"",
491 "in output, but did not: [" + r.output + "]");
492 });
493 }
494
495
496 @Test
497 public void partialUpdateFooPackagesAttribute() throws IOException {
498 Path mp = Paths.get("partialUpdateFooPackagesAttribute");
499 createTestDir(mp);
500 Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);
501 Path modularJar = mp.resolve(FOO.moduleName + ".jar");
502
503 // Not all files, and none from non-exported packages,
504 // i.e. no concealed list in first create
505 jar("--create",
506 "--file=" + modularJar.toString(),
507 "--no-manifest",
508 "-C", modClasses.toString(), "module-info.class",
509 "-C", modClasses.toString(), "jdk/test/foo/Foo.class")
510 .assertSuccess();
511
512 assertSetsEqual(readPackagesAttribute(modularJar),
513 Set.of("jdk.test.foo"));
514
515 jar("--update",
516 "--file=" + modularJar.toString(),
517 "-C", modClasses.toString(), "jdk/test/foo/resources/foo.properties")
518 .assertSuccess();
519
520 assertSetsEqual(readPackagesAttribute(modularJar),
521 Set.of("jdk.test.foo", "jdk.test.foo.resources"));
522
523 jar("--update",
524 "--file=" + modularJar.toString(),
525 "--main-class=" + FOO.mainClass,
526 "--module-version=" + FOO.version,
527 "--no-manifest",
528 "-C", modClasses.toString(), "jdk/test/foo/internal/Message.class")
529 .assertSuccess();
530
531 assertSetsEqual(readPackagesAttribute(modularJar),
532 Set.of("jdk.test.foo",
533 "jdk.test.foo.resources",
534 "jdk.test.foo.internal"));
535
536 java(mp, FOO.moduleName + "/" + FOO.mainClass)
537 .assertSuccess()
538 .resultChecker(r -> assertModuleData(r, FOO));
539 }
540
541 private Set<String> readPackagesAttribute(Path jar) {
542 return getModuleDescriptor(jar).packages();
543 }
544
545 @Test
546 public void hashBarInFooModule() throws IOException {
547 Path mp = Paths.get("dependencesFooBar");
548 createTestDir(mp);
549
550 Path modClasses = MODULE_CLASSES.resolve(BAR.moduleName);
551 Path modularJar = mp.resolve(BAR.moduleName + ".jar");
552 jar("--create",
553 "--file=" + modularJar.toString(),
554 "--main-class=" + BAR.mainClass,
555 "--module-version=" + BAR.version,
556 "--no-manifest",
557 "-C", modClasses.toString(), ".")
558 .assertSuccess();
559
560 modClasses = MODULE_CLASSES.resolve(FOO.moduleName);
561 modularJar = mp.resolve(FOO.moduleName + ".jar");
562 jar("--create",
563 "--file=" + modularJar.toString(),
564 "--main-class=" + FOO.mainClass,
565 "--module-version=" + FOO.version,
566 "--module-path=" + mp.toString(),
567 "--hash-modules=" + "bar",
568 "--no-manifest",
569 "-C", modClasses.toString(), ".")
570 .assertSuccess();
571
572 java(mp, BAR.moduleName + "/" + BAR.mainClass,
573 "--add-exports", "java.base/jdk.internal.misc=bar",
574 "--add-exports", "java.base/jdk.internal.module=bar")
575 .assertSuccess()
576 .resultChecker(r -> {
577 assertModuleData(r, BAR);
578 TestModuleData received = TestModuleData.from(r.output);
579 assertTrue(received.hashes != null, "Expected non-null hashes value.");
580 });
581 }
582
583 @Test
584 public void invalidHashInFooModule() throws IOException {
585 Path mp = Paths.get("badDependencyFooBar");
586 createTestDir(mp);
587
588 Path barClasses = MODULE_CLASSES.resolve(BAR.moduleName);
589 Path barJar = mp.resolve(BAR.moduleName + ".jar");
590 jar("--create",
591 "--file=" + barJar.toString(),
592 "--main-class=" + BAR.mainClass,
593 "--module-version=" + BAR.version,
594 "--no-manifest",
595 "-C", barClasses.toString(), ".").assertSuccess();
596
597 Path fooClasses = MODULE_CLASSES.resolve(FOO.moduleName);
598 Path fooJar = mp.resolve(FOO.moduleName + ".jar");
599 jar("--create",
600 "--file=" + fooJar.toString(),
601 "--main-class=" + FOO.mainClass,
602 "--module-version=" + FOO.version,
603 "-p", mp.toString(), // test short-form
604 "--hash-modules=" + "bar",
605 "--no-manifest",
606 "-C", fooClasses.toString(), ".").assertSuccess();
607
608 // Rebuild bar.jar with a change that will cause its hash to be different
609 FileUtils.deleteFileWithRetry(barJar);
610 jar("--create",
611 "--file=" + barJar.toString(),
612 "--main-class=" + BAR.mainClass,
613 "--module-version=" + BAR.version + ".1", // a newer version
614 "--no-manifest",
615 "-C", barClasses.toString(), ".").assertSuccess();
616
617 java(mp, BAR.moduleName + "/" + BAR.mainClass,
618 "--add-exports", "java.base/jdk.internal.misc=bar",
619 "--add-exports", "java.base/jdk.internal.module=bar")
620 .assertFailure()
621 .resultChecker(r -> {
622 // Expect similar output: "java.lang.module.ResolutionException: Hash
623 // of bar (WdktSIQSkd4+CEacpOZoeDrCosMATNrIuNub9b5yBeo=) differs to
624 // expected hash (iepvdv8xTeVrFgMtUhcFnmetSub6qQHCHc92lSaSEg0=)"
625 Pattern p = Pattern.compile(".*Hash of bar.*differs to expected hash.*");
626 assertTrue(p.matcher(r.output).find(),
627 "Expecting error message containing \"Hash of bar ... differs to"
628 + " expected hash...\" but got: [", r.output + "]");
629 });
630 }
631
632 @Test
633 public void badOptionsFoo() throws IOException {
634 Path mp = Paths.get("badOptionsFoo");
635 createTestDir(mp);
636 Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);
637 Path modularJar = mp.resolve(FOO.moduleName + ".jar");
638
639 jar("--create",
640 "--file=" + modularJar.toString(),
641 "--module-version=" + 1.1, // no module-info.class
642 "-C", modClasses.toString(), "jdk")
643 .assertFailure(); // TODO: expected failure message
644
645 jar("--create",
646 "--file=" + modularJar.toString(),
647 "--hash-modules=" + ".*", // no module-info.class
648 "-C", modClasses.toString(), "jdk")
649 .assertFailure(); // TODO: expected failure message
650 }
651
652 @Test
653 public void servicesCreateWithoutFailure() throws IOException {
654 Path mp = Paths.get("servicesCreateWithoutFailure");
655 createTestDir(mp);
656 Path modClasses = MODULE_CLASSES.resolve("baz");
657 Path modularJar = mp.resolve("baz" + ".jar");
658
659 // Positive test, create
660 jar("--create",
661 "--file=" + modularJar.toString(),
662 "-C", modClasses.toString(), "module-info.class",
663 "-C", modClasses.toString(), "jdk/test/baz/BazService.class",
664 "-C", modClasses.toString(), "jdk/test/baz/internal/BazServiceImpl.class")
665 .assertSuccess();
666 }
667
668 @Test
669 public void servicesCreateWithoutServiceImpl() throws IOException {
670 Path mp = Paths.get("servicesWithoutServiceImpl");
671 createTestDir(mp);
672 Path modClasses = MODULE_CLASSES.resolve("baz");
673 Path modularJar = mp.resolve("baz" + ".jar");
674
675 // Omit service impl
676 jar("--create",
677 "--file=" + modularJar.toString(),
678 "-C", modClasses.toString(), "module-info.class",
679 "-C", modClasses.toString(), "jdk/test/baz/BazService.class")
680 .assertFailure();
681 }
682
683 @Test
684 public void servicesUpdateWithoutFailure() throws IOException {
685 Path mp = Paths.get("servicesUpdateWithoutFailure");
686 createTestDir(mp);
687 Path modClasses = MODULE_CLASSES.resolve("baz");
688 Path modularJar = mp.resolve("baz" + ".jar");
689
690 // Positive test, update
691 jar("--create",
692 "--file=" + modularJar.toString(),
693 "-C", modClasses.toString(), "jdk/test/baz/BazService.class",
694 "-C", modClasses.toString(), "jdk/test/baz/internal/BazServiceImpl.class")
695 .assertSuccess();
696 jar("--update",
697 "--file=" + modularJar.toString(),
698 "-C", modClasses.toString(), "module-info.class")
699 .assertSuccess();
700 }
701
702 @Test
703 public void servicesUpdateWithoutServiceImpl() throws IOException {
704 Path mp = Paths.get("servicesUpdateWithoutServiceImpl");
705 createTestDir(mp);
706 Path modClasses = MODULE_CLASSES.resolve("baz");
707 Path modularJar = mp.resolve("baz" + ".jar");
708
709 // Omit service impl
710 jar("--create",
711 "--file=" + modularJar.toString(),
712 "-C", modClasses.toString(), "jdk/test/baz/BazService.class")
713 .assertSuccess();
714 jar("--update",
715 "--file=" + modularJar.toString(),
716 "-C", modClasses.toString(), "module-info.class")
717 .assertFailure();
718 }
719
720 @Test
721 public void servicesCreateWithoutFailureMRMJAR() throws IOException {
722 Path mp = Paths.get("servicesCreateWithoutFailureMRMJAR");
723 createTestDir(mp);
724 Path modClasses = MODULE_CLASSES.resolve("baz");
725 Path mrjarDir = MRJAR_DIR.resolve("baz");
726 Path modularJar = mp.resolve("baz" + ".jar");
727
728 jar("--create",
729 "--file=" + modularJar.toString(),
730 "-m", mrjarDir.resolve("META-INF/MANIFEST.MF").toRealPath().toString(),
731 "-C", modClasses.toString(), "module-info.class",
732 "-C", mrjarDir.toString(), "META-INF/versions/9/module-info.class",
733 "-C", modClasses.toString(), "jdk/test/baz/BazService.class",
734 "-C", modClasses.toString(), "jdk/test/baz/internal/BazServiceImpl.class")
735 .assertSuccess();
736 }
737
738 @Test
739 public void servicesCreateWithoutFailureNonRootMRMJAR() throws IOException {
740 // without a root module-info.class
741 Path mp = Paths.get("servicesCreateWithoutFailureNonRootMRMJAR");
742 createTestDir(mp);
743 Path modClasses = MODULE_CLASSES.resolve("baz");
744 Path mrjarDir = MRJAR_DIR.resolve("baz");
745 Path modularJar = mp.resolve("baz.jar");
746
747 jar("--create",
748 "--file=" + modularJar.toString(),
749 "--main-class=" + "jdk.test.baz.Baz",
750 "-m", mrjarDir.resolve("META-INF/MANIFEST.MF").toRealPath().toString(),
751 "-C", mrjarDir.toString(), "META-INF/versions/9/module-info.class",
752 "-C", modClasses.toString(), "jdk/test/baz/BazService.class",
753 "-C", modClasses.toString(), "jdk/test/baz/Baz.class",
754 "-C", modClasses.toString(), "jdk/test/baz/internal/BazServiceImpl.class")
755 .assertSuccess();
756
757
758 for (String option : new String[] {"--describe-module", "-d" }) {
759
760 jar(option,
761 "--file=" + modularJar.toString(),
762 "--release", "9")
763 .assertSuccess()
764 .resultChecker(r ->
765 assertTrue(r.output.contains("main-class jdk.test.baz.Baz"),
766 "Expected to find ", "main-class jdk.test.baz.Baz",
767 " in [", r.output, "]"));
768
769 jarWithStdin(modularJar.toFile(), option, "--release", "9")
770 .assertSuccess()
771 .resultChecker(r ->
772 assertTrue(r.output.contains("main-class jdk.test.baz.Baz"),
773 "Expected to find ", "main-class jdk.test.baz.Baz",
774 " in [", r.output, "]"));
775
776 }
777 // run module main class
778 java(mp, "baz/jdk.test.baz.Baz")
779 .assertSuccess()
780 .resultChecker(r ->
781 assertTrue(r.output.contains("mainClass:jdk.test.baz.Baz"),
782 "Expected to find ", "mainClass:jdk.test.baz.Baz",
783 " in [", r.output, "]"));
784 }
785
786 @Test
787 public void exportCreateWithMissingPkg() throws IOException {
788
789 Path foobar = TEST_SRC.resolve("src").resolve("foobar");
790 Path dst = Files.createDirectories(MODULE_CLASSES.resolve("foobar"));
791 javac(dst, null, sourceList(foobar));
792
793 Path mp = Paths.get("exportWithMissingPkg");
794 createTestDir(mp);
795 Path modClasses = dst;
796 Path modularJar = mp.resolve("foofoo.jar");
797
798 jar("--create",
799 "--file=" + modularJar.toString(),
800 "-C", modClasses.toString(), "module-info.class",
801 "-C", modClasses.toString(), "jdk/test/foo/Foo.class")
802 .assertFailure();
803 }
804
805 @Test
806 public void describeModuleFoo() throws IOException {
807 Path mp = Paths.get("describeModuleFoo");
808 createTestDir(mp);
809 Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);
810 Path modularJar = mp.resolve(FOO.moduleName + ".jar");
811
812 jar("--create",
813 "--file=" + modularJar.toString(),
814 "--main-class=" + FOO.mainClass,
815 "--module-version=" + FOO.version,
816 "--no-manifest",
817 "-C", modClasses.toString(), ".")
818 .assertSuccess();
819
820 for (String option : new String[] {"--describe-module", "-d" }) {
821 jar(option,
822 "--file=" + modularJar.toString())
823 .assertSuccess()
824 .resultChecker(r ->
825 assertTrue(r.output.contains(FOO.moduleName + "@" + FOO.version),
826 "Expected to find ", FOO.moduleName + "@" + FOO.version,
827 " in [", r.output, "]")
828 );
829
830 jar(option,
831 "--file=" + modularJar.toString(),
832 modularJar.toString())
833 .assertFailure();
834
835 jar(option, modularJar.toString())
836 .assertFailure();
837 }
838 }
839
840 @Test
841 public void describeModuleFooFromStdin() throws IOException {
842 Path mp = Paths.get("describeModuleFooFromStdin");
843 createTestDir(mp);
844 Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);
845 Path modularJar = mp.resolve(FOO.moduleName + ".jar");
846
847 jar("--create",
848 "--file=" + modularJar.toString(),
849 "--main-class=" + FOO.mainClass,
850 "--module-version=" + FOO.version,
851 "--no-manifest",
852 "-C", modClasses.toString(), ".")
853 .assertSuccess();
854
855 for (String option : new String[] {"--describe-module", "-d" }) {
856 jarWithStdin(modularJar.toFile(),
857 option)
858 .assertSuccess()
859 .resultChecker(r ->
860 assertTrue(r.output.contains(FOO.moduleName + "@" + FOO.version),
861 "Expected to find ", FOO.moduleName + "@" + FOO.version,
862 " in [", r.output, "]")
863 );
864 }
865 }
866
867
868 @DataProvider(name = "autoNames")
869 public Object[][] autoNames() {
870 return new Object[][] {
871 // JAR file name module-name[@version]
872 { "foo.jar", "foo" },
873 { "foo1.jar", "foo1" },
874 { "foo4j.jar", "foo4j", },
875 { "foo-1.2.3.4.jar", "foo@1.2.3.4" },
876 { "foo-bar.jar", "foo.bar" },
877 { "foo-1.2-SNAPSHOT.jar", "foo@1.2-SNAPSHOT" },
878 };
879 }
880
881 @Test(dataProvider = "autoNames")
882 public void describeAutomaticModule(String jarName, String mid)
883 throws IOException
884 {
885 Path mp = Paths.get("describeAutomaticModule");
886 createTestDir(mp);
887 Path regularJar = mp.resolve(jarName);
888 Path t = Paths.get("t");
889 if (Files.notExists(t))
890 Files.createFile(t);
891
892 jar("--create",
893 "--file=" + regularJar.toString(),
894 t.toString())
895 .assertSuccess();
896
897 for (String option : new String[] {"--describe-module", "-d" }) {
898 jar(option,
899 "--file=" + regularJar.toString())
900 .assertSuccess()
901 .resultChecker(r -> {
902 assertTrue(r.output.contains("No module descriptor found"));
903 assertTrue(r.output.contains("Derived automatic module"));
904 assertTrue(r.output.contains(mid + " automatic"),
905 "Expected [", "module " + mid,"] in [", r.output, "]");
906 }
907 );
908 }
909 }
910
911 // -- Infrastructure
912
913 static Result jarWithStdin(File stdinSource, String... args) {
914 String jar = getJDKTool("jar");
915 List<String> commands = new ArrayList<>();
916 commands.add(jar);
917 if (!TOOL_VM_OPTIONS.isEmpty()) {
918 commands.addAll(Arrays.asList(TOOL_VM_OPTIONS.split("\\s+", -1)));
919 }
920 Stream.of(args).forEach(commands::add);
921 ProcessBuilder p = new ProcessBuilder(commands);
922 if (stdinSource != null)
923 p.redirectInput(stdinSource);
924 return run(p);
925 }
926
927 static Result jar(String... args) {
928 return jarWithStdin(null, args);
929 }
930
931 static Path compileModule(String mn) throws IOException {
932 return compileModule(mn, null);
933 }
934
935 static Path compileModule(String mn, Path mp)
936 throws IOException
937 {
938 Path sourcePath = TEST_SRC.resolve("src").resolve(mn);
939 Path build = Files.createDirectories(MODULE_CLASSES.resolve(mn));
940 javac(build, mp, sourceList(sourcePath));
941 return build;
942 }
943
944 static void copyResource(Path srcDir, Path dir, String resource)
945 throws IOException
946 {
947 Path dest = dir.resolve(resource);
948 Files.deleteIfExists(dest);
949
950 Files.createDirectories(dest.getParent());
951 Files.copy(srcDir.resolve(resource), dest);
952 }
953
954 static void setupMRJARModuleInfo(String moduleName) throws IOException {
955 Path modClasses = MODULE_CLASSES.resolve(moduleName);
956 Path metaInfDir = MRJAR_DIR.resolve(moduleName).resolve("META-INF");
957 Path versionSection = metaInfDir.resolve("versions").resolve("9");
958 createTestDir(versionSection);
959
960 Path versionModuleInfo = versionSection.resolve("module-info.class");
961 System.out.println("copying " + modClasses.resolve("module-info.class") + " to " + versionModuleInfo);
962 Files.copy(modClasses.resolve("module-info.class"), versionModuleInfo);
963
964 Manifest manifest = new Manifest();
965 manifest.getMainAttributes().putValue("Manifest-Version", "1.0");
966 manifest.getMainAttributes().putValue("Multi-Release", "true");
967 try (OutputStream os = Files.newOutputStream(metaInfDir.resolve("MANIFEST.MF"))) {
968 manifest.write(os);
969 }
970 }
971
972 static ModuleDescriptor getModuleDescriptor(Path jar) {
973 ClassLoader cl = ClassLoader.getSystemClassLoader();
974 try (JarFile jf = new JarFile(jar.toFile())) {
975 JarEntry entry = jf.getJarEntry("module-info.class");
976 try (InputStream in = jf.getInputStream(entry)) {
977 return ModuleDescriptor.read(in);
978 }
979 } catch (IOException ioe) {
980 throw new UncheckedIOException(ioe);
981 }
982 }
983
984 // Re-enable when there is support in javax.tools for module path
985 // static void javac(Path dest, Path... sourceFiles) throws IOException {
986 // out.printf("Compiling %d source files %s%n", sourceFiles.length,
987 // Arrays.asList(sourceFiles));
988 // JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
989 // try (StandardJavaFileManager fileManager =
990 // compiler.getStandardFileManager(null, null, null)) {
991 //
992 // List<File> files = Stream.of(sourceFiles)
993 // .map(p -> p.toFile())
994 // .collect(Collectors.toList());
995 // List<File> dests = Stream.of(dest)
996 // .map(p -> p.toFile())
997 // .collect(Collectors.toList());
998 // Iterable<? extends JavaFileObject> compilationUnits =
999 // fileManager.getJavaFileObjectsFromFiles(files);
1000 // fileManager.setLocation(StandardLocation.CLASS_OUTPUT, dests);
1001 // JavaCompiler.CompilationTask task =
1002 // compiler.getTask(null, fileManager, null, null, null, compilationUnits);
1003 // boolean passed = task.call();
1004 // if (!passed)
1005 // throw new RuntimeException("Error compiling " + files);
1006 // }
1007 // }
1008
1009 static void javac(Path dest, Path... sourceFiles) throws IOException {
1010 javac(dest, null, sourceFiles);
1011 }
1012
1013 static void javac(Path dest, Path modulePath, Path... sourceFiles)
1014 throws IOException
1015 {
1016 String javac = getJDKTool("javac");
1017
1018 List<String> commands = new ArrayList<>();
1019 commands.add(javac);
1020 if (!TOOL_VM_OPTIONS.isEmpty()) {
1021 commands.addAll(Arrays.asList(TOOL_VM_OPTIONS.split("\\s+", -1)));
1022 }
1023 commands.add("-d");
1024 commands.add(dest.toString());
1025 if (dest.toString().contains("bar")) {
1026 commands.add("--add-exports");
1027 commands.add("java.base/jdk.internal.misc=bar");
1028 commands.add("--add-exports");
1029 commands.add("java.base/jdk.internal.module=bar");
1030 }
1031 if (modulePath != null) {
1032 commands.add("--module-path");
1033 commands.add(modulePath.toString());
1034 }
1035 Stream.of(sourceFiles).map(Object::toString).forEach(x -> commands.add(x));
1036
1037 quickFail(run(new ProcessBuilder(commands)));
1038 }
1039
1040 static Result java(Path modulePath, String entryPoint, String... args) {
1041 String java = getJDKTool("java");
1042
1043 List<String> commands = new ArrayList<>();
1044 commands.add(java);
1045 if (!VM_OPTIONS.isEmpty()) {
1046 commands.addAll(Arrays.asList(VM_OPTIONS.split("\\s+", -1)));
1047 }
1048 if (!JAVA_OPTIONS.isEmpty()) {
1049 commands.addAll(Arrays.asList(JAVA_OPTIONS.split("\\s+", -1)));
1050 }
1051 Stream.of(args).forEach(x -> commands.add(x));
1052 commands.add("--module-path");
1053 commands.add(modulePath.toString());
1054 commands.add("-m");
1055 commands.add(entryPoint);
1056
1057 return run(new ProcessBuilder(commands));
1058 }
1059
1060 static Path[] sourceList(Path directory) throws IOException {
1061 return Files.find(directory, Integer.MAX_VALUE,
1062 (file, attrs) -> (file.toString().endsWith(".java")))
1063 .toArray(Path[]::new);
1064 }
1065
1066 static void createTestDir(Path p) throws IOException{
1067 if (Files.exists(p))
1068 FileUtils.deleteFileTreeWithRetry(p);
1069 Files.createDirectories(p);
1070 }
1071
1072 static boolean jarContains(JarInputStream jis, String entryName)
1073 throws IOException
1074 {
1075 JarEntry e;
1076 while((e = jis.getNextJarEntry()) != null) {
1077 if (e.getName().equals(entryName))
1078 return true;
1079 }
1080 return false;
1081 }
1082
1083 static void quickFail(Result r) {
1084 if (r.ec != 0)
1085 throw new RuntimeException(r.output);
1086 }
1087
1088 static Result run(ProcessBuilder pb) {
1089 Process p;
1090 out.printf("Running: %s%n", pb.command());
1091 try {
1092 p = pb.start();
1093 } catch (IOException e) {
1094 throw new RuntimeException(
1095 format("Couldn't start process '%s'", pb.command()), e);
1096 }
1097
1098 String output;
1099 try {
1100 output = toString(p.getInputStream(), p.getErrorStream());
1101 } catch (IOException e) {
1102 throw new RuntimeException(
1103 format("Couldn't read process output '%s'", pb.command()), e);
1104 }
1105
1106 try {
1107 p.waitFor();
1108 } catch (InterruptedException e) {
1109 throw new RuntimeException(
1110 format("Process hasn't finished '%s'", pb.command()), e);
1111 }
1112 return new Result(p.exitValue(), output);
1113 }
1114
1115 static final String DEFAULT_IMAGE_BIN = System.getProperty("java.home")
1116 + File.separator + "bin" + File.separator;
1117
1118 static String getJDKTool(String name) {
1119 try {
1120 return JDKToolFinder.getJDKTool(name);
1121 } catch (Exception x) {
1122 return DEFAULT_IMAGE_BIN + name;
1123 }
1124 }
1125
1126 static String toString(InputStream in1, InputStream in2) throws IOException {
1127 try (ByteArrayOutputStream dst = new ByteArrayOutputStream();
1128 InputStream concatenated = new SequenceInputStream(in1, in2)) {
1129 concatenated.transferTo(dst);
1130 return new String(dst.toByteArray(), "UTF-8");
1131 }
1132 }
1133
1134 static class Result {
1135 final int ec;
1136 final String output;
1137
1138 private Result(int ec, String output) {
1139 this.ec = ec;
1140 this.output = output;
1141 }
1142 Result assertSuccess() {
1143 assertTrue(ec == 0, "Expected ec 0, got: ", ec, " , output [", output, "]");
1144 return this;
1145 }
1146 Result assertFailure() {
1147 assertTrue(ec != 0, "Expected ec != 0, got:", ec, " , output [", output, "]");
1148 return this;
1149 }
1150 Result resultChecker(Consumer<Result> r) { r.accept(this); return this; }
1151 }
1152
1153 static void assertTrue(boolean cond, Object ... failedArgs) {
1154 if (cond)
1155 return;
1156 StringBuilder sb = new StringBuilder();
1157 for (Object o : failedArgs)
1158 sb.append(o);
1159 org.testng.Assert.assertTrue(false, sb.toString());
1160 }
1161
1162 // Standalone entry point.
1163 public static void main(String[] args) throws Throwable {
1164 Basic test = new Basic();
1165 test.compileModules();
1166 for (Method m : Basic.class.getDeclaredMethods()) {
1167 if (m.getAnnotation(Test.class) != null) {
1168 System.out.println("Invoking " + m.getName());
1169 m.invoke(test);
1170 }
1171 }
1172 }
1173 }