28 * @modules |
28 * @modules |
29 * jdk.compiler/com.sun.tools.javac.api |
29 * jdk.compiler/com.sun.tools.javac.api |
30 * jdk.compiler/com.sun.tools.javac.main |
30 * jdk.compiler/com.sun.tools.javac.main |
31 * jdk.jdeps/com.sun.tools.javap |
31 * jdk.jdeps/com.sun.tools.javap |
32 * jdk.jlink/jdk.tools.jmod |
32 * jdk.jlink/jdk.tools.jmod |
33 * @build ToolBox ModuleTestBase |
33 * @build toolbox.ToolBox toolbox.JarTask toolbox.JavacTask ModuleTestBase |
34 * @run main ModulePathTest |
34 * @run main ModulePathTest |
35 */ |
35 */ |
36 |
36 |
37 import java.io.File; |
37 import java.io.File; |
38 import java.io.IOException; |
38 import java.io.IOException; |
39 import java.nio.file.Files; |
39 import java.nio.file.Files; |
40 import java.nio.file.Path; |
40 import java.nio.file.Path; |
41 |
41 |
|
42 import toolbox.JarTask; |
|
43 import toolbox.JavacTask; |
|
44 import toolbox.Task; |
|
45 import toolbox.ToolBox; |
|
46 |
42 public class ModulePathTest extends ModuleTestBase { |
47 public class ModulePathTest extends ModuleTestBase { |
43 |
48 |
44 public static final String PATH_SEP = File.pathSeparator; |
49 public static final String PATH_SEP = File.pathSeparator; |
45 |
50 |
46 public static void main(String... args) throws Exception { |
51 public static void main(String... args) throws Exception { |
51 @Test |
56 @Test |
52 void testNotExistsOnPath(Path base) throws Exception { |
57 void testNotExistsOnPath(Path base) throws Exception { |
53 Path src = base.resolve("src"); |
58 Path src = base.resolve("src"); |
54 tb.writeJavaFiles(src, "class C { }"); |
59 tb.writeJavaFiles(src, "class C { }"); |
55 |
60 |
56 String log = tb.new JavacTask(ToolBox.Mode.CMDLINE) |
61 String log = new JavacTask(tb, Task.Mode.CMDLINE) |
57 .options("-XDrawDiagnostics", |
62 .options("-XDrawDiagnostics", |
58 "-modulepath", "doesNotExist") |
63 "-modulepath", "doesNotExist") |
59 .files(findJavaFiles(src)) |
64 .files(findJavaFiles(src)) |
60 .run(ToolBox.Expect.FAIL) |
65 .run(Task.Expect.FAIL) |
61 .writeAll() |
66 .writeAll() |
62 .getOutput(ToolBox.OutputKind.DIRECT); |
67 .getOutput(Task.OutputKind.DIRECT); |
63 |
68 |
64 if (!log.contains("- compiler.err.illegal.argument.for.option: -modulepath, doesNotExist")) |
69 if (!log.contains("- compiler.err.illegal.argument.for.option: -modulepath, doesNotExist")) |
65 throw new Exception("expected output not found"); |
70 throw new Exception("expected output not found"); |
66 } |
71 } |
67 |
72 |
69 void testNotADirOnPath_1(Path base) throws Exception { |
74 void testNotADirOnPath_1(Path base) throws Exception { |
70 Path src = base.resolve("src"); |
75 Path src = base.resolve("src"); |
71 tb.writeJavaFiles(src, "class C { }"); |
76 tb.writeJavaFiles(src, "class C { }"); |
72 tb.writeFile("dummy.txt", ""); |
77 tb.writeFile("dummy.txt", ""); |
73 |
78 |
74 String log = tb.new JavacTask(ToolBox.Mode.CMDLINE) |
79 String log = new JavacTask(tb, Task.Mode.CMDLINE) |
75 .options("-XDrawDiagnostics", |
80 .options("-XDrawDiagnostics", |
76 "-modulepath", "dummy.txt") |
81 "-modulepath", "dummy.txt") |
77 .files(findJavaFiles(src)) |
82 .files(findJavaFiles(src)) |
78 .run(ToolBox.Expect.FAIL) |
83 .run(Task.Expect.FAIL) |
79 .writeAll() |
84 .writeAll() |
80 .getOutput(ToolBox.OutputKind.DIRECT); |
85 .getOutput(Task.OutputKind.DIRECT); |
81 |
86 |
82 if (!log.contains("- compiler.err.illegal.argument.for.option: -modulepath, dummy.txt")) |
87 if (!log.contains("- compiler.err.illegal.argument.for.option: -modulepath, dummy.txt")) |
83 throw new Exception("expected output not found"); |
88 throw new Exception("expected output not found"); |
84 } |
89 } |
85 |
90 |
87 void testNotADirOnPath_2(Path base) throws Exception { |
92 void testNotADirOnPath_2(Path base) throws Exception { |
88 Path src = base.resolve("src"); |
93 Path src = base.resolve("src"); |
89 tb.writeJavaFiles(src, "class C { }"); |
94 tb.writeJavaFiles(src, "class C { }"); |
90 tb.writeFile("dummy.jimage", ""); |
95 tb.writeFile("dummy.jimage", ""); |
91 |
96 |
92 String log = tb.new JavacTask(ToolBox.Mode.CMDLINE) |
97 String log = new JavacTask(tb, Task.Mode.CMDLINE) |
93 .options("-XDrawDiagnostics", |
98 .options("-XDrawDiagnostics", |
94 "-modulepath", "dummy.jimage") |
99 "-modulepath", "dummy.jimage") |
95 .files(findJavaFiles(src)) |
100 .files(findJavaFiles(src)) |
96 .run(ToolBox.Expect.FAIL) |
101 .run(Task.Expect.FAIL) |
97 .writeAll() |
102 .writeAll() |
98 .getOutput(ToolBox.OutputKind.DIRECT); |
103 .getOutput(Task.OutputKind.DIRECT); |
99 |
104 |
100 if (!log.contains("- compiler.err.illegal.argument.for.option: -modulepath, dummy.jimage")) |
105 if (!log.contains("- compiler.err.illegal.argument.for.option: -modulepath, dummy.jimage")) |
101 throw new Exception("expected output not found"); |
106 throw new Exception("expected output not found"); |
102 } |
107 } |
103 |
108 |
108 "module m1 { exports p; }", |
113 "module m1 { exports p; }", |
109 "package p; public class CC { }"); |
114 "package p; public class CC { }"); |
110 Path modClasses = base.resolve("modClasses"); |
115 Path modClasses = base.resolve("modClasses"); |
111 Files.createDirectories(modClasses); |
116 Files.createDirectories(modClasses); |
112 |
117 |
113 tb.new JavacTask(ToolBox.Mode.CMDLINE) |
118 new JavacTask(tb, Task.Mode.CMDLINE) |
114 .outdir(modClasses) |
119 .outdir(modClasses) |
115 .files(findJavaFiles(modSrc)) |
120 .files(findJavaFiles(modSrc)) |
116 .run() |
121 .run() |
117 .writeAll(); |
122 .writeAll(); |
118 |
123 |
121 "module m { requires m1 ; }", |
126 "module m { requires m1 ; }", |
122 "class C { }"); |
127 "class C { }"); |
123 Path classes = base.resolve("classes"); |
128 Path classes = base.resolve("classes"); |
124 Files.createDirectories(classes); |
129 Files.createDirectories(classes); |
125 |
130 |
126 tb.new JavacTask(ToolBox.Mode.CMDLINE) |
131 new JavacTask(tb, Task.Mode.CMDLINE) |
127 .outdir(classes) |
132 .outdir(classes) |
128 .options("-modulepath", modClasses.toString()) |
133 .options("-modulepath", modClasses.toString()) |
129 .files(findJavaFiles(src)) |
134 .files(findJavaFiles(src)) |
130 .run() |
135 .run() |
131 .writeAll(); |
136 .writeAll(); |
141 "module m { requires m1 ; }", |
146 "module m { requires m1 ; }", |
142 "class C { }"); |
147 "class C { }"); |
143 Path classes = base.resolve("classes"); |
148 Path classes = base.resolve("classes"); |
144 Files.createDirectories(classes); |
149 Files.createDirectories(classes); |
145 |
150 |
146 String log = tb.new JavacTask(ToolBox.Mode.CMDLINE) |
151 String log = new JavacTask(tb, Task.Mode.CMDLINE) |
147 .outdir(classes) |
152 .outdir(classes) |
148 .options("-XDrawDiagnostics", |
153 .options("-XDrawDiagnostics", |
149 "-modulepath", modClasses.toString()) |
154 "-modulepath", modClasses.toString()) |
150 .files(findJavaFiles(src)) |
155 .files(findJavaFiles(src)) |
151 .run(ToolBox.Expect.FAIL) |
156 .run(Task.Expect.FAIL) |
152 .writeAll() |
157 .writeAll() |
153 .getOutput(ToolBox.OutputKind.DIRECT); |
158 .getOutput(Task.OutputKind.DIRECT); |
154 |
159 |
155 if (!log.contains("- compiler.err.locn.bad.module-info: " + modClasses.toString())) |
160 if (!log.contains("- compiler.err.locn.bad.module-info: " + modClasses.toString())) |
156 throw new Exception("expected output not found"); |
161 throw new Exception("expected output not found"); |
157 } |
162 } |
158 |
163 |
162 tb.writeJavaFiles(jarSrc, |
167 tb.writeJavaFiles(jarSrc, |
163 "package p; public class CC { }"); |
168 "package p; public class CC { }"); |
164 Path jarClasses = base.resolve("jarClasses"); |
169 Path jarClasses = base.resolve("jarClasses"); |
165 Files.createDirectories(jarClasses); |
170 Files.createDirectories(jarClasses); |
166 |
171 |
167 tb.new JavacTask(ToolBox.Mode.CMDLINE) |
172 new JavacTask(tb, Task.Mode.CMDLINE) |
168 .outdir(jarClasses) |
173 .outdir(jarClasses) |
169 .files(findJavaFiles(jarSrc)) |
174 .files(findJavaFiles(jarSrc)) |
170 .run() |
175 .run() |
171 .writeAll(); |
176 .writeAll(); |
172 |
177 |
173 Path moduleJar = base.resolve("m1.jar"); |
178 Path moduleJar = base.resolve("m1.jar"); |
174 tb.new JarTask(moduleJar) |
179 new JarTask(tb, moduleJar) |
175 .baseDir(jarClasses) |
180 .baseDir(jarClasses) |
176 .files("p/CC.class") |
181 .files("p/CC.class") |
177 .run(); |
182 .run(); |
178 |
183 |
179 Path src = base.resolve("src"); |
184 Path src = base.resolve("src"); |
180 tb.writeJavaFiles(src, "class C { p.CC cc; }"); |
185 tb.writeJavaFiles(src, "class C { p.CC cc; }"); |
181 Path classes = base.resolve("classes"); |
186 Path classes = base.resolve("classes"); |
182 Files.createDirectories(classes); |
187 Files.createDirectories(classes); |
183 |
188 |
184 tb.new JavacTask(ToolBox.Mode.CMDLINE) |
189 new JavacTask(tb, Task.Mode.CMDLINE) |
185 .outdir(classes) |
190 .outdir(classes) |
186 .options("-modulepath", moduleJar.toString(), "-addmods", "m1") |
191 .options("-modulepath", moduleJar.toString(), "-addmods", "m1") |
187 .files(findJavaFiles(src)) |
192 .files(findJavaFiles(src)) |
188 .run() |
193 .run() |
189 .writeAll(); |
194 .writeAll(); |
196 "module m1 { exports p; }", |
201 "module m1 { exports p; }", |
197 "package p; public class CC { }"); |
202 "package p; public class CC { }"); |
198 Path jarClasses = base.resolve("jarClasses"); |
203 Path jarClasses = base.resolve("jarClasses"); |
199 Files.createDirectories(jarClasses); |
204 Files.createDirectories(jarClasses); |
200 |
205 |
201 tb.new JavacTask(ToolBox.Mode.CMDLINE) |
206 new JavacTask(tb, Task.Mode.CMDLINE) |
202 .outdir(jarClasses) |
207 .outdir(jarClasses) |
203 .files(findJavaFiles(jarSrc)) |
208 .files(findJavaFiles(jarSrc)) |
204 .run() |
209 .run() |
205 .writeAll(); |
210 .writeAll(); |
206 |
211 |
207 Path moduleJar = base.resolve("myModule.jar"); // deliberately not m1 |
212 Path moduleJar = base.resolve("myModule.jar"); // deliberately not m1 |
208 tb.new JarTask(moduleJar) |
213 new JarTask(tb, moduleJar) |
209 .baseDir(jarClasses) |
214 .baseDir(jarClasses) |
210 .files("module-info.class", "p/CC.class") |
215 .files("module-info.class", "p/CC.class") |
211 .run(); |
216 .run(); |
212 |
217 |
213 Path src = base.resolve("src"); |
218 Path src = base.resolve("src"); |
215 "module m { requires m1 ; }", |
220 "module m { requires m1 ; }", |
216 "class C { }"); |
221 "class C { }"); |
217 Path classes = base.resolve("classes"); |
222 Path classes = base.resolve("classes"); |
218 Files.createDirectories(classes); |
223 Files.createDirectories(classes); |
219 |
224 |
220 tb.new JavacTask(ToolBox.Mode.CMDLINE) |
225 new JavacTask(tb, Task.Mode.CMDLINE) |
221 .outdir(classes) |
226 .outdir(classes) |
222 .options("-modulepath", moduleJar.toString()) |
227 .options("-modulepath", moduleJar.toString()) |
223 .files(findJavaFiles(src)) |
228 .files(findJavaFiles(src)) |
224 .run() |
229 .run() |
225 .writeAll(); |
230 .writeAll(); |
229 void testBadJarOnPath(Path base) throws Exception { |
234 void testBadJarOnPath(Path base) throws Exception { |
230 Path src = base.resolve("src"); |
235 Path src = base.resolve("src"); |
231 tb.writeJavaFiles(src, "class C { }"); |
236 tb.writeJavaFiles(src, "class C { }"); |
232 tb.writeFile("dummy.jar", ""); |
237 tb.writeFile("dummy.jar", ""); |
233 |
238 |
234 String log = tb.new JavacTask(ToolBox.Mode.CMDLINE) |
239 String log = new JavacTask(tb, Task.Mode.CMDLINE) |
235 .options("-XDrawDiagnostics", |
240 .options("-XDrawDiagnostics", |
236 "-modulepath", "dummy.jar") |
241 "-modulepath", "dummy.jar") |
237 .files(findJavaFiles(src)) |
242 .files(findJavaFiles(src)) |
238 .run(ToolBox.Expect.FAIL) |
243 .run(Task.Expect.FAIL) |
239 .writeAll() |
244 .writeAll() |
240 .getOutput(ToolBox.OutputKind.DIRECT); |
245 .getOutput(Task.OutputKind.DIRECT); |
241 |
246 |
242 if (!log.contains("- compiler.err.locn.cant.read.file: dummy.jar")) |
247 if (!log.contains("- compiler.err.locn.cant.read.file: dummy.jar")) |
243 throw new Exception("expected output not found"); |
248 throw new Exception("expected output not found"); |
244 } |
249 } |
245 |
250 |
250 "module m1 { exports p; }", |
255 "module m1 { exports p; }", |
251 "package p; public class CC { }"); |
256 "package p; public class CC { }"); |
252 Path jmodClasses = base.resolve("jmodClasses"); |
257 Path jmodClasses = base.resolve("jmodClasses"); |
253 Files.createDirectories(jmodClasses); |
258 Files.createDirectories(jmodClasses); |
254 |
259 |
255 tb.new JavacTask(ToolBox.Mode.CMDLINE) |
260 new JavacTask(tb, Task.Mode.CMDLINE) |
256 .outdir(jmodClasses) |
261 .outdir(jmodClasses) |
257 .files(findJavaFiles(jmodSrc)) |
262 .files(findJavaFiles(jmodSrc)) |
258 .run() |
263 .run() |
259 .writeAll(); |
264 .writeAll(); |
260 |
265 |
266 "module m { requires m1 ; }", |
271 "module m { requires m1 ; }", |
267 "class C { }"); |
272 "class C { }"); |
268 Path classes = base.resolve("classes"); |
273 Path classes = base.resolve("classes"); |
269 Files.createDirectories(classes); |
274 Files.createDirectories(classes); |
270 |
275 |
271 tb.new JavacTask(ToolBox.Mode.CMDLINE) |
276 new JavacTask(tb, Task.Mode.CMDLINE) |
272 .outdir(classes) |
277 .outdir(classes) |
273 .options("-modulepath", jmod.toString()) |
278 .options("-modulepath", jmod.toString()) |
274 .files(findJavaFiles(src)) |
279 .files(findJavaFiles(src)) |
275 .run() |
280 .run() |
276 .writeAll(); |
281 .writeAll(); |
280 void testBadJModOnPath(Path base) throws Exception { |
285 void testBadJModOnPath(Path base) throws Exception { |
281 Path src = base.resolve("src"); |
286 Path src = base.resolve("src"); |
282 tb.writeJavaFiles(src, "class C { }"); |
287 tb.writeJavaFiles(src, "class C { }"); |
283 tb.writeFile("dummy.jmod", ""); |
288 tb.writeFile("dummy.jmod", ""); |
284 |
289 |
285 String log = tb.new JavacTask(ToolBox.Mode.CMDLINE) |
290 String log = new JavacTask(tb, Task.Mode.CMDLINE) |
286 .options("-XDrawDiagnostics", |
291 .options("-XDrawDiagnostics", |
287 "-modulepath", "dummy.jmod") |
292 "-modulepath", "dummy.jmod") |
288 .files(findJavaFiles(src)) |
293 .files(findJavaFiles(src)) |
289 .run(ToolBox.Expect.FAIL) |
294 .run(Task.Expect.FAIL) |
290 .writeAll() |
295 .writeAll() |
291 .getOutput(ToolBox.OutputKind.DIRECT); |
296 .getOutput(Task.OutputKind.DIRECT); |
292 |
297 |
293 if (!log.contains("- compiler.err.locn.cant.read.file: dummy.jmod")) |
298 if (!log.contains("- compiler.err.locn.cant.read.file: dummy.jmod")) |
294 throw new Exception("expected output not found"); |
299 throw new Exception("expected output not found"); |
295 } |
300 } |
296 |
301 |
300 new ModuleBuilder("m1").build(modules); |
305 new ModuleBuilder("m1").build(modules); |
301 |
306 |
302 Path src = base.resolve("src"); |
307 Path src = base.resolve("src"); |
303 tb.writeJavaFiles(src, "module m2 { requires m1; }", "class A { }"); |
308 tb.writeJavaFiles(src, "module m2 { requires m1; }", "class A { }"); |
304 |
309 |
305 tb.new JavacTask(ToolBox.Mode.CMDLINE) |
310 new JavacTask(tb, Task.Mode.CMDLINE) |
306 .options("-XDrawDiagnostics", |
311 .options("-XDrawDiagnostics", |
307 "-modulepath", modules + "/./../modules") |
312 "-modulepath", modules + "/./../modules") |
308 .files(findJavaFiles(src)) |
313 .files(findJavaFiles(src)) |
309 .run() |
314 .run() |
310 .writeAll(); |
315 .writeAll(); |
316 new ModuleBuilder("m1").build(modules); |
321 new ModuleBuilder("m1").build(modules); |
317 |
322 |
318 Path src = base.resolve("src"); |
323 Path src = base.resolve("src"); |
319 tb.writeJavaFiles(src, "module m2 { requires m1; }", "class A { }"); |
324 tb.writeJavaFiles(src, "module m2 { requires m1; }", "class A { }"); |
320 |
325 |
321 tb.new JavacTask(ToolBox.Mode.CMDLINE) |
326 new JavacTask(tb, Task.Mode.CMDLINE) |
322 .options("-XDrawDiagnostics", |
327 .options("-XDrawDiagnostics", |
323 "-modulepath", modules + "/./../modules" + PATH_SEP + modules) |
328 "-modulepath", modules + "/./../modules" + PATH_SEP + modules) |
324 .files(findJavaFiles(src)) |
329 .files(findJavaFiles(src)) |
325 .run() |
330 .run() |
326 .writeAll(); |
331 .writeAll(); |
332 new ModuleBuilder("m1").build(modules); |
337 new ModuleBuilder("m1").build(modules); |
333 |
338 |
334 Path src = base.resolve("src"); |
339 Path src = base.resolve("src"); |
335 tb.writeJavaFiles(src, "module m2 { requires m1; }", "class A { }"); |
340 tb.writeJavaFiles(src, "module m2 { requires m1; }", "class A { }"); |
336 |
341 |
337 tb.new JavacTask(ToolBox.Mode.CMDLINE) |
342 new JavacTask(tb, Task.Mode.CMDLINE) |
338 .options("-XDrawDiagnostics", |
343 .options("-XDrawDiagnostics", |
339 "-modulepath", modules.toString(), |
344 "-modulepath", modules.toString(), |
340 "-modulepath", modules.toString()) |
345 "-modulepath", modules.toString()) |
341 .files(findJavaFiles(src)) |
346 .files(findJavaFiles(src)) |
342 .run() |
347 .run() |
358 .build(deepModuleDir); |
363 .build(deepModuleDir); |
359 |
364 |
360 Path src = base.resolve("src"); |
365 Path src = base.resolve("src"); |
361 tb.writeJavaFiles(src, "module m2 { requires m1; }", " package p; class A { void main() { pkg2.E.class.getName(); } }"); |
366 tb.writeJavaFiles(src, "module m2 { requires m1; }", " package p; class A { void main() { pkg2.E.class.getName(); } }"); |
362 |
367 |
363 tb.new JavacTask(ToolBox.Mode.CMDLINE) |
368 new JavacTask(tb, Task.Mode.CMDLINE) |
364 .options("-XDrawDiagnostics", |
369 .options("-XDrawDiagnostics", |
365 "-modulepath", deepModuleDir + PATH_SEP + module) |
370 "-modulepath", deepModuleDir + PATH_SEP + module) |
366 .files(findJavaFiles(src)) |
371 .files(findJavaFiles(src)) |
367 .run() |
372 .run() |
368 .writeAll(); |
373 .writeAll(); |
388 |
393 |
389 Path src = base.resolve("src"); |
394 Path src = base.resolve("src"); |
390 tb.writeJavaFiles(src, "module m { requires m3; requires m2; requires m1; }", |
395 tb.writeJavaFiles(src, "module m { requires m3; requires m2; requires m1; }", |
391 "package p; class A { void main() { one.A.class.getName(); } }"); |
396 "package p; class A { void main() { one.A.class.getName(); } }"); |
392 |
397 |
393 tb.new JavacTask(ToolBox.Mode.CMDLINE) |
398 new JavacTask(tb, Task.Mode.CMDLINE) |
394 .options("-XDrawDiagnostics", |
399 .options("-XDrawDiagnostics", |
395 "-modulepath", modules.toString()) |
400 "-modulepath", modules.toString()) |
396 .files(findJavaFiles(src)) |
401 .files(findJavaFiles(src)) |
397 .run() |
402 .run() |
398 .writeAll(); |
403 .writeAll(); |
399 } |
404 } |
400 |
405 |
401 private void jar(Path dir, Path jar) throws IOException { |
406 private void jar(Path dir, Path jar) throws IOException { |
402 tb.new JarTask(jar) |
407 new JarTask(tb, jar) |
403 .baseDir(dir) |
408 .baseDir(dir) |
404 .files(".") |
409 .files(".") |
405 .run() |
410 .run() |
406 .writeAll(); |
411 .writeAll(); |
407 } |
412 } |