26 * @summary simple tests of module provides |
26 * @summary simple tests of module provides |
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 ProvidesTest |
32 * @run main ProvidesTest |
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; |
40 |
39 |
|
40 import toolbox.JavacTask; |
|
41 import toolbox.Task; |
|
42 import toolbox.ToolBox; |
|
43 |
41 public class ProvidesTest extends ModuleTestBase { |
44 public class ProvidesTest extends ModuleTestBase { |
42 public static void main(String... args) throws Exception { |
45 public static void main(String... args) throws Exception { |
43 ProvidesTest t = new ProvidesTest(); |
46 ProvidesTest t = new ProvidesTest(); |
44 t.runTests(); |
47 t.runTests(); |
45 } |
48 } |
52 "package p1; public class C1 { }", |
55 "package p1; public class C1 { }", |
53 "package p2; public class C2 extends p1.C1 { }"); |
56 "package p2; public class C2 extends p1.C1 { }"); |
54 Path classes = base.resolve("classes"); |
57 Path classes = base.resolve("classes"); |
55 Files.createDirectories(classes); |
58 Files.createDirectories(classes); |
56 |
59 |
57 tb.new JavacTask() |
60 new JavacTask(tb) |
58 .outdir(classes) |
61 .outdir(classes) |
59 .files(findJavaFiles(src)) |
62 .files(findJavaFiles(src)) |
60 .run(ToolBox.Expect.SUCCESS) |
63 .run(Task.Expect.SUCCESS) |
61 .writeAll(); |
64 .writeAll(); |
62 } |
65 } |
63 |
66 |
64 @Test |
67 @Test |
65 void testMulti(Path base) throws Exception { |
68 void testMulti(Path base) throws Exception { |
71 "module m2 { requires m1; provides p1.C1 with p2.C2; }", |
74 "module m2 { requires m1; provides p1.C1 with p2.C2; }", |
72 "package p2; public class C2 extends p1.C1 { }"); |
75 "package p2; public class C2 extends p1.C1 { }"); |
73 Path modules = base.resolve("modules"); |
76 Path modules = base.resolve("modules"); |
74 Files.createDirectories(modules); |
77 Files.createDirectories(modules); |
75 |
78 |
76 tb.new JavacTask() |
79 new JavacTask(tb) |
77 .options("-modulesourcepath", src.toString()) |
80 .options("-modulesourcepath", src.toString()) |
78 .outdir(modules) |
81 .outdir(modules) |
79 .files(findJavaFiles(src)) |
82 .files(findJavaFiles(src)) |
80 .run(ToolBox.Expect.SUCCESS) |
83 .run(Task.Expect.SUCCESS) |
81 .writeAll(); |
84 .writeAll(); |
82 |
85 |
83 } |
86 } |
84 |
87 |
85 @Test |
88 @Test |
89 "module m { provides p.C; }", |
92 "module m { provides p.C; }", |
90 "package p; public class C { }"); |
93 "package p; public class C { }"); |
91 Path classes = base.resolve("classes"); |
94 Path classes = base.resolve("classes"); |
92 Files.createDirectories(classes); |
95 Files.createDirectories(classes); |
93 |
96 |
94 String log = tb.new JavacTask() |
97 String log = new JavacTask(tb) |
95 .options("-XDrawDiagnostics") |
98 .options("-XDrawDiagnostics") |
96 .outdir(classes) |
99 .outdir(classes) |
97 .files(findJavaFiles(src)) |
100 .files(findJavaFiles(src)) |
98 .run(ToolBox.Expect.FAIL) |
101 .run(Task.Expect.FAIL) |
99 .writeAll() |
102 .writeAll() |
100 .getOutput(ToolBox.OutputKind.DIRECT); |
103 .getOutput(Task.OutputKind.DIRECT); |
101 |
104 |
102 if (!log.contains("module-info.java:1:24: compiler.err.expected: 'with'")) |
105 if (!log.contains("module-info.java:1:24: compiler.err.expected: 'with'")) |
103 throw new Exception("expected output not found"); |
106 throw new Exception("expected output not found"); |
104 |
107 |
105 } |
108 } |
112 "package p1; public class C1 { }", |
115 "package p1; public class C1 { }", |
113 "package p2; public class C2 extends p1.C1 { }"); |
116 "package p2; public class C2 extends p1.C1 { }"); |
114 Path classes = base.resolve("classes"); |
117 Path classes = base.resolve("classes"); |
115 Files.createDirectories(classes); |
118 Files.createDirectories(classes); |
116 |
119 |
117 tb.new JavacTask() |
120 new JavacTask(tb) |
118 .options("-XDrawDiagnostic") |
121 .options("-XDrawDiagnostic") |
119 .outdir(classes) |
122 .outdir(classes) |
120 .files(findJavaFiles(src)) |
123 .files(findJavaFiles(src)) |
121 .run(ToolBox.Expect.FAIL) |
124 .run(Task.Expect.FAIL) |
122 .writeAll(); |
125 .writeAll(); |
123 } |
126 } |
124 |
127 |
125 @Test |
128 @Test |
126 void testMissingService(Path base) throws Exception { |
129 void testMissingService(Path base) throws Exception { |
127 Path src = base.resolve("src"); |
130 Path src = base.resolve("src"); |
128 tb.writeJavaFiles(src, |
131 tb.writeJavaFiles(src, |
129 "module m { provides p.Missing with p.C; }", |
132 "module m { provides p.Missing with p.C; }", |
130 "package p; public class C extends p.Missing { }"); |
133 "package p; public class C extends p.Missing { }"); |
131 |
134 |
132 List<String> output = tb.new JavacTask() |
135 List<String> output = new JavacTask(tb) |
133 .options("-XDrawDiagnostics") |
136 .options("-XDrawDiagnostics") |
134 .outdir(Files.createDirectories(base.resolve("classes"))) |
137 .outdir(Files.createDirectories(base.resolve("classes"))) |
135 .files(findJavaFiles(src)) |
138 .files(findJavaFiles(src)) |
136 .run(ToolBox.Expect.FAIL) |
139 .run(Task.Expect.FAIL) |
137 .writeAll() |
140 .writeAll() |
138 .getOutputLines(ToolBox.OutputKind.DIRECT); |
141 .getOutputLines(Task.OutputKind.DIRECT); |
139 |
142 |
140 List<String> expected = Arrays.asList( |
143 List<String> expected = Arrays.asList( |
141 "C.java:1:36: compiler.err.cant.resolve.location: kindname.class, Missing, , , (compiler.misc.location: kindname.package, p, null)", |
144 "C.java:1:36: compiler.err.cant.resolve.location: kindname.class, Missing, , , (compiler.misc.location: kindname.package, p, null)", |
142 "module-info.java:1:22: compiler.err.cant.resolve.location: kindname.class, Missing, , , (compiler.misc.location: kindname.package, p, null)", |
145 "module-info.java:1:22: compiler.err.cant.resolve.location: kindname.class, Missing, , , (compiler.misc.location: kindname.package, p, null)", |
143 "module-info.java:1:37: compiler.err.service.implementation.doesnt.have.a.no.args.constructor: <any>", |
146 "module-info.java:1:37: compiler.err.service.implementation.doesnt.have.a.no.args.constructor: <any>", |
154 "module M { exports p; }", |
157 "module M { exports p; }", |
155 "package p; public class Service { }"); |
158 "package p; public class Service { }"); |
156 tb.writeJavaFiles(modules.resolve("L"), |
159 tb.writeJavaFiles(modules.resolve("L"), |
157 "module L { requires M; provides p.Service with p.Service; }"); |
160 "module L { requires M; provides p.Service with p.Service; }"); |
158 |
161 |
159 List<String> output = tb.new JavacTask() |
162 List<String> output = new JavacTask(tb) |
160 .options("-XDrawDiagnostics", |
163 .options("-XDrawDiagnostics", |
161 "-modulesourcepath", modules.toString()) |
164 "-modulesourcepath", modules.toString()) |
162 .outdir(Files.createDirectories(base.resolve("classes"))) |
165 .outdir(Files.createDirectories(base.resolve("classes"))) |
163 .files(findJavaFiles(modules)) |
166 .files(findJavaFiles(modules)) |
164 .run(ToolBox.Expect.FAIL) |
167 .run(Task.Expect.FAIL) |
165 .writeAll() |
168 .writeAll() |
166 .getOutputLines(ToolBox.OutputKind.DIRECT); |
169 .getOutputLines(Task.OutputKind.DIRECT); |
167 List<String> expected = Arrays.asList( |
170 List<String> expected = Arrays.asList( |
168 "module-info.java:1:24: compiler.err.service.implementation.not.in.right.module: M", |
171 "module-info.java:1:24: compiler.err.service.implementation.not.in.right.module: M", |
169 "1 error"); |
172 "1 error"); |
170 if (!output.containsAll(expected)) { |
173 if (!output.containsAll(expected)) { |
171 throw new Exception("Expected output not found"); |
174 throw new Exception("Expected output not found"); |
179 tb.writeJavaFiles(src, |
182 tb.writeJavaFiles(src, |
180 "module m { provides p.A with p.B; }", |
183 "module m { provides p.A with p.B; }", |
181 "package p; public class A { }", |
184 "package p; public class A { }", |
182 "package p; public class B { }"); |
185 "package p; public class B { }"); |
183 |
186 |
184 List<String> output = tb.new JavacTask() |
187 List<String> output = new JavacTask(tb) |
185 .options("-XDrawDiagnostics") |
188 .options("-XDrawDiagnostics") |
186 .outdir(Files.createDirectories(base.resolve("classes"))) |
189 .outdir(Files.createDirectories(base.resolve("classes"))) |
187 .files(findJavaFiles(src)) |
190 .files(findJavaFiles(src)) |
188 .run(ToolBox.Expect.FAIL) |
191 .run(Task.Expect.FAIL) |
189 .writeAll() |
192 .writeAll() |
190 .getOutputLines(ToolBox.OutputKind.DIRECT); |
193 .getOutputLines(Task.OutputKind.DIRECT); |
191 |
194 |
192 List<String> expected = Arrays.asList("module-info.java:1:31: compiler.err.prob.found.req: (compiler.misc.inconvertible.types: p.B, p.A)", |
195 List<String> expected = Arrays.asList("module-info.java:1:31: compiler.err.prob.found.req: (compiler.misc.inconvertible.types: p.B, p.A)", |
193 "1 error"); |
196 "1 error"); |
194 if (!output.containsAll(expected)) { |
197 if (!output.containsAll(expected)) { |
195 throw new Exception("Expected output not found"); |
198 throw new Exception("Expected output not found"); |
201 Path src = base.resolve("src"); |
204 Path src = base.resolve("src"); |
202 tb.writeJavaFiles(src, |
205 tb.writeJavaFiles(src, |
203 "module m { provides p.C with p.Impl; }", |
206 "module m { provides p.C with p.Impl; }", |
204 "package p; public class C { }"); |
207 "package p; public class C { }"); |
205 |
208 |
206 List<String> output = tb.new JavacTask() |
209 List<String> output = new JavacTask(tb) |
207 .options("-XDrawDiagnostics") |
210 .options("-XDrawDiagnostics") |
208 .outdir(Files.createDirectories(base.resolve("classes"))) |
211 .outdir(Files.createDirectories(base.resolve("classes"))) |
209 .files(findJavaFiles(src)) |
212 .files(findJavaFiles(src)) |
210 .run(ToolBox.Expect.FAIL) |
213 .run(Task.Expect.FAIL) |
211 .writeAll() |
214 .writeAll() |
212 .getOutputLines(ToolBox.OutputKind.DIRECT); |
215 .getOutputLines(Task.OutputKind.DIRECT); |
213 |
216 |
214 List<String> expected = Arrays.asList("module-info.java:1:31: compiler.err.cant.resolve.location: kindname.class, Impl, , , (compiler.misc.location: kindname.package, p, null)", |
217 List<String> expected = Arrays.asList("module-info.java:1:31: compiler.err.cant.resolve.location: kindname.class, Impl, , , (compiler.misc.location: kindname.package, p, null)", |
215 "1 error"); |
218 "1 error"); |
216 if (!output.containsAll(expected)) { |
219 if (!output.containsAll(expected)) { |
217 throw new Exception("Expected output not found"); |
220 throw new Exception("Expected output not found"); |
225 "module m { provides p.C with p.Impl1; provides p.C with p.Impl2; }", |
228 "module m { provides p.C with p.Impl1; provides p.C with p.Impl2; }", |
226 "package p; public class C { }", |
229 "package p; public class C { }", |
227 "package p; public class Impl1 extends p.C { }", |
230 "package p; public class Impl1 extends p.C { }", |
228 "package p; public class Impl2 extends p.C { }"); |
231 "package p; public class Impl2 extends p.C { }"); |
229 |
232 |
230 tb.new JavacTask() |
233 new JavacTask(tb) |
231 .outdir(Files.createDirectories(base.resolve("classes"))) |
234 .outdir(Files.createDirectories(base.resolve("classes"))) |
232 .files(findJavaFiles(src)) |
235 .files(findJavaFiles(src)) |
233 .run(ToolBox.Expect.SUCCESS) |
236 .run(Task.Expect.SUCCESS) |
234 .writeAll(); |
237 .writeAll(); |
235 } |
238 } |
236 |
239 |
237 @Test |
240 @Test |
238 void testOneImplementationsForServices(Path base) throws Exception { |
241 void testOneImplementationsForServices(Path base) throws Exception { |
241 "module m { provides p.Service1 with p.Impl; provides p.Service2 with p.Impl; }", |
244 "module m { provides p.Service1 with p.Impl; provides p.Service2 with p.Impl; }", |
242 "package p; public interface Service1 { }", |
245 "package p; public interface Service1 { }", |
243 "package p; public abstract class Service2 { }", |
246 "package p; public abstract class Service2 { }", |
244 "package p; public class Impl extends p.Service2 implements p.Service1 { }"); |
247 "package p; public class Impl extends p.Service2 implements p.Service1 { }"); |
245 |
248 |
246 tb.new JavacTask() |
249 new JavacTask(tb) |
247 .outdir(Files.createDirectories(base.resolve("classes"))) |
250 .outdir(Files.createDirectories(base.resolve("classes"))) |
248 .files(findJavaFiles(src)) |
251 .files(findJavaFiles(src)) |
249 .run(ToolBox.Expect.SUCCESS) |
252 .run(Task.Expect.SUCCESS) |
250 .writeAll(); |
253 .writeAll(); |
251 } |
254 } |
252 |
255 |
253 @Test |
256 @Test |
254 void testAbstractImplementation(Path base) throws Exception { |
257 void testAbstractImplementation(Path base) throws Exception { |
256 tb.writeJavaFiles(src, |
259 tb.writeJavaFiles(src, |
257 "module m { provides p1.C1 with p2.C2; }", |
260 "module m { provides p1.C1 with p2.C2; }", |
258 "package p1; public class C1 { }", |
261 "package p1; public class C1 { }", |
259 "package p2; public abstract class C2 extends p1.C1 { }"); |
262 "package p2; public abstract class C2 extends p1.C1 { }"); |
260 |
263 |
261 List<String> output = tb.new JavacTask() |
264 List<String> output = new JavacTask(tb) |
262 .options("-XDrawDiagnostics") |
265 .options("-XDrawDiagnostics") |
263 .outdir(Files.createDirectories(base.resolve("classes"))) |
266 .outdir(Files.createDirectories(base.resolve("classes"))) |
264 .files(findJavaFiles(src)) |
267 .files(findJavaFiles(src)) |
265 .run(ToolBox.Expect.FAIL) |
268 .run(Task.Expect.FAIL) |
266 .writeAll() |
269 .writeAll() |
267 .getOutputLines(ToolBox.OutputKind.DIRECT); |
270 .getOutputLines(Task.OutputKind.DIRECT); |
268 |
271 |
269 List<String> expected = Arrays.asList( |
272 List<String> expected = Arrays.asList( |
270 "module-info.java:1:34: compiler.err.service.implementation.is.abstract: p2.C2"); |
273 "module-info.java:1:34: compiler.err.service.implementation.is.abstract: p2.C2"); |
271 if (!output.containsAll(expected)) { |
274 if (!output.containsAll(expected)) { |
272 throw new Exception("Expected output not found"); |
275 throw new Exception("Expected output not found"); |
279 tb.writeJavaFiles(src, |
282 tb.writeJavaFiles(src, |
280 "module m { provides p1.Service with p2.Impl; }", |
283 "module m { provides p1.Service with p2.Impl; }", |
281 "package p1; public interface Service { }", |
284 "package p1; public interface Service { }", |
282 "package p2; public interface Impl extends p1.Service { }"); |
285 "package p2; public interface Impl extends p1.Service { }"); |
283 |
286 |
284 List<String> output = tb.new JavacTask() |
287 List<String> output = new JavacTask(tb) |
285 .options("-XDrawDiagnostics") |
288 .options("-XDrawDiagnostics") |
286 .outdir(Files.createDirectories(base.resolve("classes"))) |
289 .outdir(Files.createDirectories(base.resolve("classes"))) |
287 .files(findJavaFiles(src)) |
290 .files(findJavaFiles(src)) |
288 .run(ToolBox.Expect.FAIL) |
291 .run(Task.Expect.FAIL) |
289 .writeAll() |
292 .writeAll() |
290 .getOutputLines(ToolBox.OutputKind.DIRECT); |
293 .getOutputLines(Task.OutputKind.DIRECT); |
291 |
294 |
292 List<String> expected = Arrays.asList( |
295 List<String> expected = Arrays.asList( |
293 "module-info.java:1:39: compiler.err.service.implementation.is.abstract: p2.Impl"); |
296 "module-info.java:1:39: compiler.err.service.implementation.is.abstract: p2.Impl"); |
294 if (!output.containsAll(expected)) { |
297 if (!output.containsAll(expected)) { |
295 throw new Exception("Expected output not found"); |
298 throw new Exception("Expected output not found"); |
302 tb.writeJavaFiles(src, |
305 tb.writeJavaFiles(src, |
303 "module m { provides p1.C1 with p2.C2; }", |
306 "module m { provides p1.C1 with p2.C2; }", |
304 "package p1; public class C1 { }", |
307 "package p1; public class C1 { }", |
305 "package p2; class C2 extends p1.C1 { }"); |
308 "package p2; class C2 extends p1.C1 { }"); |
306 |
309 |
307 List<String> output = tb.new JavacTask() |
310 List<String> output = new JavacTask(tb) |
308 .options("-XDrawDiagnostics") |
311 .options("-XDrawDiagnostics") |
309 .outdir(Files.createDirectories(base.resolve("classes"))) |
312 .outdir(Files.createDirectories(base.resolve("classes"))) |
310 .files(findJavaFiles(src)) |
313 .files(findJavaFiles(src)) |
311 .run(ToolBox.Expect.FAIL) |
314 .run(Task.Expect.FAIL) |
312 .writeAll() |
315 .writeAll() |
313 .getOutputLines(ToolBox.OutputKind.DIRECT); |
316 .getOutputLines(Task.OutputKind.DIRECT); |
314 |
317 |
315 List<String> expected = Arrays.asList("module-info.java:1:34: compiler.err.not.def.public.cant.access: p2.C2, p2", |
318 List<String> expected = Arrays.asList("module-info.java:1:34: compiler.err.not.def.public.cant.access: p2.C2, p2", |
316 "1 error"); |
319 "1 error"); |
317 if (!output.containsAll(expected)) { |
320 if (!output.containsAll(expected)) { |
318 throw new Exception("Expected output not found"); |
321 throw new Exception("Expected output not found"); |
325 tb.writeJavaFiles(src, |
328 tb.writeJavaFiles(src, |
326 "module m { uses p1.C1; provides p1.C1 with p2.C2; }", |
329 "module m { uses p1.C1; provides p1.C1 with p2.C2; }", |
327 "package p1; public class C1 { }", |
330 "package p1; public class C1 { }", |
328 "package p2; public class C2 extends p1.C1 { public C2(String str) { } }"); |
331 "package p2; public class C2 extends p1.C1 { public C2(String str) { } }"); |
329 |
332 |
330 List<String> output = tb.new JavacTask() |
333 List<String> output = new JavacTask(tb) |
331 .options("-XDrawDiagnostics") |
334 .options("-XDrawDiagnostics") |
332 .outdir(Files.createDirectories(base.resolve("classes"))) |
335 .outdir(Files.createDirectories(base.resolve("classes"))) |
333 .files(findJavaFiles(src)) |
336 .files(findJavaFiles(src)) |
334 .run(ToolBox.Expect.FAIL) |
337 .run(Task.Expect.FAIL) |
335 .writeAll() |
338 .writeAll() |
336 .getOutputLines(ToolBox.OutputKind.DIRECT); |
339 .getOutputLines(Task.OutputKind.DIRECT); |
337 |
340 |
338 List<String> expected = Arrays.asList( |
341 List<String> expected = Arrays.asList( |
339 "module-info.java:1:46: compiler.err.service.implementation.doesnt.have.a.no.args.constructor: p2.C2"); |
342 "module-info.java:1:46: compiler.err.service.implementation.doesnt.have.a.no.args.constructor: p2.C2"); |
340 if (!output.containsAll(expected)) { |
343 if (!output.containsAll(expected)) { |
341 throw new Exception("Expected output not found"); |
344 throw new Exception("Expected output not found"); |
348 tb.writeJavaFiles(src, |
351 tb.writeJavaFiles(src, |
349 "module m { uses p1.C1; provides p1.C1 with p2.C2; }", |
352 "module m { uses p1.C1; provides p1.C1 with p2.C2; }", |
350 "package p1; public class C1 { }", |
353 "package p1; public class C1 { }", |
351 "package p2; public class C2 extends p1.C1 { private C2() { } }"); |
354 "package p2; public class C2 extends p1.C1 { private C2() { } }"); |
352 |
355 |
353 List<String> output = tb.new JavacTask() |
356 List<String> output = new JavacTask(tb) |
354 .options("-XDrawDiagnostics") |
357 .options("-XDrawDiagnostics") |
355 .outdir(Files.createDirectories(base.resolve("classes"))) |
358 .outdir(Files.createDirectories(base.resolve("classes"))) |
356 .files(findJavaFiles(src)) |
359 .files(findJavaFiles(src)) |
357 .run(ToolBox.Expect.FAIL) |
360 .run(Task.Expect.FAIL) |
358 .writeAll() |
361 .writeAll() |
359 .getOutputLines(ToolBox.OutputKind.DIRECT); |
362 .getOutputLines(Task.OutputKind.DIRECT); |
360 |
363 |
361 List<String> expected = Arrays.asList( |
364 List<String> expected = Arrays.asList( |
362 "module-info.java:1:46: compiler.err.service.implementation.no.args.constructor.not.public: p2.C2"); |
365 "module-info.java:1:46: compiler.err.service.implementation.no.args.constructor.not.public: p2.C2"); |
363 if (!output.containsAll(expected)) { |
366 if (!output.containsAll(expected)) { |
364 throw new Exception("Expected output not found"); |
367 throw new Exception("Expected output not found"); |
372 "module m { provides p1.C1 with p2.C3; }", |
375 "module m { provides p1.C1 with p2.C3; }", |
373 "package p1; public class C1 { }", |
376 "package p1; public class C1 { }", |
374 "package p2; public class C2 extends p1.C1 { }", |
377 "package p2; public class C2 extends p1.C1 { }", |
375 "package p2; public class C3 extends p2.C2 { }"); |
378 "package p2; public class C3 extends p2.C2 { }"); |
376 |
379 |
377 tb.new JavacTask() |
380 new JavacTask(tb) |
378 .outdir(Files.createDirectories(base.resolve("classes"))) |
381 .outdir(Files.createDirectories(base.resolve("classes"))) |
379 .files(findJavaFiles(src)) |
382 .files(findJavaFiles(src)) |
380 .run(ToolBox.Expect.SUCCESS) |
383 .run(Task.Expect.SUCCESS) |
381 .writeAll(); |
384 .writeAll(); |
382 } |
385 } |
383 |
386 |
384 @Test |
387 @Test |
385 void testServiceImplementationInnerClass(Path base) throws Exception { |
388 void testServiceImplementationInnerClass(Path base) throws Exception { |
387 tb.writeJavaFiles(src, |
390 tb.writeJavaFiles(src, |
388 "module m { provides p1.C1 with p2.C2.Inner; }", |
391 "module m { provides p1.C1 with p2.C2.Inner; }", |
389 "package p1; public class C1 { }", |
392 "package p1; public class C1 { }", |
390 "package p2; public class C2 { public class Inner extends p1.C1 { } }"); |
393 "package p2; public class C2 { public class Inner extends p1.C1 { } }"); |
391 |
394 |
392 List<String> output = tb.new JavacTask() |
395 List<String> output = new JavacTask(tb) |
393 .options("-XDrawDiagnostics") |
396 .options("-XDrawDiagnostics") |
394 .outdir(Files.createDirectories(base.resolve("classes"))) |
397 .outdir(Files.createDirectories(base.resolve("classes"))) |
395 .files(findJavaFiles(src)) |
398 .files(findJavaFiles(src)) |
396 .run(ToolBox.Expect.FAIL) |
399 .run(Task.Expect.FAIL) |
397 .writeAll() |
400 .writeAll() |
398 .getOutputLines(ToolBox.OutputKind.DIRECT); |
401 .getOutputLines(Task.OutputKind.DIRECT); |
399 |
402 |
400 List<String> expected = Arrays.asList( |
403 List<String> expected = Arrays.asList( |
401 "module-info.java:1:37: compiler.err.service.implementation.is.inner: p2.C2.Inner"); |
404 "module-info.java:1:37: compiler.err.service.implementation.is.inner: p2.C2.Inner"); |
402 if (!output.containsAll(expected)) { |
405 if (!output.containsAll(expected)) { |
403 throw new Exception("Expected output not found"); |
406 throw new Exception("Expected output not found"); |
410 tb.writeJavaFiles(src, |
413 tb.writeJavaFiles(src, |
411 "module m { provides p1.C1.InnerDefinition with p2.C2; }", |
414 "module m { provides p1.C1.InnerDefinition with p2.C2; }", |
412 "package p1; public class C1 { public class InnerDefinition { } }", |
415 "package p1; public class C1 { public class InnerDefinition { } }", |
413 "package p2; public class C2 extends p1.C1.InnerDefinition { }"); |
416 "package p2; public class C2 extends p1.C1.InnerDefinition { }"); |
414 |
417 |
415 List<String> output = tb.new JavacTask() |
418 List<String> output = new JavacTask(tb) |
416 .options("-XDrawDiagnostics") |
419 .options("-XDrawDiagnostics") |
417 .outdir(Files.createDirectories(base.resolve("classes"))) |
420 .outdir(Files.createDirectories(base.resolve("classes"))) |
418 .files(findJavaFiles(src)) |
421 .files(findJavaFiles(src)) |
419 .run(ToolBox.Expect.FAIL) |
422 .run(Task.Expect.FAIL) |
420 .writeAll() |
423 .writeAll() |
421 .getOutputLines(ToolBox.OutputKind.DIRECT); |
424 .getOutputLines(Task.OutputKind.DIRECT); |
422 |
425 |
423 List<String> expected = Arrays.asList( |
426 List<String> expected = Arrays.asList( |
424 "module-info.java:1:26: compiler.err.service.definition.is.inner: p1.C1.InnerDefinition", |
427 "module-info.java:1:26: compiler.err.service.definition.is.inner: p1.C1.InnerDefinition", |
425 "module-info.java:1:12: compiler.warn.service.provided.but.not.exported.or.used: p1.C1.InnerDefinition", |
428 "module-info.java:1:12: compiler.warn.service.provided.but.not.exported.or.used: p1.C1.InnerDefinition", |
426 "C2.java:1:20: compiler.err.encl.class.required: p1.C1.InnerDefinition", |
429 "C2.java:1:20: compiler.err.encl.class.required: p1.C1.InnerDefinition", |