| /* |
| * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /* |
| * @test |
| * @bug 8159305 8166127 8175860 8176481 |
| * @summary Tests primarily the module graph computations. |
| * @modules |
| * jdk.javadoc/jdk.javadoc.internal.api |
| * jdk.javadoc/jdk.javadoc.internal.tool |
| * jdk.compiler/com.sun.tools.javac.api |
| * jdk.compiler/com.sun.tools.javac.main |
| * @library /tools/lib |
| * @build toolbox.ToolBox toolbox.TestRunner |
| * @run main Modules |
| */ |
| |
| import java.io.IOException; |
| import java.nio.file.Files; |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| |
| import toolbox.*; |
| import toolbox.Task.Expect; |
| import toolbox.Task.OutputKind; |
| |
| public class Modules extends ModuleTestBase { |
| |
| public static void main(String... args) throws Exception { |
| new Modules().runTests(); |
| } |
| |
| @Test |
| public void testBasicMoption(Path base) throws Exception { |
| Files.createDirectory(base); |
| Path src = base.resolve("src"); |
| ModuleBuilder mb = new ModuleBuilder(tb, "m1"); |
| mb.comment("The first module.") |
| .exports("pub") |
| .classes("package pub; /** Class A */ public class A {}") |
| .classes("package pro; /** Class B */ public class B {}") |
| .write(src); |
| execTask("--module-source-path", src.toString(), |
| "--module", "m1"); |
| checkModulesSpecified("m1"); |
| checkPackagesIncluded("pub"); |
| checkTypesIncluded("pub.A"); |
| } |
| |
| @Test |
| public void testMultipleModulesOption1(Path base) throws Exception { |
| Path src = base.resolve("src"); |
| |
| ModuleBuilder mb1 = new ModuleBuilder(tb, "m1"); |
| mb1.comment("The first module.") |
| .exports("m1pub") |
| .requires("m2") |
| .classes("package m1pub; /** Class A */ public class A {}") |
| .classes("package m1pro; /** Class B */ public class B {}") |
| .write(src); |
| |
| ModuleBuilder mb2 = new ModuleBuilder(tb, "m2"); |
| mb2.comment("The second module.") |
| .exports("m2pub") |
| .classes("package m2pub; /** Class A */ public class A {}") |
| .classes("package m2pro; /** Class B */ public class B {}") |
| .write(src); |
| execTask("--module-source-path", src.toString(), |
| "--module", "m1,m2"); |
| checkModulesSpecified("m1", "m2"); |
| checkPackagesIncluded("m1pub", "m2pub"); |
| checkTypesIncluded("m1pub.A", "m2pub.A"); |
| |
| } |
| |
| @Test |
| public void testMissingModuleWithSourcePath(Path base) throws Exception { |
| Path src = base.resolve("src"); |
| Path mod = src.resolve("m1"); |
| |
| ModuleBuilder mb1 = new ModuleBuilder(tb, "m1"); |
| mb1.comment("The first module.") |
| .exports("m1pub") |
| .requires("m2") |
| .classes("package m1pub; /** Class A */ public class A {}") |
| .classes("package m1pro; /** Class B */ public class B {}") |
| .write(src); |
| |
| Path javafile = Paths.get(mod.toString(), "m1pub/A.java"); |
| |
| execNegativeTask("--source-path", mod.toString(), |
| javafile.toString()); |
| |
| assertMessagePresent("error: cannot access module-info"); |
| assertMessageNotPresent("error - fatal error encountered"); |
| |
| } |
| |
| @Test |
| public void testMultipleModulesAggregatedModuleOption(Path base) throws Exception { |
| Path src = base.resolve("src"); |
| |
| ModuleBuilder mb1 = new ModuleBuilder(tb, "m1"); |
| mb1.comment("The first module.") |
| .exports("m1pub") |
| .requires("m2") |
| .classes("package m1pub; /** Class A */ public class A {}") |
| .classes("package m1pro; /** Class B */ public class B {}") |
| .write(src); |
| |
| ModuleBuilder mb2 = new ModuleBuilder(tb, "m2"); |
| mb2.comment("The second module.") |
| .exports("m2pub") |
| .classes("package m2pub; /** Class A */ public class A {}") |
| .classes("package m2pro; /** Class B */ public class B {}") |
| .write(src); |
| execTask("--module-source-path", src.toString(), |
| "--module", "m1", |
| "--module", "m2"); |
| checkModulesSpecified("m1", "m2"); |
| checkPackagesIncluded("m1pub", "m2pub"); |
| checkTypesIncluded("m1pub.A", "m2pub.A"); |
| |
| } |
| |
| @Test |
| public void testModulePathOption(Path base) throws Exception { |
| Path src = base.resolve("src"); |
| Path modulePath = base.resolve("modules"); |
| |
| ModuleBuilder mb1 = new ModuleBuilder(tb, "m1"); |
| mb1.comment("Module on module path.") |
| .exports("pkg1") |
| .classes("package pkg1; /** Class A */ public class A { }") |
| .build(modulePath); |
| |
| ModuleBuilder mb2 = new ModuleBuilder(tb, "m2"); |
| mb2.comment("The second module.") |
| .exports("pkg2") |
| .requires("m1") |
| .classes("package pkg2; /** Class B */ public class B { /** Field f */ public pkg1.A f; }") |
| .write(src); |
| execTask("--module-source-path", src.toString(), |
| "--module-path", modulePath.toString(), |
| "--module", "m2"); |
| checkModulesSpecified("m2"); |
| checkPackagesIncluded("pkg2"); |
| checkMembersSelected("pkg2.B.f"); |
| |
| // module path option "-p" |
| execTask("--module-source-path", src.toString(), |
| "-p", modulePath.toString(), |
| "--module", "m2"); |
| // no module path |
| execNegativeTask("--module-source-path", src.toString(), |
| "--module", "m2"); |
| assertMessagePresent("error: module not found: m1"); |
| } |
| |
| @Test |
| public void testUpgradeModulePathOption(Path base) throws Exception { |
| Path src = base.resolve("src"); |
| Path modulePath = base.resolve("modules"); |
| Path upgradePath = base.resolve("upgrades"); |
| |
| ModuleBuilder mb1 = new ModuleBuilder(tb, "m1"); |
| mb1.comment("Module on module path.") |
| .exports("pkg1") |
| .classes("package pkg1; /** Class A */ public class A { }") |
| .build(modulePath); |
| |
| ModuleBuilder mbUpgrade = new ModuleBuilder(tb, "m1"); |
| mbUpgrade.comment("Module on upgrade module path.") |
| .exports("pkg1") |
| .classes("package pkg1; /** Class C */ public class C { }") |
| .build(upgradePath); |
| |
| ModuleBuilder mb2 = new ModuleBuilder(tb, "m2"); |
| mb2.comment("The second module.") |
| .exports("pkg2") |
| .requires("m1") |
| .classes("package pkg2; /** Class B */ public class B { /** Field f */ public pkg1.C f; }") |
| .write(src); |
| execTask("--module-source-path", src.toString(), |
| "--module-path", modulePath.toString(), |
| "--upgrade-module-path", upgradePath.toString(), |
| "--module", "m2"); |
| checkModulesSpecified("m2"); |
| checkPackagesIncluded("pkg2"); |
| checkMembersSelected("pkg2.B.f"); |
| |
| // no upgrade module path |
| execNegativeTask("--module-source-path", src.toString(), |
| "--module-path", modulePath.toString(), |
| "--module", "m2"); |
| assertMessagePresent("error: cannot find symbol"); |
| |
| // dependency from module path |
| ModuleBuilder mb3 = new ModuleBuilder(tb, "m3"); |
| mb3.comment("The third module.") |
| .exports("pkg3") |
| .requires("m1") |
| .classes("package pkg3; /** Class Z */ public class Z { /** Field f */ public pkg1.A f; }") |
| .write(src); |
| execNegativeTask("--module-source-path", src.toString(), |
| "--module-path", modulePath.toString(), |
| "--upgrade-module-path", upgradePath.toString(), |
| "--module", "m3"); |
| assertMessagePresent("Z.java:1: error: cannot find symbol"); |
| } |
| |
| @Test |
| public void testAddModulesOption(Path base) throws Exception { |
| Path src = base.resolve("src"); |
| Path modulePath = base.resolve("modules"); |
| |
| ModuleBuilder mb1 = new ModuleBuilder(tb, "m1"); |
| mb1.comment("Module on module path.") |
| .exports("pkg1") |
| .classes("package pkg1; /** Class A */ public class A { }") |
| .build(modulePath); |
| |
| ModuleBuilder mb2 = new ModuleBuilder(tb, "m2"); |
| mb2.comment("The second module.") |
| .exports("pkg2") |
| .classes("package pkg2; /** @see pkg1.A */ public class B { }") |
| .write(src); |
| |
| Path out = base.resolve("out-1"); |
| Files.createDirectories(out); |
| String log = new JavadocTask(tb) |
| .outdir(out) |
| .options("--module-source-path", src.toString(), |
| "--module-path", modulePath.toString(), |
| "--module", "m2") |
| .run(Expect.FAIL) |
| .writeAll() |
| .getOutput(OutputKind.DIRECT); |
| if (!log.contains("B.java:1: error: reference not found")) { |
| throw new Exception("Error not found"); |
| } |
| |
| out = base.resolve("out-2"); |
| Files.createDirectories(out); |
| new JavadocTask(tb) |
| .outdir(out) |
| .options("--module-source-path", src.toString(), |
| "--module-path", modulePath.toString(), |
| "--add-modules", "m1", |
| "--module", "m2") |
| .run() |
| .writeAll(); |
| } |
| |
| @Test |
| public void testLimitModulesOption(Path base) throws Exception { |
| Path src = base.resolve("src"); |
| Path modulePath = base.resolve("modules"); |
| |
| ModuleBuilder mb1 = new ModuleBuilder(tb, "m1"); |
| mb1.comment("Module on module path.") |
| .build(modulePath); |
| |
| ModuleBuilder mb2 = new ModuleBuilder(tb, "m2"); |
| mb2.comment("The second module.") |
| .exports("pkg2") |
| .requires("m1") |
| .classes("package pkg2; /** Class B */ public class B { }") |
| .write(src); |
| |
| execNegativeTask("--module-source-path", src.toString(), |
| "--module-path", modulePath.toString(), |
| "--limit-modules", "java.base", |
| "--module", "m2"); |
| assertMessagePresent("error: module not found: m1"); |
| } |
| |
| @Test |
| public void testAddExportsOption(Path base) throws Exception { |
| Path src = base.resolve("src"); |
| Path modulePath = base.resolve("modules"); |
| |
| ModuleBuilder mb1 = new ModuleBuilder(tb, "m1"); |
| mb1.comment("Module on module path.") |
| .classes("package pkg1; /** Class A */ public class A { }") |
| .build(modulePath); |
| |
| ModuleBuilder mb2 = new ModuleBuilder(tb, "m2"); |
| mb2.comment("The second module.") |
| .exports("pkg2") |
| .requires("m1") |
| .classes("package pkg2; /** Class B */ public class B { /** Field f */ public pkg1.A f; }") |
| .write(src); |
| execTask("--module-source-path", src.toString(), |
| "--module-path", modulePath.toString(), |
| "--add-exports", "m1/pkg1=m2", |
| "--module", "m2"); |
| checkModulesSpecified("m2"); |
| checkPackagesIncluded("pkg2"); |
| checkMembersSelected("pkg2.B.f"); |
| } |
| |
| @Test |
| public void testAddReadsOption(Path base) throws Exception { |
| Path src = base.resolve("src"); |
| Path modulePath = base.resolve("modules"); |
| |
| ModuleBuilder mb1 = new ModuleBuilder(tb, "m1"); |
| mb1.comment("Module on module path.") |
| .exports("pkg1") |
| .classes("package pkg1; /** Class A */ public class A {}") |
| .build(modulePath); |
| |
| ModuleBuilder mb2 = new ModuleBuilder(tb, "m2"); |
| mb2.comment("The second module.") |
| .exports("pkg2") |
| .classes("package pkg2; /** Class B */ public class B { /** Field f */ public pkg1.A f;}") |
| .write(src); |
| execTask("--module-source-path", src.toString(), |
| "--module-path", modulePath.toString(), |
| "--add-modules", "m1", |
| "--add-reads", "m2=m1", |
| "--module", "m2"); |
| checkModulesSpecified("m2"); |
| checkPackagesIncluded("pkg2"); |
| checkMembersSelected("pkg2.B.f"); |
| } |
| |
| @Test |
| public void testModuleOptionsWithLegacy(Path base) throws Exception { |
| Files.createDirectory(base); |
| Path src = base.resolve("src"); |
| Path classpath = base.resolve("classpath"); |
| Path modulePath = base.resolve("modules"); |
| |
| tb.writeJavaFiles(classpath, "package pkg1; /** Class C */ public class C { }"); |
| new JavacTask(tb) |
| .files(classpath.resolve("pkg1/C.java")) |
| .run(); |
| |
| ModuleBuilder mb = new ModuleBuilder(tb, "m1"); |
| mb.comment("The first module.") |
| .exports("pub") |
| .classes("package pub; /** Class M */ public class M { }") |
| .build(modulePath); |
| |
| tb.writeJavaFiles(src, "package pkg; /** Class L */ public class L { public pkg1.C f1; public pub.M f2; }"); |
| |
| execTask("--source-path", src.toString(), |
| "--class-path", classpath.toString(), |
| "--module-path", modulePath.toString(), |
| "--add-modules", "m1", |
| "pkg"); |
| checkPackagesIncluded("pkg"); |
| checkTypesIncluded("pkg.L"); |
| checkMembersSelected("pkg.L.f1"); |
| checkMembersSelected("pkg.L.f2"); |
| assertAbsent("error", OutputKind.DIRECT); |
| } |
| |
| /** |
| * Tests diamond graph, inspired by javac diamond tests. |
| * |
| * |
| * Module M : test module, with variable requires |
| * |
| * Module N : |
| * requires transitive O ---> Module O: |
| * requires J ----> Module J: |
| * exports openO exports openJ |
| * |
| * |
| * Module L : |
| * requires transitive P ---> Module P: |
| * exports openP |
| * |
| * |
| */ |
| |
| @Test |
| public void testExpandRequiresNone(Path base) throws Exception { |
| Path src = base.resolve("src"); |
| |
| createAuxiliaryModules(src); |
| |
| new ModuleBuilder(tb, "M") |
| .comment("The M module.") |
| .requires("N", src) |
| .requires("L", src) |
| .requires("O", src) |
| .exports("p") |
| .classes("package p; public class Main { openO.O o; openN.N n; openL.L l; }") |
| .write(src); |
| |
| execTask("--module-source-path", src.toString(), |
| "--module", "M"); |
| |
| checkModulesSpecified("M"); |
| checkModulesIncluded("M"); |
| checkPackagesIncluded("p"); |
| checkTypesIncluded("p.Main"); |
| checkPackagesNotIncluded(".*open.*"); |
| assertMessageNotPresent("warning"); |
| } |
| |
| @Test |
| public void testExpandRequiresTransitive(Path base) throws Exception { |
| Path src = base.resolve("src"); |
| |
| createAuxiliaryModules(src); |
| |
| new ModuleBuilder(tb, "M") |
| .comment("The M module.") |
| .requiresTransitive("N", src) |
| .requires("L", src) |
| .exports("p") |
| .classes("package p; public class Main { openO.O o; openN.N n; openL.L l; }") |
| .write(src); |
| |
| execTask("--module-source-path", src.toString(), |
| "--module", "M", |
| "--expand-requires", "transitive"); |
| |
| checkModulesSpecified("M", "N", "O"); |
| checkModulesNotSpecified("java.base"); |
| checkModulesIncluded("M", "N", "O"); |
| checkModulesNotIncluded("java.base"); |
| checkPackagesIncluded("p", "openN", "openO"); |
| checkTypesIncluded("p.Main", "openN.N", "openO.O"); |
| assertMessageNotPresent("warning"); |
| } |
| |
| @Test |
| public void testExpandRequiresTransitiveWithMandated(Path base) throws Exception { |
| Path src = base.resolve("src"); |
| |
| createAuxiliaryModules(src); |
| |
| Path patchSrc = Paths.get(src.toString(), "patch"); |
| |
| new ModuleBuilder(tb, "M") |
| .comment("The M module.") |
| .requiresTransitive("N", src) |
| .requires("L", src) |
| .exports("p") |
| .classes("package p; public class Main { openO.O o; openN.N n; openL.L l; }") |
| .write(src); |
| |
| // build the patching module |
| tb.writeJavaFiles(patchSrc, "package pkg1;\n" + |
| "/** Class A */ public class A extends java.util.ArrayList { }"); |
| tb.writeJavaFiles(patchSrc, "package pkg1;\n" |
| + "/** Class B */ public class B { }"); |
| |
| execTask("--module-source-path", src.toString(), |
| "--patch-module", "java.base=" + patchSrc.toString(), |
| "--module", "M", |
| "--expand-requires", "transitive"); |
| |
| checkModulesSpecified("java.base", "M", "N", "O"); |
| checkModulesIncluded("java.base", "M", "N", "O"); |
| checkPackagesIncluded("p", "openN", "openO"); |
| checkTypesIncluded("p.Main", "openN.N", "openO.O"); |
| assertMessageNotPresent("warning"); |
| } |
| |
| @Test |
| public void testExpandRequiresAll(Path base) throws Exception { |
| Path src = base.resolve("src"); |
| |
| createAuxiliaryModules(src); |
| |
| new ModuleBuilder(tb, "M") |
| .comment("The M module.") |
| .requiresTransitive("N", src) |
| .requires("L", src) |
| .requires("O", src) |
| .exports("p") |
| .classes("package p; public class Main { openO.O o; openN.N n; openL.L l; }") |
| .write(src); |
| |
| execTask("--module-source-path", src.toString(), |
| "--module", "M", |
| "--expand-requires", "all"); |
| |
| checkModulesSpecified("M", "N", "L", "O"); |
| checkModulesIncluded("M", "N", "L", "O"); |
| checkModulesNotIncluded("P", "J", "Q"); |
| checkPackagesIncluded("p", "openN", "openL", "openO"); |
| checkPackagesNotIncluded(".*openP.*", ".*openJ.*"); |
| checkTypesIncluded("p.Main", "openN.N", "openL.L", "openO.O"); |
| checkTypesNotIncluded(".*openP.*", ".*openJ.*"); |
| assertMessageNotPresent("warning"); |
| } |
| |
| @Test |
| public void testMissingModule(Path base) throws Exception { |
| Path src = base.resolve("src"); |
| |
| createAuxiliaryModules(src); |
| |
| new ModuleBuilder(tb, "M") |
| .comment("The M module.") |
| .requiresTransitive("N", src) |
| .requires("L", src) |
| .requires("O", src) |
| .exports("p") |
| .classes("package p; public class Main { openO.O o; openN.N n; openL.L l; }") |
| .write(src); |
| |
| execNegativeTask("--module-source-path", src.toString(), |
| "--module", "MIA", |
| "--expand-requires", "all"); |
| |
| assertMessagePresent("javadoc: error - module MIA not found."); |
| } |
| |
| @Test |
| public void testMissingModuleMultiModuleCmdline(Path base) throws Exception { |
| Path src = base.resolve("src"); |
| |
| createAuxiliaryModules(src); |
| |
| new ModuleBuilder(tb, "M") |
| .comment("The M module.") |
| .requiresTransitive("N", src) |
| .requires("L", src) |
| .requires("O", src) |
| .exports("p") |
| .classes("package p; public class Main { openO.O o; openN.N n; openL.L l; }") |
| .write(src); |
| |
| execNegativeTask("--module-source-path", src.toString(), |
| "--module", "M,N,L,MIA,O,P", |
| "--expand-requires", "all"); |
| |
| assertMessagePresent("javadoc: error - module MIA not found"); |
| } |
| |
| @Test |
| public void testSingleModuleOptionWithSourcePath(Path base) throws Exception { |
| Path src = base.resolve("src"); |
| Path mod = createSimpleModule(src, "m1"); |
| execTask("--source-path", mod.toString(), |
| "--module", "m1"); |
| checkModulesSpecified("m1"); |
| checkPackagesIncluded("p"); |
| checkTypesIncluded("p.C"); |
| } |
| |
| @Test |
| public void testSingleModuleOptionWithMissingModuleInSourcePath(Path base) throws Exception { |
| Path src = base.resolve("src"); |
| Path mod = createSimpleModule(src, "m1"); |
| execNegativeTask("--source-path", mod.toString(), |
| "--module", "m2"); |
| assertMessagePresent("source path does not contain module m2"); |
| } |
| |
| @Test |
| public void testMultipleModuleOptionWithSourcePath(Path base) throws Exception { |
| Path src = base.resolve("src"); |
| Path mod = createSimpleModule(src, "m1"); |
| execNegativeTask("--source-path", mod.toString(), |
| "--module", "m1,m2,m3"); |
| assertMessagePresent("cannot use source path for multiple modules m1, m2, m3"); |
| } |
| |
| @Test |
| public void testSingleModuleOptionWithNoModuleOnSourcePath(Path base) throws Exception { |
| Path src = base.resolve("src"); |
| Path mod1 = Paths.get(src.toString(), "m1"); |
| execNegativeTask("--source-path", mod1.toString(), |
| "--module", "m1"); |
| assertMessagePresent("module m1 not found on source path"); |
| } |
| |
| Path createSimpleModule(Path src, String mname) throws IOException { |
| Path mpath = Paths.get(src.toString(), mname); |
| tb.writeJavaFiles(mpath, |
| "module " + mname + " { exports p; }", |
| "package p; public class C { }"); |
| return mpath; |
| } |
| |
| void createAuxiliaryModules(Path src) throws IOException { |
| |
| new ModuleBuilder(tb, "J") |
| .comment("The J module.") |
| .exports("openJ") |
| .classes("package openJ; /** Class J open. */ public class J { }") |
| .classes("package closedJ; /** Class J closed. */ public class J { }") |
| .write(src); |
| |
| new ModuleBuilder(tb, "L") |
| .comment("The L module.") |
| .exports("openL") |
| .requiresTransitive("P") |
| .classes("package openL; /** Class L open */ public class L { }") |
| .classes("package closedL; /** Class L closed */ public class L { }") |
| .write(src); |
| |
| new ModuleBuilder(tb, "N") |
| .comment("The N module.") |
| .exports("openN") |
| .requiresTransitive("O") |
| .classes("package openN; /** Class N open */ public class N { }") |
| .classes("package closedN; /** Class N closed */ public class N { }") |
| .write(src); |
| |
| new ModuleBuilder(tb, "O") |
| .comment("The O module.") |
| .exports("openO") |
| .requires("J") |
| .classes("package openO; /** Class O open. */ public class O { openJ.J j; }") |
| .classes("package closedO; /** Class O closed. */ public class O { }") |
| .write(src); |
| |
| new ModuleBuilder(tb, "P") |
| .comment("The P module.") |
| .exports("openP") |
| .requires("J") |
| .classes("package openP; /** Class O open. */ public class O { openJ.J j; }") |
| .classes("package closedP; /** Class O closed. */ public class O { }") |
| .write(src); |
| |
| new ModuleBuilder(tb, "Q") |
| .comment("The Q module.") |
| .exports("openQ") |
| .requires("J") |
| .classes("package openQ; /** Class Q open. */ public class Q { openJ.J j; }") |
| .classes("package closedQ; /** Class Q closed. */ public class Q { }") |
| .write(src); |
| |
| } |
| } |
