1 /**
2 * Copyright (c) 2015, 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 * @summary Negative tests for jlink
27 * @bug 8130861
28 * @author Andrei Eremeev
29 * @library ../lib
30 * @modules java.base/jdk.internal.jimage
31 * java.base/jdk.internal.module
32 * jdk.jdeps/com.sun.tools.classfile
33 * jdk.jlink/jdk.tools.jlink
34 * jdk.jlink/jdk.tools.jlink.internal
35 * jdk.jlink/jdk.tools.jmod
36 * jdk.jlink/jdk.tools.jimage
37 * jdk.compiler
38 * @build tests.*
39 * @run testng JLinkNegativeTest
40 */
41
42 import java.io.IOException;
43 import java.io.OutputStream;
44 import java.lang.module.ModuleDescriptor;
45 import java.nio.file.FileVisitResult;
46 import java.nio.file.Files;
47 import java.nio.file.Path;
48 import java.nio.file.Paths;
49 import java.nio.file.SimpleFileVisitor;
50 import java.nio.file.attribute.BasicFileAttributes;
51 import java.util.Arrays;
52 import java.util.Collections;
53 import java.util.List;
54
55 import jdk.internal.module.ModuleInfoWriter;
56 import org.testng.SkipException;
57 import org.testng.annotations.BeforeClass;
58 import org.testng.annotations.Test;
59 import tests.Helper;
60 import tests.JImageGenerator;
61 import tests.JImageGenerator.InMemoryFile;
62 import tests.Result;
63
64 @Test
65 public class JLinkNegativeTest {
66
67 private Helper helper;
68
69 @BeforeClass
70 public void setUp() throws IOException {
71 helper = Helper.newHelper();
72 if (helper == null) {
73 throw new SkipException("Not run");
74 }
75 helper.generateDefaultModules();
76 }
77
78 private void deleteDirectory(Path dir) throws IOException {
79 Files.walkFileTree(dir, new SimpleFileVisitor<Path>() {
80 @Override
81 public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
82 Files.delete(file);
83 return FileVisitResult.CONTINUE;
84 }
85
86 @Override
87 public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
88 Files.delete(dir);
89 return FileVisitResult.CONTINUE;
90 }
91 });
92 }
93
94 public void testModuleNotExist() {
95 helper.generateDefaultImage("failure1").assertFailure("Error: Module failure1 not found");
96 }
97
98 public void testNotExistInAddMods() {
99 // cannot find jmod from --addmods
100 JImageGenerator.getJLinkTask()
101 .modulePath(".")
102 .addMods("not_exist")
103 .output(helper.getImageDir().resolve("failure2"))
104 .call().assertFailure("Error: Module not_exist not found");
105 }
106
107 public void test() throws IOException {
108 helper.generateDefaultJModule("failure3");
109 Path image = helper.generateDefaultImage("failure3").assertSuccess();
110 JImageGenerator.getJLinkTask()
111 .modulePath(helper.defaultModulePath())
112 .output(image)
113 .addMods("leaf1")
114 .limitMods("leaf1")
115 .call().assertFailure("Error: not empty: .*failure3.image(\n|\r|.)*");
116 }
117
118 public void testOutputIsFile() throws IOException {
119 // output == file
120 Path image = helper.createNewImageDir("failure4");
121 Files.createFile(image);
122 JImageGenerator.getJLinkTask()
123 .modulePath(helper.defaultModulePath())
124 .output(image)
125 .call().assertFailure("Error: file already exists: .*failure4.image(\n|\r|.)*");
126 }
127
128 public void testModuleNotFound() {
129 // limit module is not found
130 Path imageFile = helper.createNewImageDir("test");
131 JImageGenerator.getJLinkTask()
132 .output(imageFile)
133 .addMods("leaf1")
134 .limitMods("leaf1")
135 .limitMods("failure5")
136 .modulePath(helper.defaultModulePath())
137 .call().assertFailure("Error: Module failure5 not found");
138 }
139
140 public void testAddedModuleIsFiltered() {
141 // added module is filtered out
142 Path imageFile = helper.createNewImageDir("test");
143 JImageGenerator.getJLinkTask()
144 .output(imageFile)
145 .addMods("leaf1")
146 .limitMods("leaf2")
147 .modulePath(helper.defaultModulePath())
148 .call().assertFailure("Error: Module leaf1 not found");
149 }
150
151 public void testJmodIsDir() throws IOException {
152 Path imageFile = helper.createNewImageDir("test");
153 Path dirJmod = helper.createNewJmodFile("dir");
154 Files.createDirectory(dirJmod);
155 try {
156 JImageGenerator.getJLinkTask()
157 .output(imageFile)
158 .addMods("dir")
159 .modulePath(helper.defaultModulePath())
160 .call().assertFailure("Error: Module dir not found");
161 } finally {
162 deleteDirectory(dirJmod);
163 }
164 }
165
166 public void testJarIsDir() throws IOException {
167 Path imageFile = helper.createNewImageDir("test");
168 Path dirJar = helper.createNewJarFile("dir");
169 Files.createDirectory(dirJar);
170 try {
171 JImageGenerator.getJLinkTask()
172 .output(imageFile)
173 .addMods("dir")
174 .modulePath(helper.defaultModulePath())
175 .call().assertFailure("Error: Module dir not found");
176 } finally {
177 deleteDirectory(dirJar);
178 }
179 }
180
181 public void testMalformedJar() throws IOException {
182 Path imageFile = helper.createNewImageDir("test");
183 Path jar = helper.createNewJarFile("not_zip");
184 Files.createFile(jar);
185 try {
186 JImageGenerator.getJLinkTask()
187 .output(imageFile)
188 .addMods("not_zip")
189 .modulePath(helper.defaultModulePath())
190 .call().assertFailure("Error: java.util.zip.ZipException: zip file is empty");
191 } finally {
192 deleteDirectory(jar);
193 }
194 }
195
196 public void testMalformedJmod() throws IOException {
197 Path imageFile = helper.createNewImageDir("test");
198 Path jmod = helper.createNewJmodFile("not_zip");
199 Files.createFile(jmod);
200 try {
201 JImageGenerator.getJLinkTask()
202 .output(imageFile)
203 .addMods("not_zip")
204 .modulePath(helper.defaultModulePath())
205 .call().assertFailure("Error: java.util.zip.ZipException: zip file is empty");
206 } finally {
207 deleteDirectory(jmod);
208 }
209 }
210
211 public void testAddDefaultPackage() throws IOException {
212 String moduleName = "hacked1";
213 Path module = helper.generateModuleCompiledClasses(helper.getJmodSrcDir(), helper.getJmodClassesDir(),
214 moduleName, Arrays.asList("hacked1.Main", "A", "B"), "leaf1");
215 JImageGenerator
216 .getJModTask()
217 .addClassPath(module)
218 .jmod(helper.getJmodDir().resolve(moduleName + ".jmod"))
219 .create().assertSuccess();
220 Path image = helper.generateDefaultImage(moduleName).assertSuccess();
221 helper.checkImage(image, moduleName, null, null);
222 }
223
224 public void testAddSomeTopLevelFiles() throws IOException {
225 String moduleName = "hacked2";
226 Path module = helper.generateModuleCompiledClasses(helper.getJmodSrcDir(), helper.getJmodClassesDir(),
227 moduleName);
228 Files.createFile(module.resolve("top-level-file"));
229 Path jmod = JImageGenerator
230 .getJModTask()
231 .addClassPath(module)
232 .jmod(helper.getJmodDir().resolve(moduleName + ".jmod"))
233 .create().assertSuccess();
234 try {
235 Path image = helper.generateDefaultImage(moduleName).assertSuccess();
236 helper.checkImage(image, moduleName, null, null);
237 } finally {
238 deleteDirectory(jmod);
239 }
240 }
241
242 public void testAddNonStandardSection() throws IOException {
243 String moduleName = "hacked3";
244 Path module = helper.generateDefaultJModule(moduleName).assertSuccess();
245 JImageGenerator.addFiles(module, new InMemoryFile("unknown/A.class", new byte[0]));
246 try {
247 Result result = helper.generateDefaultImage(moduleName);
248 if (result.getExitCode() != 4) {
249 throw new AssertionError("Crash expected");
250 }
251 if (!result.getMessage().contains("java.lang.InternalError: unexpected entry: unknown")) {
252 System.err.println(result.getMessage());
253 throw new AssertionError("InternalError expected");
254 }
255 } finally {
256 deleteDirectory(module);
257 }
258 }
259
260 @Test(enabled = false)
261 public void testSectionsAreFiles() throws IOException {
262 String moduleName = "module";
263 Path jmod = helper.generateDefaultJModule(moduleName).assertSuccess();
264 JImageGenerator.addFiles(jmod,
265 new InMemoryFile("/native", new byte[0]),
266 new InMemoryFile("/conf", new byte[0]),
267 new InMemoryFile("/bin", new byte[0]));
268 Path image = helper.generateDefaultImage(moduleName).assertSuccess();
269 helper.checkImage(image, moduleName, null, null);
270 }
271
272 public void testDuplicateModule1() throws IOException {
273 String moduleName1 = "dupRes1Jmod1";
274 String moduleName2 = "dupRes1Jmod2";
275 List<String> classNames = Arrays.asList("java.A", "javax.B");
276 Path module1 = helper.generateModuleCompiledClasses(
277 helper.getJmodSrcDir(), helper.getJmodClassesDir(), moduleName1, classNames);
278 Path module2 = helper.generateModuleCompiledClasses(
279 helper.getJmodSrcDir(), helper.getJmodClassesDir(), moduleName2, classNames);
280
281 try (OutputStream out = Files.newOutputStream(module2.resolve("module-info.class"))) {
282 ModuleInfoWriter.write(new ModuleDescriptor.Builder(moduleName1)
283 .requires("java.base").build(), out);
284 }
285
286 Path jmod1 = JImageGenerator.getJModTask()
287 .addClassPath(module1)
288 .jmod(helper.createNewJmodFile(moduleName1))
289 .create()
290 .assertSuccess();
291 Path jmod2 = JImageGenerator.getJModTask()
292 .addClassPath(module2)
293 .jmod(helper.createNewJmodFile(moduleName2))
294 .create()
295 .assertSuccess();
296 try {
297 helper.generateDefaultImage(moduleName1)
298 .assertFailure("Error: Two versions of module dupRes1Jmod1 found in");
299 } finally {
300 deleteDirectory(jmod1);
301 deleteDirectory(jmod2);
302 }
303 }
304
305 public void testDuplicateModule2() throws IOException {
306 String moduleName = "dupRes2Jmod";
307 List<String> classNames = Arrays.asList("java.A", "javax.B");
308 Path module1 = helper.generateModuleCompiledClasses(
309 helper.getJmodSrcDir(), helper.getJmodClassesDir(), moduleName, classNames);
310 Path module2 = helper.generateModuleCompiledClasses(
311 helper.getJarSrcDir(), helper.getJarClassesDir(), moduleName, classNames);
312
313 Path jmod = JImageGenerator.getJModTask()
314 .addClassPath(module1)
315 .jmod(helper.createNewJmodFile(moduleName))
316 .create()
317 .assertSuccess();
318 Path jar = JImageGenerator.createJarFile(helper.getJarDir().resolve(moduleName + ".jar"), module2);
319 Path newJar = helper.getJmodDir().resolve(jar.getFileName());
320 Files.move(jar, newJar);
321 try {
322 helper.generateDefaultImage(moduleName)
323 .assertFailure("Error: Two versions of module dupRes2Jmod found in");
324 } finally {
325 deleteDirectory(jmod);
326 deleteDirectory(newJar);
327 }
328 }
329
330 public void testDuplicateModule3() throws IOException {
331 String moduleName1 = "dupRes3Jar1";
332 String moduleName2 = "dupRes3Jar2";
333 List<String> classNames = Arrays.asList("java.A", "javax.B");
334 Path module1 = helper.generateModuleCompiledClasses(
335 helper.getJarSrcDir(), helper.getJarClassesDir(), moduleName1, classNames);
336 Path module2 = helper.generateModuleCompiledClasses(
337 helper.getJarSrcDir(), helper.getJarClassesDir(), moduleName2, classNames);
338
339 try (OutputStream out = Files.newOutputStream(module2.resolve("module-info.class"))) {
340 ModuleInfoWriter.write(new ModuleDescriptor.Builder(moduleName1)
341 .requires("java.base").build(), out);
342 }
343
344 Path jar1 = JImageGenerator.createJarFile(helper.getJarDir().resolve(moduleName1 + ".jar"), module1);
345 Path jar2 = JImageGenerator.createJarFile(helper.getJarDir().resolve(moduleName2 + ".jar"), module2);
346 try {
347 helper.generateDefaultImage(moduleName1)
348 .assertFailure("Error: Two versions of module dupRes3Jar1 found in");
349 } finally {
350 deleteDirectory(jar1);
351 deleteDirectory(jar2);
352 }
353 }
354
355 public void testCustomImageBuilderNotFound() throws IOException {
356 String builderName = "not-found-image-builder";
357 JImageGenerator.getJLinkTask()
358 .option("--image-builder")
359 .option("not-found-image-builder")
360 .modulePath(helper.defaultModulePath())
361 .output(helper.createNewImageDir("leaf1"))
362 .addMods("leaf1")
363 .call().assertFailure("Error: Image builder not found for " + builderName);
364 }
365 }