AddModulesTest.java revision 3778:f6ae0686d664 
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 Test the --add-modules option
27 * @library /tools/lib
28 * @modules jdk.compiler/com.sun.tools.javac.api
29 *          jdk.compiler/com.sun.tools.javac.main
30 * @build toolbox.ToolBox toolbox.JavacTask ModuleTestBase
31 * @run main AddModulesTest
32 */
33
34
35import java.nio.file.Path;
36
37import toolbox.JavacTask;
38import toolbox.Task;
39import toolbox.ToolBox;
40
41public class AddModulesTest extends ModuleTestBase {
42    public static void main(String... args) throws Exception {
43        new AddModulesTest().runTests();
44    }
45
46    @Test
47    public void testEmpty(Path base) throws Exception {
48        Path src = base.resolve("src");
49        tb.writeJavaFiles(src, "class Dummy { }");
50        Path classes = base.resolve("classes");
51        tb.createDirectories(classes);
52
53        testEmpty(src, classes, "--add-modules", "");
54        testEmpty(src, classes, "--add-modules=");
55    }
56
57    private void testEmpty(Path src, Path classes, String... options) throws Exception {
58        String log = new JavacTask(tb, Task.Mode.CMDLINE)
59                .options(options)
60                .outdir(classes)
61                .files(findJavaFiles(src))
62                .run(Task.Expect.FAIL)
63                .writeAll()
64                .getOutput(Task.OutputKind.DIRECT);
65
66        checkOutputContains(log,
67            "javac: no value for --add-modules option");
68    }
69
70    @Test
71    public void testEmptyItem(Path base) throws Exception {
72        Path src = base.resolve("src");
73        Path src_m1 = src.resolve("m1");
74        tb.writeJavaFiles(src_m1,
75                          "module m1 { }");
76        Path src_m2 = src.resolve("m2");
77        tb.writeJavaFiles(src_m2,
78                          "module m2 { }");
79        Path classes = base.resolve("classes");
80        tb.createDirectories(classes);
81
82        testEmptyItem(src, classes, ",m1");
83        testEmptyItem(src, classes, "m1,,m2");
84        testEmptyItem(src, classes, "m1,");
85    }
86
87    private void testEmptyItem(Path src, Path classes, String option) throws Exception {
88        new JavacTask(tb)
89                .options("--module-source-path", src.toString(),
90                         "--add-modules", option)
91                .outdir(classes)
92                .files(findJavaFiles(src))
93                .run()
94                .writeAll();
95    }
96
97    @Test
98    public void testEmptyList(Path base) throws Exception {
99        Path src = base.resolve("src");
100        tb.writeJavaFiles(src, "class Dummy { }");
101        Path classes = base.resolve("classes");
102        tb.createDirectories(classes);
103
104        String log = new JavacTask(tb, Task.Mode.CMDLINE)
105                .options("--module-source-path", src.toString(),
106                         "--add-modules", ",")
107                .outdir(classes)
108                .files(findJavaFiles(src))
109                .run(Task.Expect.FAIL)
110                .writeAll()
111                .getOutput(Task.OutputKind.DIRECT);
112
113        checkOutputContains(log,
114            "javac: bad value for --add-modules option");
115    }
116
117    @Test
118    public void testInvalidName(Path base) throws Exception {
119        Path src = base.resolve("src");
120        tb.writeJavaFiles(src, "class Dummy { }");
121        Path classes = base.resolve("classes");
122        tb.createDirectories(classes);
123
124        String log = new JavacTask(tb)
125                .options("-XDrawDiagnostics",
126                         "--add-modules", "BadModule!")
127                .outdir(classes)
128                .files(findJavaFiles(src))
129                .run(Task.Expect.FAIL)
130                .writeAll()
131                .getOutput(Task.OutputKind.DIRECT);
132
133        checkOutputContains(log,
134            "- compiler.err.bad.name.for.option: --add-modules, BadModule!");
135    }
136
137    @Test
138    public void testUnknownName(Path base) throws Exception {
139        Path src = base.resolve("src");
140        tb.writeJavaFiles(src, "class Dummy { }");
141        Path classes = base.resolve("classes");
142        tb.createDirectories(classes);
143
144        String log = new JavacTask(tb)
145                .options("-XDrawDiagnostics",
146                         "--add-modules", "DoesNotExist")
147                .outdir(classes)
148                .files(findJavaFiles(src))
149                .run(Task.Expect.FAIL)
150                .writeAll()
151                .getOutput(Task.OutputKind.DIRECT);
152
153        checkOutputContains(log,
154            "- compiler.err.module.not.found: DoesNotExist");
155    }
156
157    @Test
158    public void testDuplicate(Path base) throws Exception {
159        Path src = base.resolve("src");
160
161        // setup a utility module
162        Path src_m1 = src.resolve("m1");
163        tb.writeJavaFiles(src_m1,
164                          "module m1 { exports p1; }",
165                          "package p1; public class C1 { }");
166        Path modules = base.resolve("modules");
167        tb.createDirectories(modules);
168
169        new JavacTask(tb)
170                .options("--module-source-path", src.toString())
171                .outdir(modules)
172                .files(findJavaFiles(src))
173                .run()
174                .writeAll();
175
176        // now test access to the module
177        Path src2 = base.resolve("src2");
178        tb.writeJavaFiles(src2,
179                          "class Dummy { p1.C1 c1; }");
180        Path classes = base.resolve("classes");
181        tb.createDirectories(classes);
182
183        new JavacTask(tb)
184                .options("--module-path", modules.toString(),
185                         "--add-modules", "m1,m1")
186                .outdir(classes)
187                .files(findJavaFiles(src2))
188                .run()
189                .writeAll();
190    }
191
192    @Test
193    public void testRepeatable(Path base) throws Exception {
194        Path src = base.resolve("src");
195
196        // setup some utility modules
197        Path src_m1 = src.resolve("m1");
198        tb.writeJavaFiles(src_m1,
199                          "module m1 { exports p1; }",
200                          "package p1; public class C1 { }");
201        Path src_m2 = src.resolve("m2");
202        tb.writeJavaFiles(src_m2,
203                          "module m2 { exports p2; }",
204                          "package p2; public class C2 { }");
205        Path modules = base.resolve("modules");
206        tb.createDirectories(modules);
207
208        new JavacTask(tb)
209                .options("--module-source-path", src.toString())
210                .outdir(modules)
211                .files(findJavaFiles(src))
212                .run()
213                .writeAll();
214
215        // now test access to the modules
216        Path src2 = base.resolve("src2");
217        tb.writeJavaFiles(src2,
218                          "class Dummy { p1.C1 c1; p2.C2 c2; }");
219        Path classes = base.resolve("classes");
220        tb.createDirectories(classes);
221
222        new JavacTask(tb)
223                .options("--module-path", modules.toString(),
224                         "--add-modules", "m1",
225                         "--add-modules", "m2")
226                .outdir(classes)
227                .files(findJavaFiles(src2))
228                .run()
229                .writeAll();
230    }
231}
232
233