96 |
98 |
97 ModuleBuilder mb1 = new ModuleBuilder(tb, "m1"); |
99 ModuleBuilder mb1 = new ModuleBuilder(tb, "m1"); |
98 mb1.comment("The first module.") |
100 mb1.comment("The first module.") |
99 .exports("m1pub") |
101 .exports("m1pub") |
100 .requires("m2") |
102 .requires("m2") |
101 .classes("package m1pub; /** Klass A */ public class A {}") |
103 .classes("package m1pub; /** Class A */ public class A {}") |
102 .classes("package m1pro; /** Klass B */ public class B {}") |
104 .classes("package m1pro; /** Class B */ public class B {}") |
103 .write(src); |
105 .write(src); |
104 |
106 |
105 ModuleBuilder mb2 = new ModuleBuilder(tb, "m2"); |
107 ModuleBuilder mb2 = new ModuleBuilder(tb, "m2"); |
106 mb2.comment("The second module.") |
108 mb2.comment("The second module.") |
107 .exports("m2pub") |
109 .exports("m2pub") |
108 .classes("package m2pub; /** Klass A */ public class A {}") |
110 .classes("package m2pub; /** Class A */ public class A {}") |
109 .classes("package m2pro; /** Klass B */ public class B {}") |
111 .classes("package m2pro; /** Class B */ public class B {}") |
110 .write(src); |
112 .write(src); |
111 execTask("--module-source-path", src.toString(), |
113 execTask("--module-source-path", src.toString(), |
112 "--module", "m1", |
114 "--module", "m1", |
113 "--module", "m2"); |
115 "--module", "m2"); |
114 checkModulesSpecified("m1", "m2"); |
116 checkModulesSpecified("m1", "m2"); |
115 checkPackagesIncluded("m1pub", "m2pub"); |
117 checkPackagesIncluded("m1pub", "m2pub"); |
116 checkTypesIncluded("m1pub.A", "m2pub.A"); |
118 checkTypesIncluded("m1pub.A", "m2pub.A"); |
117 |
119 |
118 } |
120 } |
119 |
121 |
120 /** |
122 @Test |
|
123 public void testModulePathOption(Path base) throws Exception { |
|
124 Path src = base.resolve("src"); |
|
125 Path modulePath = base.resolve("modules"); |
|
126 |
|
127 ModuleBuilder mb1 = new ModuleBuilder(tb, "m1"); |
|
128 mb1.comment("Module on module path.") |
|
129 .exports("pkg1") |
|
130 .classes("package pkg1; /** Class A */ public class A { }") |
|
131 .build(modulePath); |
|
132 |
|
133 ModuleBuilder mb2 = new ModuleBuilder(tb, "m2"); |
|
134 mb2.comment("The second module.") |
|
135 .exports("pkg2") |
|
136 .requires("m1") |
|
137 .classes("package pkg2; /** Class B */ public class B { /** Field f */ public pkg1.A f; }") |
|
138 .write(src); |
|
139 execTask("--module-source-path", src.toString(), |
|
140 "--module-path", modulePath.toString(), |
|
141 "--module", "m2"); |
|
142 checkModulesSpecified("m2"); |
|
143 checkPackagesIncluded("pkg2"); |
|
144 checkMembersSelected("pkg2.B.f"); |
|
145 |
|
146 // module path option "-p" |
|
147 execTask("--module-source-path", src.toString(), |
|
148 "-p", modulePath.toString(), |
|
149 "--module", "m2"); |
|
150 // no module path |
|
151 execNegativeTask("--module-source-path", src.toString(), |
|
152 "--module", "m2"); |
|
153 assertErrorPresent("error: module not found: m1"); |
|
154 } |
|
155 |
|
156 @Test |
|
157 public void testUpgradeModulePathOption(Path base) throws Exception { |
|
158 Path src = base.resolve("src"); |
|
159 Path modulePath = base.resolve("modules"); |
|
160 Path upgradePath = base.resolve("upgrades"); |
|
161 |
|
162 ModuleBuilder mb1 = new ModuleBuilder(tb, "m1"); |
|
163 mb1.comment("Module on module path.") |
|
164 .exports("pkg1") |
|
165 .classes("package pkg1; /** Class A */ public class A { }") |
|
166 .build(modulePath); |
|
167 |
|
168 ModuleBuilder mbUpgrade = new ModuleBuilder(tb, "m1"); |
|
169 mbUpgrade.comment("Module on upgrade module path.") |
|
170 .exports("pkg1") |
|
171 .classes("package pkg1; /** Class C */ public class C { }") |
|
172 .build(upgradePath); |
|
173 |
|
174 ModuleBuilder mb2 = new ModuleBuilder(tb, "m2"); |
|
175 mb2.comment("The second module.") |
|
176 .exports("pkg2") |
|
177 .requires("m1") |
|
178 .classes("package pkg2; /** Class B */ public class B { /** Field f */ public pkg1.C f; }") |
|
179 .write(src); |
|
180 execTask("--module-source-path", src.toString(), |
|
181 "--module-path", modulePath.toString(), |
|
182 "--upgrade-module-path", upgradePath.toString(), |
|
183 "--module", "m2"); |
|
184 checkModulesSpecified("m2"); |
|
185 checkPackagesIncluded("pkg2"); |
|
186 checkMembersSelected("pkg2.B.f"); |
|
187 |
|
188 // no upgrade module path |
|
189 execNegativeTask("--module-source-path", src.toString(), |
|
190 "--module-path", modulePath.toString(), |
|
191 "--module", "m2"); |
|
192 assertErrorPresent("error: cannot find symbol"); |
|
193 |
|
194 // dependency from module path |
|
195 ModuleBuilder mb3 = new ModuleBuilder(tb, "m3"); |
|
196 mb3.comment("The third module.") |
|
197 .exports("pkg3") |
|
198 .requires("m1") |
|
199 .classes("package pkg3; /** Class Z */ public class Z { /** Field f */ public pkg1.A f; }") |
|
200 .write(src); |
|
201 execNegativeTask("--module-source-path", src.toString(), |
|
202 "--module-path", modulePath.toString(), |
|
203 "--upgrade-module-path", upgradePath.toString(), |
|
204 "--module", "m3"); |
|
205 assertErrorPresent("Z.java:1: error: cannot find symbol"); |
|
206 } |
|
207 |
|
208 @Test |
|
209 public void testAddModulesOption(Path base) throws Exception { |
|
210 Path src = base.resolve("src"); |
|
211 Path modulePath = base.resolve("modules"); |
|
212 |
|
213 ModuleBuilder mb1 = new ModuleBuilder(tb, "m1"); |
|
214 mb1.comment("Module on module path.") |
|
215 .exports("pkg1") |
|
216 .classes("package pkg1; /** Class A */ public class A { }") |
|
217 .build(modulePath); |
|
218 |
|
219 ModuleBuilder mb2 = new ModuleBuilder(tb, "m2"); |
|
220 mb2.comment("The second module.") |
|
221 .exports("pkg2") |
|
222 .classes("package pkg2; /** @see pkg1.A */ public class B { }") |
|
223 .write(src); |
|
224 |
|
225 String log = new JavadocTask(tb) |
|
226 .options("--module-source-path", src.toString(), |
|
227 "--module-path", modulePath.toString(), |
|
228 "--module", "m2") |
|
229 .run(Expect.FAIL) |
|
230 .writeAll() |
|
231 .getOutput(OutputKind.DIRECT); |
|
232 if (!log.contains("B.java:1: error: reference not found")) { |
|
233 throw new Exception("Error not found"); |
|
234 } |
|
235 |
|
236 new JavadocTask(tb) |
|
237 .options("--module-source-path", src.toString(), |
|
238 "--module-path", modulePath.toString(), |
|
239 "--add-modules", "m1", |
|
240 "--module", "m2") |
|
241 .run() |
|
242 .writeAll(); |
|
243 } |
|
244 |
|
245 @Test |
|
246 public void testLimitModulesOption(Path base) throws Exception { |
|
247 Path src = base.resolve("src"); |
|
248 Path modulePath = base.resolve("modules"); |
|
249 |
|
250 ModuleBuilder mb1 = new ModuleBuilder(tb, "m1"); |
|
251 mb1.comment("Module on module path.") |
|
252 .build(modulePath); |
|
253 |
|
254 ModuleBuilder mb2 = new ModuleBuilder(tb, "m2"); |
|
255 mb2.comment("The second module.") |
|
256 .exports("pkg2") |
|
257 .requires("m1") |
|
258 .classes("package pkg2; /** Class B */ public class B { }") |
|
259 .write(src); |
|
260 |
|
261 execNegativeTask("--module-source-path", src.toString(), |
|
262 "--module-path", modulePath.toString(), |
|
263 "--limit-modules", "java.base", |
|
264 "--module", "m2"); |
|
265 assertErrorPresent("error: module not found: m1"); |
|
266 } |
|
267 |
|
268 @Test |
|
269 public void testAddExportsOption(Path base) throws Exception { |
|
270 Path src = base.resolve("src"); |
|
271 Path modulePath = base.resolve("modules"); |
|
272 |
|
273 ModuleBuilder mb1 = new ModuleBuilder(tb, "m1"); |
|
274 mb1.comment("Module on module path.") |
|
275 .classes("package pkg1; /** Class A */ public class A { }") |
|
276 .build(modulePath); |
|
277 |
|
278 ModuleBuilder mb2 = new ModuleBuilder(tb, "m2"); |
|
279 mb2.comment("The second module.") |
|
280 .exports("pkg2") |
|
281 .requires("m1") |
|
282 .classes("package pkg2; /** Class B */ public class B { /** Field f */ public pkg1.A f; }") |
|
283 .write(src); |
|
284 execTask("--module-source-path", src.toString(), |
|
285 "--module-path", modulePath.toString(), |
|
286 "--add-exports", "m1/pkg1=m2", |
|
287 "--module", "m2"); |
|
288 checkModulesSpecified("m2"); |
|
289 checkPackagesIncluded("pkg2"); |
|
290 checkMembersSelected("pkg2.B.f"); |
|
291 } |
|
292 |
|
293 // @Test @ignore JDK-8166379 |
|
294 public void testPatchModuleOption(Path base) throws Exception { |
|
295 Path src = base.resolve("src"); |
|
296 Path modulePath = base.resolve("modules"); |
|
297 Path patchPath = base.resolve("patch"); |
|
298 |
|
299 ModuleBuilder mb1 = new ModuleBuilder(tb, "m1"); |
|
300 mb1.comment("Module on module path.") |
|
301 .exports("pkg1") |
|
302 .classes("package pkg1; /** Class A */ public class A { }") |
|
303 .build(modulePath); |
|
304 |
|
305 tb.writeJavaFiles(patchPath, "package pkg1; /** Class A */ public class A { public static int k; }"); |
|
306 new JavacTask(tb) |
|
307 .files(patchPath.resolve("pkg1/A.java")) |
|
308 .run(); |
|
309 |
|
310 ModuleBuilder mb2 = new ModuleBuilder(tb, "m2"); |
|
311 mb2.comment("The second module.") |
|
312 .exports("pkg2") |
|
313 .requires("m1") |
|
314 .classes("package pkg2; /** Class B */ public class B { /** Field f */ public int f = pkg1.A.k; }") |
|
315 .write(src); |
|
316 execTask("--module-source-path", src.toString(), |
|
317 "--patch-module", "m1=" + patchPath.toString(), |
|
318 "--module-path", modulePath.toString(), |
|
319 "--module", "m2"); |
|
320 checkModulesSpecified("m2"); |
|
321 checkPackagesIncluded("pkg2"); |
|
322 checkMembersSelected("pkg2.B.f"); |
|
323 } |
|
324 |
|
325 @Test |
|
326 public void testAddReadsOption(Path base) throws Exception { |
|
327 Path src = base.resolve("src"); |
|
328 Path modulePath = base.resolve("modules"); |
|
329 |
|
330 ModuleBuilder mb1 = new ModuleBuilder(tb, "m1"); |
|
331 mb1.comment("Module on module path.") |
|
332 .exports("pkg1") |
|
333 .classes("package pkg1; /** Class A */ public class A {}") |
|
334 .build(modulePath); |
|
335 |
|
336 ModuleBuilder mb2 = new ModuleBuilder(tb, "m2"); |
|
337 mb2.comment("The second module.") |
|
338 .exports("pkg2") |
|
339 .classes("package pkg2; /** Class B */ public class B { /** Field f */ public pkg1.A f;}") |
|
340 .write(src); |
|
341 execTask("--module-source-path", src.toString(), |
|
342 "--module-path", modulePath.toString(), |
|
343 "--add-modules", "m1", |
|
344 "--add-reads", "m2=m1", |
|
345 "--module", "m2"); |
|
346 checkModulesSpecified("m2"); |
|
347 checkPackagesIncluded("pkg2"); |
|
348 checkMembersSelected("pkg2.B.f"); |
|
349 } |
|
350 |
|
351 @Test |
|
352 public void testModuleOptionsWithLegacy(Path base) throws Exception { |
|
353 Files.createDirectory(base); |
|
354 Path src = base.resolve("src"); |
|
355 Path classpath = base.resolve("classpath"); |
|
356 Path modulePath = base.resolve("modules"); |
|
357 |
|
358 tb.writeJavaFiles(classpath, "package pkg1; /** Class C */ public class C { }"); |
|
359 new JavacTask(tb) |
|
360 .files(classpath.resolve("pkg1/C.java")) |
|
361 .run(); |
|
362 |
|
363 ModuleBuilder mb = new ModuleBuilder(tb, "m1"); |
|
364 mb.comment("The first module.") |
|
365 .exports("pub") |
|
366 .classes("package pub; /** Class M */ public class M { }") |
|
367 .build(modulePath); |
|
368 |
|
369 tb.writeJavaFiles(src, "package pkg; /** Class L */ public class L { public pkg1.C f1; public pub.M f2; }"); |
|
370 |
|
371 execTask("--source-path", src.toString(), |
|
372 "--class-path", classpath.toString(), |
|
373 "--module-path", modulePath.toString(), |
|
374 "--add-modules", "m1", |
|
375 "pkg"); |
|
376 checkPackagesIncluded("pkg"); |
|
377 checkTypesIncluded("pkg.L"); |
|
378 checkMembersSelected("pkg.L.f1"); |
|
379 checkMembersSelected("pkg.L.f2"); |
|
380 assertAbsent("error", OutputKind.DIRECT); |
|
381 } |
|
382 |
|
383 /** |
121 * Tests diamond graph, inspired by javac diamond tests. |
384 * Tests diamond graph, inspired by javac diamond tests. |
122 * |
385 * |
123 * |
386 * |
124 * Module M : test module, with variable requires |
387 * Module M : test module, with variable requires |
125 * |
388 * |
260 void createAuxiliaryModules(Path src) throws IOException { |
523 void createAuxiliaryModules(Path src) throws IOException { |
261 |
524 |
262 new ModuleBuilder(tb, "J") |
525 new ModuleBuilder(tb, "J") |
263 .comment("The J module.") |
526 .comment("The J module.") |
264 .exports("openJ") |
527 .exports("openJ") |
265 .classes("package openJ; /** Klass J open. */ public class J { }") |
528 .classes("package openJ; /** Class J open. */ public class J { }") |
266 .classes("package closedJ; /** Klass J closed. */ public class J { }") |
529 .classes("package closedJ; /** Class J closed. */ public class J { }") |
267 .write(src); |
530 .write(src); |
268 |
531 |
269 new ModuleBuilder(tb, "L") |
532 new ModuleBuilder(tb, "L") |
270 .comment("The L module.") |
533 .comment("The L module.") |
271 .exports("openL") |
534 .exports("openL") |
272 .requiresPublic("P") |
535 .requiresPublic("P") |
273 .classes("package openL; /** Klass L open */ public class L { }") |
536 .classes("package openL; /** Class L open */ public class L { }") |
274 .classes("package closedL; /** Klass L closed */ public class L { }") |
537 .classes("package closedL; /** Class L closed */ public class L { }") |
275 .write(src); |
538 .write(src); |
276 |
539 |
277 new ModuleBuilder(tb, "N") |
540 new ModuleBuilder(tb, "N") |
278 .comment("The N module.") |
541 .comment("The N module.") |
279 .exports("openN") |
542 .exports("openN") |
280 .requiresPublic("O") |
543 .requiresPublic("O") |
281 .classes("package openN; /** Klass N open */ public class N { }") |
544 .classes("package openN; /** Class N open */ public class N { }") |
282 .classes("package closedN; /** Klass N closed */ public class N { }") |
545 .classes("package closedN; /** Class N closed */ public class N { }") |
283 .write(src); |
546 .write(src); |
284 |
547 |
285 new ModuleBuilder(tb, "O") |
548 new ModuleBuilder(tb, "O") |
286 .comment("The O module.") |
549 .comment("The O module.") |
287 .exports("openO") |
550 .exports("openO") |
288 .requires("J") |
551 .requires("J") |
289 .classes("package openO; /** Klass O open. */ public class O { openJ.J j; }") |
552 .classes("package openO; /** Class O open. */ public class O { openJ.J j; }") |
290 .classes("package closedO; /** Klass O closed. */ public class O { }") |
553 .classes("package closedO; /** Class O closed. */ public class O { }") |
291 .write(src); |
554 .write(src); |
292 |
555 |
293 new ModuleBuilder(tb, "P") |
556 new ModuleBuilder(tb, "P") |
294 .comment("The O module.") |
557 .comment("The O module.") |
295 .exports("openP") |
558 .exports("openP") |
296 .requires("J") |
559 .requires("J") |
297 .classes("package openP; /** Klass O open. */ public class O { openJ.J j; }") |
560 .classes("package openP; /** Class O open. */ public class O { openJ.J j; }") |
298 .classes("package closedP; /** Klass O closed. */ public class O { }") |
561 .classes("package closedP; /** Class O closed. */ public class O { }") |
299 .write(src); |
562 .write(src); |
300 |
563 |
301 new ModuleBuilder(tb, "Q") |
564 new ModuleBuilder(tb, "Q") |
302 .comment("The Q module.") |
565 .comment("The Q module.") |
303 .exports("openQ") |
566 .exports("openQ") |
304 .requires("J") |
567 .requires("J") |
305 .classes("package openQ; /** Klass Q open. */ public class Q { openJ.J j; }") |
568 .classes("package openQ; /** Class Q open. */ public class Q { openJ.J j; }") |
306 .classes("package closedQ; /** Klass Q closed. */ public class Q { }") |
569 .classes("package closedQ; /** Class Q closed. */ public class Q { }") |
307 .write(src); |
570 .write(src); |
308 |
571 |
309 } |
572 } |
310 } |
573 } |