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 * @summary tests for multi-module mode compilation
27 * @library /tools/lib
28 * @modules
29 * jdk.compiler/com.sun.tools.javac.api
30 * jdk.compiler/com.sun.tools.javac.code
31 * jdk.compiler/com.sun.tools.javac.main
32 * jdk.compiler/com.sun.tools.javac.processing
33 * @build toolbox.ToolBox toolbox.JavacTask toolbox.ModuleBuilder ModuleTestBase
34 * @run main XModuleTest
35 */
36
37 import java.nio.file.Path;
38 import java.util.Arrays;
39 import java.util.List;
40 import java.util.Set;
41
42 import javax.annotation.processing.AbstractProcessor;
43 import javax.annotation.processing.RoundEnvironment;
44 import javax.annotation.processing.SupportedAnnotationTypes;
45 import javax.lang.model.SourceVersion;
46 import javax.lang.model.element.ModuleElement;
47 import javax.lang.model.element.TypeElement;
48 import javax.lang.model.util.Elements;
49
50 import com.sun.tools.javac.code.Symtab;
51 import com.sun.tools.javac.processing.JavacProcessingEnvironment;
52 import toolbox.JavacTask;
53 import toolbox.ModuleBuilder;
54 import toolbox.Task;
55 import toolbox.Task.Expect;
56
57 public class XModuleTest extends ModuleTestBase {
58
59 public static void main(String... args) throws Exception {
60 new XModuleTest().runTests();
61 }
62
63 @Test
64 public void testCorrectXModule(Path base) throws Exception {
65 //note: avoiding use of java.base, as that gets special handling on some places:
66 Path src = base.resolve("src");
67 tb.writeJavaFiles(src, "package javax.lang.model.element; public interface Extra extends Element { }");
68 Path classes = base.resolve("classes");
69 tb.createDirectories(classes);
70
71 String log = new JavacTask(tb)
72 .options("-Xmodule:java.compiler")
73 .outdir(classes)
74 .files(findJavaFiles(src))
75 .run()
76 .writeAll()
77 .getOutput(Task.OutputKind.DIRECT);
78
79 if (!log.isEmpty())
80 throw new Exception("expected output not found: " + log);
81 }
82
83 @Test
84 public void testSourcePath(Path base) throws Exception {
85 //note: avoiding use of java.base, as that gets special handling on some places:
86 Path src = base.resolve("src");
87 tb.writeJavaFiles(src, "package javax.lang.model.element; public interface Extra extends Element, Other { }", "package javax.lang.model.element; interface Other { }");
88 Path classes = base.resolve("classes");
89 tb.createDirectories(classes);
90
91 String log = new JavacTask(tb)
92 .options("-Xmodule:java.compiler", "-sourcepath", src.toString())
93 .outdir(classes)
94 .files(src.resolve("javax/lang/model/element/Extra.java"))
95 .run()
96 .writeAll()
97 .getOutput(Task.OutputKind.DIRECT);
98
99 if (!log.isEmpty())
100 throw new Exception("expected output not found: " + log);
101 }
102
103 @Test
104 public void testClassPath(Path base) throws Exception {
105 Path cpSrc = base.resolve("cpSrc");
106 tb.writeJavaFiles(cpSrc, "package p; public interface Other { }");
107 Path cpClasses = base.resolve("cpClasses");
108 tb.createDirectories(cpClasses);
109
110 String cpLog = new JavacTask(tb)
111 .outdir(cpClasses)
112 .files(findJavaFiles(cpSrc))
113 .run()
114 .writeAll()
115 .getOutput(Task.OutputKind.DIRECT);
116
117 if (!cpLog.isEmpty())
118 throw new Exception("expected output not found: " + cpLog);
119
120 Path src = base.resolve("src");
121 //note: avoiding use of java.base, as that gets special handling on some places:
122 tb.writeJavaFiles(src, "package javax.lang.model.element; public interface Extra extends Element, p.Other { }");
123 Path classes = base.resolve("classes");
124 tb.createDirectories(classes);
125
126 List<String> log = new JavacTask(tb)
127 .options("-Xmodule:java.compiler",
128 "--class-path", cpClasses.toString(),
129 "-XDrawDiagnostics")
130 .outdir(classes)
131 .files(src.resolve("javax/lang/model/element/Extra.java"))
132 .run(Expect.FAIL)
133 .writeAll()
134 .getOutputLines(Task.OutputKind.DIRECT);
135
136 List<String> expectedOut = Arrays.asList(
137 "Extra.java:1:76: compiler.err.doesnt.exist: p",
138 "1 error"
139 );
140
141 if (!expectedOut.equals(log))
142 throw new Exception("expected output not found: " + log);
143 }
144
145 @Test
146 public void testNoModuleInfoOnSourcePath(Path base) throws Exception {
147 //note: avoiding use of java.base, as that gets special handling on some places:
148 Path src = base.resolve("src");
149 tb.writeJavaFiles(src,
150 "module java.compiler {}",
151 "package javax.lang.model.element; public interface Extra { }");
152 Path classes = base.resolve("classes");
153 tb.createDirectories(classes);
154
155 List<String> log = new JavacTask(tb)
156 .options("-XDrawDiagnostics", "-Xmodule:java.compiler")
157 .outdir(classes)
158 .files(findJavaFiles(src))
159 .run(Task.Expect.FAIL)
160 .writeAll()
161 .getOutputLines(Task.OutputKind.DIRECT);
162
163 List<String> expected = Arrays.asList("Extra.java:1:1: compiler.err.module-info.with.xmodule.sourcepath",
164 "1 error");
165
166 if (!expected.equals(log))
167 throw new Exception("expected output not found: " + log);
168 }
169
170 @Test
171 public void testNoModuleInfoInClassOutput(Path base) throws Exception {
172 //note: avoiding use of java.base, as that gets special handling on some places:
173 Path srcMod = base.resolve("src-mod");
174 tb.writeJavaFiles(srcMod,
175 "module mod {}");
176 Path classes = base.resolve("classes");
177 tb.createDirectories(classes);
178
179 String logMod = new JavacTask(tb)
180 .options()
181 .outdir(classes)
182 .files(findJavaFiles(srcMod))
183 .run()
184 .writeAll()
185 .getOutput(Task.OutputKind.DIRECT);
186
187 if (!logMod.isEmpty())
188 throw new Exception("unexpected output found: " + logMod);
189
190 Path src = base.resolve("src");
191 tb.writeJavaFiles(src,
192 "package javax.lang.model.element; public interface Extra { }");
193 tb.createDirectories(classes);
194
195 List<String> log = new JavacTask(tb)
196 .options("-XDrawDiagnostics", "-Xmodule:java.compiler")
197 .outdir(classes)
198 .files(findJavaFiles(src))
199 .run(Task.Expect.FAIL)
200 .writeAll()
201 .getOutputLines(Task.OutputKind.DIRECT);
202
203 List<String> expected = Arrays.asList("Extra.java:1:1: compiler.err.module-info.with.xmodule.classpath",
204 "1 error");
205
206 if (!expected.equals(log))
207 throw new Exception("expected output not found: " + log);
208 }
209
210 @Test
211 public void testModuleSourcePathXModule(Path base) throws Exception {
212 //note: avoiding use of java.base, as that gets special handling on some places:
213 Path src = base.resolve("src");
214 tb.writeJavaFiles(src, "package javax.lang.model.element; public interface Extra extends Element { }");
215 Path classes = base.resolve("classes");
216 tb.createDirectories(classes);
217
218 List<String> log = new JavacTask(tb)
219 .options("-XDrawDiagnostics", "-Xmodule:java.compiler", "--module-source-path", src.toString())
220 .outdir(classes)
221 .files(findJavaFiles(src))
222 .run(Task.Expect.FAIL)
223 .writeAll()
224 .getOutputLines(Task.OutputKind.DIRECT);
225
226 List<String> expected = Arrays.asList("- compiler.err.xmodule.no.module.sourcepath");
227
228 if (!expected.equals(log))
229 throw new Exception("expected output not found: " + log);
230 }
231
232 @Test
233 public void testXModuleTooMany(Path base) throws Exception {
234 //note: avoiding use of java.base, as that gets special handling on some places:
235 Path src = base.resolve("src");
236 tb.writeJavaFiles(src, "package javax.lang.model.element; public interface Extra extends Element { }");
237 Path classes = base.resolve("classes");
238 tb.createDirectories(classes);
239
240 List<String> log = new JavacTask(tb, Task.Mode.CMDLINE)
241 .options("-XDrawDiagnostics", "-Xmodule:java.compiler", "-Xmodule:java.compiler")
242 .outdir(classes)
243 .files(findJavaFiles(src))
244 .run(Task.Expect.FAIL)
245 .writeAll()
246 .getOutputLines(Task.OutputKind.DIRECT);
247
248 List<String> expected = Arrays.asList("javac: option -Xmodule: can only be specified once",
249 "Usage: javac <options> <source files>",
250 "use --help for a list of possible options");
251
252 if (!expected.equals(log))
253 throw new Exception("expected output not found: " + log);
254 }
255
256 @Test
257 public void testWithModulePath(Path base) throws Exception {
258 Path modSrc = base.resolve("modSrc");
259 Path modules = base.resolve("modules");
260 new ModuleBuilder(tb, "m1")
261 .classes("package pkg1; public interface E { }")
262 .build(modSrc, modules);
263
264 Path src = base.resolve("src");
265 tb.writeJavaFiles(src, "package p; interface A extends pkg1.E { }");
266
267 new JavacTask(tb, Task.Mode.CMDLINE)
268 .options("--module-path", modules.toString(),
269 "-Xmodule:m1")
270 .files(findJavaFiles(src))
271 .run()
272 .writeAll();
273
274 //checks module bounds still exist
275 new ModuleBuilder(tb, "m2")
276 .classes("package pkg2; public interface D { }")
277 .build(modSrc, modules);
278
279 Path src2 = base.resolve("src2");
280 tb.writeJavaFiles(src2, "package p; interface A extends pkg2.D { }");
281
282 List<String> log = new JavacTask(tb, Task.Mode.CMDLINE)
283 .options("-XDrawDiagnostics",
284 "--module-path", modules.toString(),
285 "-Xmodule:m1")
286 .files(findJavaFiles(src2))
287 .run(Task.Expect.FAIL)
288 .writeAll()
289 .getOutputLines(Task.OutputKind.DIRECT);
290
291 List<String> expected = Arrays.asList("A.java:1:32: compiler.err.package.not.visible: pkg2, (compiler.misc.not.def.access.does.not.read: m1, pkg2, m2)",
292 "1 error");
293
294 if (!expected.equals(log))
295 throw new Exception("expected output not found: " + log);
296 }
297
298 @Test
299 public void testWithUpgradeModulePath(Path base) throws Exception {
300 Path modSrc = base.resolve("modSrc");
301 Path modules = base.resolve("modules");
302 new ModuleBuilder(tb, "m1")
303 .classes("package pkg1; public interface E { }")
304 .build(modSrc, modules);
305
306 Path upgrSrc = base.resolve("upgradeSrc");
307 Path upgrade = base.resolve("upgrade");
308 new ModuleBuilder(tb, "m1")
309 .classes("package pkg1; public interface D { }")
310 .build(upgrSrc, upgrade);
311
312 Path src = base.resolve("src");
313 tb.writeJavaFiles(src, "package p; interface A extends pkg1.D { }");
314
315 new JavacTask(tb, Task.Mode.CMDLINE)
316 .options("--module-path", modules.toString(),
317 "--upgrade-module-path", upgrade.toString(),
318 "-Xmodule:m1")
319 .files(findJavaFiles(src))
320 .run()
321 .writeAll();
322 }
323
324 @Test
325 public void testUnnamedIsolation(Path base) throws Exception {
326 //note: avoiding use of java.base, as that gets special handling on some places:
327 Path sourcePath = base.resolve("source-path");
328 tb.writeJavaFiles(sourcePath, "package src; public class Src {}");
329
330 Path classPathSrc = base.resolve("class-path-src");
331 tb.writeJavaFiles(classPathSrc, "package cp; public class CP { }");
332 Path classPath = base.resolve("classPath");
333 tb.createDirectories(classPath);
334
335 String cpLog = new JavacTask(tb)
336 .outdir(classPath)
337 .files(findJavaFiles(classPathSrc))
338 .run()
339 .writeAll()
340 .getOutput(Task.OutputKind.DIRECT);
341
342 if (!cpLog.isEmpty())
343 throw new Exception("expected output not found: " + cpLog);
344
345 Path modulePathSrc = base.resolve("module-path-src");
346 tb.writeJavaFiles(modulePathSrc,
347 "module m {}",
348 "package m; public class M {}");
349 Path modulePath = base.resolve("modulePath");
350 tb.createDirectories(modulePath.resolve("m"));
351
352 String modLog = new JavacTask(tb)
353 .outdir(modulePath.resolve("m"))
354 .files(findJavaFiles(modulePathSrc))
355 .run()
356 .writeAll()
357 .getOutput(Task.OutputKind.DIRECT);
358
359 if (!modLog.isEmpty())
360 throw new Exception("expected output not found: " + modLog);
361
362 Path src = base.resolve("src");
363 tb.writeJavaFiles(src, "package m; public class Extra { }");
364 Path classes = base.resolve("classes");
365 tb.createDirectories(classes);
366
367 String log = new JavacTask(tb)
368 .options("-Xmodule:m",
369 "--class-path", classPath.toString(),
370 "--source-path", sourcePath.toString(),
371 "--module-path", modulePath.toString(),
372 "--processor-path", System.getProperty("test.classes"),
373 "-XDaccessInternalAPI=true",
374 "-processor", CheckModuleContentProcessing.class.getName())
375 .outdir(classes)
376 .files(findJavaFiles(sourcePath))
377 .run()
378 .writeAll()
379 .getOutput(Task.OutputKind.DIRECT);
380
381 if (!log.isEmpty())
382 throw new Exception("expected output not found: " + log);
383 }
384
385 @SupportedAnnotationTypes("*")
386 public static final class CheckModuleContentProcessing extends AbstractProcessor {
387
388 @Override
389 public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
390 Symtab syms = Symtab.instance(((JavacProcessingEnvironment) processingEnv).getContext());
391 Elements elements = processingEnv.getElementUtils();
392 ModuleElement unnamedModule = syms.unnamedModule;
393 ModuleElement mModule = elements.getModuleElement("m");
394
395 assertNonNull("mModule found", mModule);
396 assertNonNull("src.Src from m", elements.getTypeElement(mModule, "src.Src"));
397 assertNull("cp.CP not from m", elements.getTypeElement(mModule, "cp.CP"));
398 assertNull("src.Src not from unnamed", elements.getTypeElement(unnamedModule, "src.Src"));
399 assertNonNull("cp.CP from unnamed", elements.getTypeElement(unnamedModule, "cp.CP"));
400
401 return false;
402 }
403
404 @Override
405 public SourceVersion getSupportedSourceVersion() {
406 return SourceVersion.latest();
407 }
408
409 private static void assertNonNull(String msg, Object val) {
410 if (val == null) {
411 throw new AssertionError(msg);
412 }
413 }
414
415 private static void assertNull(String msg, Object val) {
416 if (val != null) {
417 throw new AssertionError(msg);
418 }
419 }
420 }
421
422 }