63 import com.sun.tools.javac.code.Symtab; |
63 import com.sun.tools.javac.code.Symtab; |
64 import com.sun.tools.javac.model.JavacElements; |
64 import com.sun.tools.javac.model.JavacElements; |
65 import com.sun.tools.javac.processing.JavacProcessingEnvironment; |
65 import com.sun.tools.javac.processing.JavacProcessingEnvironment; |
66 import com.sun.tools.javac.util.Context; |
66 import com.sun.tools.javac.util.Context; |
67 |
67 |
|
68 import toolbox.JarTask; |
|
69 import toolbox.JavacTask; |
|
70 import toolbox.JavaTask; |
|
71 import toolbox.Task; |
|
72 import toolbox.ToolBox; |
|
73 |
68 public class AddLimitMods extends ModuleTestBase { |
74 public class AddLimitMods extends ModuleTestBase { |
69 |
75 |
70 public static void main(String... args) throws Exception { |
76 public static void main(String... args) throws Exception { |
71 AddLimitMods t = new AddLimitMods(); |
77 AddLimitMods t = new AddLimitMods(); |
72 t.runTests(); |
78 t.runTests(); |
94 |
100 |
95 Path modulePath = base.resolve("module-path"); |
101 Path modulePath = base.resolve("module-path"); |
96 |
102 |
97 Files.createDirectories(modulePath); |
103 Files.createDirectories(modulePath); |
98 |
104 |
99 tb.new JavacTask() |
105 new JavacTask(tb) |
100 .options("-modulesourcepath", moduleSrc.toString()) |
106 .options("-modulesourcepath", moduleSrc.toString()) |
101 .outdir(modulePath) |
107 .outdir(modulePath) |
102 .files(findJavaFiles(m3)) |
108 .files(findJavaFiles(m3)) |
103 .run() |
109 .run() |
104 .writeAll(); |
110 .writeAll(); |
105 |
111 |
106 tb.new JavacTask() |
112 new JavacTask(tb) |
107 .options("-modulesourcepath", moduleSrc.toString()) |
113 .options("-modulesourcepath", moduleSrc.toString()) |
108 .outdir(modulePath) |
114 .outdir(modulePath) |
109 .files(findJavaFiles(m2)) |
115 .files(findJavaFiles(m2)) |
110 .run() |
116 .run() |
111 .writeAll(); |
117 .writeAll(); |
112 |
118 |
113 //real test |
119 //real test |
114 tb.new JavacTask() |
120 new JavacTask(tb) |
115 .options("-modulepath", modulePath.toString(), |
121 .options("-modulepath", modulePath.toString(), |
116 "-XDshouldStopPolicyIfNoError=FLOW", |
122 "-XDshouldStopPolicyIfNoError=FLOW", |
117 "-limitmods", "java.base") |
123 "-limitmods", "java.base") |
118 .outdir(modulePath) |
124 .outdir(modulePath) |
119 .files(findJavaFiles(m1)) |
125 .files(findJavaFiles(m1)) |
120 .run(ToolBox.Expect.FAIL) |
126 .run(Task.Expect.FAIL) |
121 .writeAll(); |
127 .writeAll(); |
122 |
128 |
123 tb.new JavacTask() |
129 new JavacTask(tb) |
124 .options("-modulepath", modulePath.toString(), |
130 .options("-modulepath", modulePath.toString(), |
125 "-XDshouldStopPolicyIfNoError=FLOW", |
131 "-XDshouldStopPolicyIfNoError=FLOW", |
126 "-limitmods", "java.base", |
132 "-limitmods", "java.base", |
127 "-addmods", "m2") |
133 "-addmods", "m2") |
128 .outdir(modulePath) |
134 .outdir(modulePath) |
129 .files(findJavaFiles(m1)) |
135 .files(findJavaFiles(m1)) |
130 .run(ToolBox.Expect.FAIL) |
136 .run(Task.Expect.FAIL) |
131 .writeAll(); |
137 .writeAll(); |
132 |
138 |
133 tb.new JavacTask() |
139 new JavacTask(tb) |
134 .options("-modulepath", modulePath.toString(), |
140 .options("-modulepath", modulePath.toString(), |
135 "-XDshouldStopPolicyIfNoError=FLOW", |
141 "-XDshouldStopPolicyIfNoError=FLOW", |
136 "-limitmods", "java.base", |
142 "-limitmods", "java.base", |
137 "-addmods", "m2,m3") |
143 "-addmods", "m2,m3") |
138 .outdir(modulePath) |
144 .outdir(modulePath) |
139 .files(findJavaFiles(m1)) |
145 .files(findJavaFiles(m1)) |
140 .run() |
146 .run() |
141 .writeAll(); |
147 .writeAll(); |
142 |
148 |
143 tb.new JavacTask() |
149 new JavacTask(tb) |
144 .options("-modulepath", modulePath.toString(), |
150 .options("-modulepath", modulePath.toString(), |
145 "-XDshouldStopPolicyIfNoError=FLOW", |
151 "-XDshouldStopPolicyIfNoError=FLOW", |
146 "-limitmods", "m2") |
152 "-limitmods", "m2") |
147 .outdir(modulePath) |
153 .outdir(modulePath) |
148 .files(findJavaFiles(m1)) |
154 .files(findJavaFiles(m1)) |
149 .run() |
155 .run() |
150 .writeAll(); |
156 .writeAll(); |
151 |
157 |
152 tb.new JavacTask() |
158 new JavacTask(tb) |
153 .options("-modulepath", modulePath.toString(), |
159 .options("-modulepath", modulePath.toString(), |
154 "-XDshouldStopPolicyIfNoError=FLOW", |
160 "-XDshouldStopPolicyIfNoError=FLOW", |
155 "-limitmods", "m3") |
161 "-limitmods", "m3") |
156 .outdir(modulePath) |
162 .outdir(modulePath) |
157 .files(findJavaFiles(m1)) |
163 .files(findJavaFiles(m1)) |
158 .run(ToolBox.Expect.FAIL) |
164 .run(Task.Expect.FAIL) |
159 .writeAll(); |
165 .writeAll(); |
160 |
166 |
161 tb.new JavacTask() |
167 new JavacTask(tb) |
162 .options("-modulepath", modulePath.toString(), |
168 .options("-modulepath", modulePath.toString(), |
163 "-XDshouldStopPolicyIfNoError=FLOW", |
169 "-XDshouldStopPolicyIfNoError=FLOW", |
164 "-limitmods", "m3", |
170 "-limitmods", "m3", |
165 "-addmods", "m2") |
171 "-addmods", "m2") |
166 .outdir(modulePath) |
172 .outdir(modulePath) |
197 |
203 |
198 Path cpOut = base.resolve("cp-out"); |
204 Path cpOut = base.resolve("cp-out"); |
199 |
205 |
200 Files.createDirectories(cpOut); |
206 Files.createDirectories(cpOut); |
201 |
207 |
202 tb.new JavacTask() |
208 new JavacTask(tb) |
203 .options("-modulepath", modulePath.toString()) |
209 .options("-modulepath", modulePath.toString()) |
204 .outdir(cpOut) |
210 .outdir(cpOut) |
205 .files(findJavaFiles(cpSrc)) |
211 .files(findJavaFiles(cpSrc)) |
206 .run(ToolBox.Expect.FAIL) |
212 .run(Task.Expect.FAIL) |
207 .writeAll(); |
213 .writeAll(); |
208 |
214 |
209 tb.new JavacTask() |
215 new JavacTask(tb) |
210 .options("-modulepath", modulePath.toString(), |
216 .options("-modulepath", modulePath.toString(), |
211 "-addmods", "ALL-MODULE-PATH") |
217 "-addmods", "ALL-MODULE-PATH") |
212 .outdir(cpOut) |
218 .outdir(cpOut) |
213 .files(findJavaFiles(cpSrc)) |
219 .files(findJavaFiles(cpSrc)) |
214 .run() |
220 .run() |
217 List<String> actual; |
223 List<String> actual; |
218 List<String> expected = Arrays.asList( |
224 List<String> expected = Arrays.asList( |
219 "- compiler.err.addmods.all.module.path.invalid", |
225 "- compiler.err.addmods.all.module.path.invalid", |
220 "1 error"); |
226 "1 error"); |
221 |
227 |
222 actual = tb.new JavacTask() |
228 actual = new JavacTask(tb) |
223 .options("-modulesourcepath", moduleSrc.toString(), |
229 .options("-modulesourcepath", moduleSrc.toString(), |
224 "-XDrawDiagnostics", |
230 "-XDrawDiagnostics", |
225 "-addmods", "ALL-MODULE-PATH") |
231 "-addmods", "ALL-MODULE-PATH") |
226 .outdir(modulePath) |
232 .outdir(modulePath) |
227 .files(findJavaFiles(moduleSrc)) |
233 .files(findJavaFiles(moduleSrc)) |
228 .run(ToolBox.Expect.FAIL) |
234 .run(Task.Expect.FAIL) |
229 .writeAll() |
235 .writeAll() |
230 .getOutputLines(ToolBox.OutputKind.DIRECT); |
236 .getOutputLines(Task.OutputKind.DIRECT); |
231 |
237 |
232 if (!Objects.equals(actual, expected)) { |
238 if (!Objects.equals(actual, expected)) { |
233 throw new IllegalStateException("incorrect errors; actual=" + actual + "; expected=" + expected); |
239 throw new IllegalStateException("incorrect errors; actual=" + actual + "; expected=" + expected); |
234 } |
240 } |
235 |
241 |
236 actual = tb.new JavacTask() |
242 actual = new JavacTask(tb) |
237 .options("-Xmodule:java.base", |
243 .options("-Xmodule:java.base", |
238 "-XDrawDiagnostics", |
244 "-XDrawDiagnostics", |
239 "-addmods", "ALL-MODULE-PATH") |
245 "-addmods", "ALL-MODULE-PATH") |
240 .outdir(cpOut) |
246 .outdir(cpOut) |
241 .files(findJavaFiles(cpSrc)) |
247 .files(findJavaFiles(cpSrc)) |
242 .run(ToolBox.Expect.FAIL) |
248 .run(Task.Expect.FAIL) |
243 .writeAll() |
249 .writeAll() |
244 .getOutputLines(ToolBox.OutputKind.DIRECT); |
250 .getOutputLines(Task.OutputKind.DIRECT); |
245 |
251 |
246 if (!Objects.equals(actual, expected)) { |
252 if (!Objects.equals(actual, expected)) { |
247 throw new IllegalStateException("incorrect errors; actual=" + actual + "; expected=" + expected); |
253 throw new IllegalStateException("incorrect errors; actual=" + actual + "; expected=" + expected); |
248 } |
254 } |
249 |
255 |
250 actual = tb.new JavacTask(ToolBox.Mode.CMDLINE) |
256 actual = new JavacTask(tb, Task.Mode.CMDLINE) |
251 .options("-source", "8", "-target", "8", |
257 .options("-source", "8", "-target", "8", |
252 "-XDrawDiagnostics", |
258 "-XDrawDiagnostics", |
253 "-addmods", "ALL-MODULE-PATH") |
259 "-addmods", "ALL-MODULE-PATH") |
254 .outdir(cpOut) |
260 .outdir(cpOut) |
255 .files(findJavaFiles(cpSrc)) |
261 .files(findJavaFiles(cpSrc)) |
256 .run(ToolBox.Expect.FAIL) |
262 .run(Task.Expect.FAIL) |
257 .writeAll() |
263 .writeAll() |
258 .getOutputLines(ToolBox.OutputKind.DIRECT); |
264 .getOutputLines(Task.OutputKind.DIRECT); |
259 |
265 |
260 if (!actual.contains("javac: option -addmods not allowed with target 1.8")) { |
266 if (!actual.contains("javac: option -addmods not allowed with target 1.8")) { |
261 throw new IllegalStateException("incorrect errors; actual=" + actual); |
267 throw new IllegalStateException("incorrect errors; actual=" + actual); |
262 } |
268 } |
263 |
269 |
264 tb.writeJavaFiles(cpSrc, "module m1 {}"); |
270 tb.writeJavaFiles(cpSrc, "module m1 {}"); |
265 |
271 |
266 actual = tb.new JavacTask() |
272 actual = new JavacTask(tb) |
267 .options("-XDrawDiagnostics", |
273 .options("-XDrawDiagnostics", |
268 "-addmods", "ALL-MODULE-PATH") |
274 "-addmods", "ALL-MODULE-PATH") |
269 .outdir(cpOut) |
275 .outdir(cpOut) |
270 .files(findJavaFiles(cpSrc)) |
276 .files(findJavaFiles(cpSrc)) |
271 .run(ToolBox.Expect.FAIL) |
277 .run(Task.Expect.FAIL) |
272 .writeAll() |
278 .writeAll() |
273 .getOutputLines(ToolBox.OutputKind.DIRECT); |
279 .getOutputLines(Task.OutputKind.DIRECT); |
274 |
280 |
275 if (!Objects.equals(actual, expected)) { |
281 if (!Objects.equals(actual, expected)) { |
276 throw new IllegalStateException("incorrect errors; actual=" + actual + "; expected=" + expected); |
282 throw new IllegalStateException("incorrect errors; actual=" + actual + "; expected=" + expected); |
277 } |
283 } |
278 } |
284 } |
285 tb.writeJavaFiles(classpathSrc, |
291 tb.writeJavaFiles(classpathSrc, |
286 generateCheckAccessibleClass("cp.CP")); |
292 generateCheckAccessibleClass("cp.CP")); |
287 |
293 |
288 Files.createDirectories(classpathOut); |
294 Files.createDirectories(classpathOut); |
289 |
295 |
290 tb.new JavacTask() |
296 new JavacTask(tb) |
291 .outdir(classpathOut) |
297 .outdir(classpathOut) |
292 .files(findJavaFiles(classpathSrc)) |
298 .files(findJavaFiles(classpathSrc)) |
293 .run() |
299 .run() |
294 .writeAll() |
300 .writeAll() |
295 .getOutput(ToolBox.OutputKind.DIRECT); |
301 .getOutput(Task.OutputKind.DIRECT); |
296 |
302 |
297 Path automaticSrc = base.resolve("automatic-src"); |
303 Path automaticSrc = base.resolve("automatic-src"); |
298 Path automaticOut = base.resolve("automatic-out"); |
304 Path automaticOut = base.resolve("automatic-out"); |
299 |
305 |
300 tb.writeJavaFiles(automaticSrc, |
306 tb.writeJavaFiles(automaticSrc, |
301 generateCheckAccessibleClass("automatic.Automatic")); |
307 generateCheckAccessibleClass("automatic.Automatic")); |
302 |
308 |
303 Files.createDirectories(automaticOut); |
309 Files.createDirectories(automaticOut); |
304 |
310 |
305 tb.new JavacTask() |
311 new JavacTask(tb) |
306 .outdir(automaticOut) |
312 .outdir(automaticOut) |
307 .files(findJavaFiles(automaticSrc)) |
313 .files(findJavaFiles(automaticSrc)) |
308 .run() |
314 .run() |
309 .writeAll() |
315 .writeAll() |
310 .getOutput(ToolBox.OutputKind.DIRECT); |
316 .getOutput(Task.OutputKind.DIRECT); |
311 |
317 |
312 Path modulePath = base.resolve("module-path"); |
318 Path modulePath = base.resolve("module-path"); |
313 |
319 |
314 Files.createDirectories(modulePath); |
320 Files.createDirectories(modulePath); |
315 |
321 |
316 Path automaticJar = modulePath.resolve("automatic.jar"); |
322 Path automaticJar = modulePath.resolve("automatic.jar"); |
317 |
323 |
318 tb.new JarTask(automaticJar) |
324 new JarTask(tb, automaticJar) |
319 .baseDir(automaticOut) |
325 .baseDir(automaticOut) |
320 .files("automatic/Automatic.class") |
326 .files("automatic/Automatic.class") |
321 .run(); |
327 .run(); |
322 |
328 |
323 Path moduleSrc = base.resolve("module-src"); |
329 Path moduleSrc = base.resolve("module-src"); |
325 |
331 |
326 tb.writeJavaFiles(m1, |
332 tb.writeJavaFiles(m1, |
327 "module m1 { exports api; }", |
333 "module m1 { exports api; }", |
328 "package api; public class Api { public void test() { } }"); |
334 "package api; public class Api { public void test() { } }"); |
329 |
335 |
330 tb.new JavacTask() |
336 new JavacTask(tb) |
331 .options("-modulesourcepath", moduleSrc.toString()) |
337 .options("-modulesourcepath", moduleSrc.toString()) |
332 .outdir(modulePath) |
338 .outdir(modulePath) |
333 .files(findJavaFiles(moduleSrc)) |
339 .files(findJavaFiles(moduleSrc)) |
334 .run() |
340 .run() |
335 .writeAll() |
341 .writeAll() |
336 .getOutput(ToolBox.OutputKind.DIRECT); |
342 .getOutput(Task.OutputKind.DIRECT); |
337 |
343 |
338 int index = 0; |
344 int index = 0; |
339 |
345 |
340 for (String moduleInfo : MODULE_INFO_VARIANTS) { |
346 for (String moduleInfo : MODULE_INFO_VARIANTS) { |
341 for (String[] options : OPTIONS_VARIANTS) { |
347 for (String[] options : OPTIONS_VARIANTS) { |
367 testClassNamed.append(" }\n" + |
373 testClassNamed.append(" }\n" + |
368 "}"); |
374 "}"); |
369 |
375 |
370 tb.writeJavaFiles(m2Runtime, moduleInfo, testClassNamed.toString()); |
376 tb.writeJavaFiles(m2Runtime, moduleInfo, testClassNamed.toString()); |
371 |
377 |
372 tb.new JavacTask() |
378 new JavacTask(tb) |
373 .options("-modulepath", modulePath.toString()) |
379 .options("-modulepath", modulePath.toString()) |
374 .outdir(out) |
380 .outdir(out) |
375 .files(findJavaFiles(m2Runtime)) |
381 .files(findJavaFiles(m2Runtime)) |
376 .run() |
382 .run() |
377 .writeAll(); |
383 .writeAll(); |
378 |
384 |
379 boolean success; |
385 boolean success; |
380 String output; |
386 String output; |
381 |
387 |
382 try { |
388 try { |
383 output = tb.new JavaTask() |
389 output = new JavaTask(tb) |
384 .vmOptions(augmentOptions(options, |
390 .vmOptions(augmentOptions(options, |
385 Collections.emptyList(), |
391 Collections.emptyList(), |
386 "-modulepath", modulePath.toString() + File.pathSeparator + out.getParent().toString(), |
392 "-modulepath", modulePath.toString() + File.pathSeparator + out.getParent().toString(), |
387 "-classpath", classpathOut.toString(), |
393 "-classpath", classpathOut.toString(), |
388 "-XaddReads:m2=ALL-UNNAMED,m2=automatic", |
394 "-XaddReads:m2=ALL-UNNAMED,m2=automatic", |
389 "-m", "m2/test.Test")) |
395 "-m", "m2/test.Test")) |
390 .run() |
396 .run() |
391 .writeAll() |
397 .writeAll() |
392 .getOutput(ToolBox.OutputKind.STDERR); |
398 .getOutput(Task.OutputKind.STDERR); |
393 |
399 |
394 success = true; |
400 success = true; |
395 } catch (ToolBox.TaskError err) { |
401 } catch (Task.TaskError err) { |
396 success = false; |
402 success = false; |
397 output = ""; |
403 output = ""; |
398 } |
404 } |
399 |
405 |
400 Path m2 = base.resolve(String.valueOf(index)).resolve("m2"); |
406 Path m2 = base.resolve(String.valueOf(index)).resolve("m2"); |
408 "-processorpath", System.getProperty("test.class.path"), |
414 "-processorpath", System.getProperty("test.class.path"), |
409 "-processor", CheckVisibleModule.class.getName(), |
415 "-processor", CheckVisibleModule.class.getName(), |
410 "-Aoutput=" + output, |
416 "-Aoutput=" + output, |
411 "-XDaccessInternalAPI=true" |
417 "-XDaccessInternalAPI=true" |
412 ) : Collections.emptyList(); |
418 ) : Collections.emptyList(); |
413 tb.new JavacTask() |
419 new JavacTask(tb) |
414 .options(augmentOptions(options, |
420 .options(augmentOptions(options, |
415 auxOptions, |
421 auxOptions, |
416 "-modulepath", modulePath.toString(), |
422 "-modulepath", modulePath.toString(), |
417 "-classpath", classpathOut.toString(), |
423 "-classpath", classpathOut.toString(), |
418 "-XDshouldStopPolicyIfNoError=FLOW")) |
424 "-XDshouldStopPolicyIfNoError=FLOW")) |
419 .outdir(modulePath) |
425 .outdir(modulePath) |
420 .files(findJavaFiles(m2)) |
426 .files(findJavaFiles(m2)) |
421 .run(success ? ToolBox.Expect.SUCCESS : ToolBox.Expect.FAIL) |
427 .run(success ? Task.Expect.SUCCESS : Task.Expect.FAIL) |
422 .writeAll(); |
428 .writeAll(); |
423 } |
429 } |
424 } |
430 } |
425 } |
431 } |
426 |
432 |