26 * @summary test module/package conflicts |
26 * @summary test module/package conflicts |
27 * @library /tools/lib |
27 * @library /tools/lib |
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 * @build toolbox.ToolBox toolbox.JavacTask ModuleTestBase |
32 * @build ToolBox ModuleTestBase |
|
33 * @run main PackageConflictTest |
32 * @run main PackageConflictTest |
34 */ |
33 */ |
35 |
34 |
36 import java.nio.file.Files; |
35 import java.nio.file.Files; |
37 import java.nio.file.Path; |
36 import java.nio.file.Path; |
38 import java.util.Arrays; |
37 import java.util.Arrays; |
39 import java.util.List; |
38 import java.util.List; |
|
39 |
|
40 import toolbox.JavacTask; |
|
41 import toolbox.Task; |
|
42 import toolbox.ToolBox; |
40 |
43 |
41 public class PackageConflictTest extends ModuleTestBase { |
44 public class PackageConflictTest extends ModuleTestBase { |
42 public static void main(String... args) throws Exception { |
45 public static void main(String... args) throws Exception { |
43 PackageConflictTest t = new PackageConflictTest(); |
46 PackageConflictTest t = new PackageConflictTest(); |
44 t.runTests(); |
47 t.runTests(); |
50 tb.writeJavaFiles(src, |
53 tb.writeJavaFiles(src, |
51 "package java.util; public class MyList { }"); |
54 "package java.util; public class MyList { }"); |
52 Path classes = base.resolve("classes"); |
55 Path classes = base.resolve("classes"); |
53 Files.createDirectories(classes); |
56 Files.createDirectories(classes); |
54 |
57 |
55 String log = tb.new JavacTask() |
58 String log = new JavacTask(tb) |
56 .options("-XDrawDiagnostics") |
59 .options("-XDrawDiagnostics") |
57 .outdir(classes) |
60 .outdir(classes) |
58 .files(findJavaFiles(src)) |
61 .files(findJavaFiles(src)) |
59 .run(ToolBox.Expect.FAIL) |
62 .run(Task.Expect.FAIL) |
60 .writeAll() |
63 .writeAll() |
61 .getOutput(ToolBox.OutputKind.DIRECT); |
64 .getOutput(Task.OutputKind.DIRECT); |
62 |
65 |
63 if (!log.contains("MyList.java:1:1: compiler.err.package.in.other.module: java.base")) |
66 if (!log.contains("MyList.java:1:1: compiler.err.package.in.other.module: java.base")) |
64 throw new Exception("expected output not found"); |
67 throw new Exception("expected output not found"); |
65 } |
68 } |
66 |
69 |
75 "module m2 { }", |
78 "module m2 { }", |
76 "package test; public class B { }"); |
79 "package test; public class B { }"); |
77 Path classes = base.resolve("classes"); |
80 Path classes = base.resolve("classes"); |
78 Files.createDirectories(classes); |
81 Files.createDirectories(classes); |
79 |
82 |
80 tb.new JavacTask() |
83 new JavacTask(tb) |
81 .options("-Werror", "-modulesourcepath", base.toString()) |
84 .options("-Werror", "-modulesourcepath", base.toString()) |
82 .outdir(classes) |
85 .outdir(classes) |
83 .files(findJavaFiles(base)) |
86 .files(findJavaFiles(base)) |
84 .run() |
87 .run() |
85 .writeAll(); |
88 .writeAll(); |
100 "module m3 { requires m1; requires m2; }", |
103 "module m3 { requires m1; requires m2; }", |
101 "package impl; public class Impl { }"); |
104 "package impl; public class Impl { }"); |
102 Path classes = base.resolve("classes"); |
105 Path classes = base.resolve("classes"); |
103 Files.createDirectories(classes); |
106 Files.createDirectories(classes); |
104 |
107 |
105 List<String> log = tb.new JavacTask() |
108 List<String> log = new JavacTask(tb) |
106 .options("-XDrawDiagnostics", "-modulesourcepath", base.toString()) |
109 .options("-XDrawDiagnostics", "-modulesourcepath", base.toString()) |
107 .outdir(classes) |
110 .outdir(classes) |
108 .files(findJavaFiles(base)) |
111 .files(findJavaFiles(base)) |
109 .run(ToolBox.Expect.FAIL) |
112 .run(Task.Expect.FAIL) |
110 .writeAll() |
113 .writeAll() |
111 .getOutputLines(ToolBox.OutputKind.DIRECT); |
114 .getOutputLines(Task.OutputKind.DIRECT); |
112 |
115 |
113 List<String> expected = |
116 List<String> expected = |
114 Arrays.asList("module-info.java:1:1: compiler.err.package.clash.from.requires: m3, test, m1, m2", |
117 Arrays.asList("module-info.java:1:1: compiler.err.package.clash.from.requires: m3, test, m1, m2", |
115 "1 error"); |
118 "1 error"); |
116 |
119 |
129 new ModuleBuilder("M") |
132 new ModuleBuilder("M") |
130 .requires("N") |
133 .requires("N") |
131 .classes("package pack; public class B { pack.A f; }") |
134 .classes("package pack; public class B { pack.A f; }") |
132 .write(modules); |
135 .write(modules); |
133 |
136 |
134 String log = tb.new JavacTask() |
137 String log = new JavacTask(tb) |
135 .options("-XDrawDiagnostics", "-mp", modules.toString()) |
138 .options("-XDrawDiagnostics", "-mp", modules.toString()) |
136 .outdir(Files.createDirectories(base.resolve("classes"))) |
139 .outdir(Files.createDirectories(base.resolve("classes"))) |
137 .files(findJavaFiles(modules.resolve("M"))) |
140 .files(findJavaFiles(modules.resolve("M"))) |
138 .run(ToolBox.Expect.FAIL) |
141 .run(Task.Expect.FAIL) |
139 .writeAll() |
142 .writeAll() |
140 .getOutput(ToolBox.OutputKind.DIRECT); |
143 .getOutput(Task.OutputKind.DIRECT); |
141 |
144 |
142 if (!log.contains("B.java:1:1: compiler.err.package.in.other.module: N")) |
145 if (!log.contains("B.java:1:1: compiler.err.package.in.other.module: N")) |
143 throw new Exception("expected output not found"); |
146 throw new Exception("expected output not found"); |
144 } |
147 } |
145 |
148 |
154 new ModuleBuilder("M") |
157 new ModuleBuilder("M") |
155 .requires("N") |
158 .requires("N") |
156 .classes("package pack; public class C { publ.B b; }") |
159 .classes("package pack; public class C { publ.B b; }") |
157 .write(modules); |
160 .write(modules); |
158 |
161 |
159 String log = tb.new JavacTask() |
162 String log = new JavacTask(tb) |
160 .options("-XDrawDiagnostics", "-modulesourcepath", modules + "/*/src") |
163 .options("-XDrawDiagnostics", "-modulesourcepath", modules + "/*/src") |
161 .outdir(Files.createDirectories(base.resolve("classes"))) |
164 .outdir(Files.createDirectories(base.resolve("classes"))) |
162 .files(findJavaFiles(modules)) |
165 .files(findJavaFiles(modules)) |
163 .run(ToolBox.Expect.SUCCESS) |
166 .run(Task.Expect.SUCCESS) |
164 .writeAll() |
167 .writeAll() |
165 .getOutput(ToolBox.OutputKind.DIRECT); |
168 .getOutput(Task.OutputKind.DIRECT); |
166 |
169 |
167 if (!log.contains("")) |
170 if (!log.contains("")) |
168 throw new Exception("unexpected output not found"); |
171 throw new Exception("unexpected output not found"); |
169 |
172 |
170 } |
173 } |
180 new ModuleBuilder("M") |
183 new ModuleBuilder("M") |
181 .requires("N") |
184 .requires("N") |
182 .classes("package pack; public class C { publ.B b; }") |
185 .classes("package pack; public class C { publ.B b; }") |
183 .write(modules); |
186 .write(modules); |
184 |
187 |
185 String log = tb.new JavacTask() |
188 String log = new JavacTask(tb) |
186 .options("-XDrawDiagnostics", "-mp", modules.toString()) |
189 .options("-XDrawDiagnostics", "-mp", modules.toString()) |
187 .outdir(Files.createDirectories(base.resolve("classes"))) |
190 .outdir(Files.createDirectories(base.resolve("classes"))) |
188 .files(findJavaFiles(modules.resolve("M"))) |
191 .files(findJavaFiles(modules.resolve("M"))) |
189 .run(ToolBox.Expect.SUCCESS) |
192 .run(Task.Expect.SUCCESS) |
190 .writeAll() |
193 .writeAll() |
191 .getOutput(ToolBox.OutputKind.DIRECT); |
194 .getOutput(Task.OutputKind.DIRECT); |
192 |
195 |
193 if (!log.contains("")) |
196 if (!log.contains("")) |
194 throw new Exception("expected output not found"); |
197 throw new Exception("expected output not found"); |
195 |
198 |
196 } |
199 } |
210 .requires("M") |
213 .requires("M") |
211 .requires("N") |
214 .requires("N") |
212 .classes("package pkg; public class C { pack.A a; pack.B b; }") |
215 .classes("package pkg; public class C { pack.A a; pack.B b; }") |
213 .write(modules); |
216 .write(modules); |
214 |
217 |
215 List<String> log = tb.new JavacTask() |
218 List<String> log = new JavacTask(tb) |
216 .options("-XDrawDiagnostics", "-mp", modules.toString()) |
219 .options("-XDrawDiagnostics", "-mp", modules.toString()) |
217 .outdir(Files.createDirectories(base.resolve("classes"))) |
220 .outdir(Files.createDirectories(base.resolve("classes"))) |
218 .files(findJavaFiles(modules.resolve("K"))) |
221 .files(findJavaFiles(modules.resolve("K"))) |
219 .run(ToolBox.Expect.FAIL) |
222 .run(Task.Expect.FAIL) |
220 .writeAll() |
223 .writeAll() |
221 .getOutputLines(ToolBox.OutputKind.DIRECT); |
224 .getOutputLines(Task.OutputKind.DIRECT); |
222 |
225 |
223 List<String> expected = |
226 List<String> expected = |
224 Arrays.asList("module-info.java:1:1: compiler.err.package.clash.from.requires: K, pack, M, N", |
227 Arrays.asList("module-info.java:1:1: compiler.err.package.clash.from.requires: K, pack, M, N", |
225 "1 error"); |
228 "1 error"); |
226 if (!log.containsAll(expected)) |
229 if (!log.containsAll(expected)) |
242 ModuleBuilder moduleK = new ModuleBuilder("K"); |
245 ModuleBuilder moduleK = new ModuleBuilder("K"); |
243 moduleK.requires("M") |
246 moduleK.requires("M") |
244 .requires("N") |
247 .requires("N") |
245 .classes("package p; public class DependsOnN { boolean f = pkg.A.flagN; } ") |
248 .classes("package p; public class DependsOnN { boolean f = pkg.A.flagN; } ") |
246 .write(modules); |
249 .write(modules); |
247 tb.new JavacTask() |
250 new JavacTask(tb) |
248 .options("-modulesourcepath", modules + "/*/src") |
251 .options("-modulesourcepath", modules + "/*/src") |
249 .outdir(Files.createDirectories(base.resolve("classes"))) |
252 .outdir(Files.createDirectories(base.resolve("classes"))) |
250 .files(findJavaFiles(modules.resolve("K"))) |
253 .files(findJavaFiles(modules.resolve("K"))) |
251 .run(ToolBox.Expect.SUCCESS) |
254 .run(Task.Expect.SUCCESS) |
252 .writeAll(); |
255 .writeAll(); |
253 |
256 |
254 //negative case |
257 //negative case |
255 moduleK.classes("package pkg; public class DuplicatePackage { } ") |
258 moduleK.classes("package pkg; public class DuplicatePackage { } ") |
256 .classes("package p; public class DependsOnM { boolean f = pkg.A.flagM; } ") |
259 .classes("package p; public class DependsOnM { boolean f = pkg.A.flagM; } ") |
257 .write(modules); |
260 .write(modules); |
258 |
261 |
259 List<String> output = tb.new JavacTask() |
262 List<String> output = new JavacTask(tb) |
260 .options("-XDrawDiagnostics", |
263 .options("-XDrawDiagnostics", |
261 "-modulesourcepath", modules + "/*/src") |
264 "-modulesourcepath", modules + "/*/src") |
262 .outdir(Files.createDirectories(base.resolve("classes"))) |
265 .outdir(Files.createDirectories(base.resolve("classes"))) |
263 .files(findJavaFiles(modules.resolve("K"))) |
266 .files(findJavaFiles(modules.resolve("K"))) |
264 .run(ToolBox.Expect.FAIL) |
267 .run(Task.Expect.FAIL) |
265 .writeAll() |
268 .writeAll() |
266 .getOutputLines(ToolBox.OutputKind.DIRECT); |
269 .getOutputLines(Task.OutputKind.DIRECT); |
267 |
270 |
268 List<String> expected = Arrays.asList( |
271 List<String> expected = Arrays.asList( |
269 "DependsOnM.java:1:55: compiler.err.cant.resolve.location: kindname.variable, flagM, , , (compiler.misc.location: kindname.class, pkg.A, null)"); |
272 "DependsOnM.java:1:55: compiler.err.cant.resolve.location: kindname.variable, flagM, , , (compiler.misc.location: kindname.class, pkg.A, null)"); |
270 if (!output.containsAll(expected)) { |
273 if (!output.containsAll(expected)) { |
271 throw new Exception("expected output not found"); |
274 throw new Exception("expected output not found"); |