AddExportsTest.java revision 3747:80b576bd3631 
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-exports 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 AddExportsTest
32 */
33
34import java.nio.file.Files;
35import java.nio.file.Path;
36import java.util.Set;
37
38import toolbox.JavacTask;
39import toolbox.Task;
40import toolbox.ToolBox;
41
42public class AddExportsTest extends ModuleTestBase {
43
44    public static void main(String... args) throws Exception {
45        new AddExportsTest().runTests();
46    }
47
48    @Test
49    public void testEmpty(Path base) throws Exception {
50        Path src = base.resolve("src");
51        tb.writeJavaFiles(src, "class Dummy { }");
52        Path classes = base.resolve("classes");
53        tb.createDirectories(classes);
54        testEmpty(src, classes, "--add-exports", "");
55        testEmpty(src, classes, "--add-exports=");
56    }
57
58    private void testEmpty(Path src, Path classes, String... options) throws Exception {
59        String log = new JavacTask(tb, Task.Mode.CMDLINE)
60                .options(options)
61                .outdir(classes)
62                .files(findJavaFiles(src))
63                .run(Task.Expect.FAIL)
64                .writeAll()
65                .getOutput(Task.OutputKind.DIRECT);
66
67        checkOutputContains(log,
68            "javac: no value for --add-exports option");
69    }
70
71    @Test
72    public void testEmptyItem(Path base) throws Exception {
73        Path src = base.resolve("src");
74        Path src_m1 = src.resolve("m1");
75        tb.writeJavaFiles(src_m1,
76                          "module m1 { }",
77                          "package p1; public class C1 { }");
78        Path src_m2 = src.resolve("m2");
79        tb.writeJavaFiles(src_m2,
80                          "module m2 { }",
81                          "package p2; class C2 { p1.C1 c1; }");
82        Path src_m3 = src.resolve("m3");
83        tb.writeJavaFiles(src_m3,
84                          "module m3 { }",
85                          "package p3; class C3 { p1.C1 c1; }");
86        Path classes = base.resolve("classes");
87        tb.createDirectories(classes);
88
89        testEmptyItem(src, classes, "m1/p1=,m2,m3");
90        testEmptyItem(src, classes, "m1/p1=m2,,m3");
91        testEmptyItem(src, classes, "m1/p1=m2,m3,");
92    }
93
94    void testEmptyItem(Path src, Path classes, String option) throws Exception {
95        new JavacTask(tb)
96                .options("--module-source-path", src.toString(),
97                         "--add-exports", option)
98                .outdir(classes)
99                .files(findJavaFiles(src))
100                .run()
101                .writeAll();
102    }
103
104    @Test
105    public void testEmptyList(Path base) throws Exception {
106        Path src = base.resolve("src");
107        Path src_m1 = src.resolve("m1");
108        tb.writeJavaFiles(src_m1,
109                          "module m1 { exports p1; }",
110                          "package p1; public class C1 { }");
111        Path classes = base.resolve("classes");
112        tb.createDirectories(classes);
113
114        testEmptyList(src, classes, "m1/p1=");
115        testEmptyList(src, classes, "m1/p1=,");
116    }
117
118    void testEmptyList(Path src, Path classes, String option) throws Exception {
119        String log = new JavacTask(tb, Task.Mode.CMDLINE)
120                .options("--module-source-path", src.toString(),
121                         "--add-exports", option)
122                .outdir(classes)
123                .files(findJavaFiles(src))
124                .run(Task.Expect.FAIL)
125                .writeAll()
126                .getOutput(Task.OutputKind.DIRECT);
127
128        checkOutputContains(log,
129            "javac: bad value for --add-exports option: '" + option + "'");
130    }
131
132    @Test
133    public void testMissingSourceParts(Path base) throws Exception {
134        Path src = base.resolve("src");
135        Path src_m1 = src.resolve("m1");
136        tb.writeJavaFiles(src_m1,
137                          "module m1 { exports p1; }",
138                          "package p1; public class C1 { }");
139        Path src_m2 = src.resolve("m2");
140        tb.writeJavaFiles(src_m2,
141                          "module m2 { }",
142                          "package p2; class C2 { p1.C1 c1; }");
143        Path classes = base.resolve("classes");
144        tb.createDirectories(classes);
145
146        testMissingSourcePart(src, classes, "=m2");
147        testMissingSourcePart(src, classes, "/=m2");
148        testMissingSourcePart(src, classes, "m1/=m2");
149        testMissingSourcePart(src, classes, "/p1=m2");
150        testMissingSourcePart(src, classes, "m1p1=m2");
151    }
152
153    private void testMissingSourcePart(Path src, Path classes, String option) throws Exception {
154        String log = new JavacTask(tb, Task.Mode.CMDLINE)
155                .options("--module-source-path", src.toString(),
156                         "--add-exports", option)
157                .outdir(classes)
158                .files(findJavaFiles(src))
159                .run(Task.Expect.FAIL)
160                .writeAll()
161                .getOutput(Task.OutputKind.DIRECT);
162
163        checkOutputContains(log,
164            "javac: bad value for --add-exports option: '" + option + "'");
165    }
166
167    @Test
168    public void testBadSourceParts(Path base) throws Exception {
169        Path src = base.resolve("src");
170        Path src_m1 = src.resolve("m1");
171        tb.writeJavaFiles(src_m1,
172                          "module m1 { exports p1; }",
173                          "package p1; public class C1 { }");
174        Path src_m2 = src.resolve("m2");
175        tb.writeJavaFiles(src_m2,
176                          "module m2 { }",
177                          "package p2; class C2 { p1.C1 c1; }");
178        Path classes = base.resolve("classes");
179        tb.createDirectories(classes);
180
181        testBadSourcePart(src, classes, "m!/p1=m2", "m!");
182        testBadSourcePart(src, classes, "m1/p!=m2", "p!");
183    }
184
185    private void testBadSourcePart(Path src, Path classes, String option, String badName)
186                throws Exception {
187        String log = new JavacTask(tb, Task.Mode.CMDLINE)
188                .options("-XDrawDiagnostics",
189                         "--module-source-path", src.toString(),
190                         "--add-exports", option)
191                .outdir(classes)
192                .files(findJavaFiles(src))
193                .run(Task.Expect.FAIL)
194                .writeAll()
195                .getOutput(Task.OutputKind.DIRECT);
196
197        checkOutputContains(log,
198            "- compiler.warn.bad.name.for.option: --add-exports, " + badName);
199    }
200
201    @Test
202    public void testBadTarget(Path base) throws Exception {
203        Path src = base.resolve("src");
204        Path src_m1 = src.resolve("m1");
205        tb.writeJavaFiles(src_m1,
206                          "module m1 { exports p1; }",
207                          "package p1; public class C1 { }");
208        Path classes = base.resolve("classes");
209        tb.createDirectories(classes);
210
211        String log = new JavacTask(tb, Task.Mode.CMDLINE)
212                .options("-XDrawDiagnostics",
213                         "--module-source-path", src.toString(),
214                         "--add-exports", "m1/p1=m!")
215                .outdir(classes)
216                .files(findJavaFiles(src))
217                .run()
218                .writeAll()
219                .getOutput(Task.OutputKind.DIRECT);
220
221        checkOutputContains(log,
222            "- compiler.warn.bad.name.for.option: --add-exports, m!");
223    }
224
225    @Test
226    public void testSourceNotFound(Path base) throws Exception {
227        Path src = base.resolve("src");
228        Path src_m1 = src.resolve("m1");
229        tb.writeJavaFiles(src_m1,
230                          "module m1 { }");
231        Path classes = base.resolve("classes");
232        tb.createDirectories(classes);
233
234        String log = new JavacTask(tb, Task.Mode.CMDLINE)
235                .options("-XDrawDiagnostics",
236                         "--module-source-path", src.toString(),
237                         "--add-exports", "DoesNotExist/p=m1")
238                .outdir(classes)
239                .files(findJavaFiles(src))
240                .run()
241                .writeAll()
242                .getOutput(Task.OutputKind.DIRECT);
243
244        checkOutputContains(log,
245            "- compiler.warn.module.for.option.not.found: --add-exports, DoesNotExist");
246    }
247
248    @Test
249    public void testTargetNotFound(Path base) throws Exception {
250        Path src = base.resolve("src");
251        Path src_m1 = src.resolve("m1");
252        tb.writeJavaFiles(src_m1,
253                          "module m1 { }",
254                          "package p1; class C1 { }");
255        Path classes = base.resolve("classes");
256        tb.createDirectories(classes);
257
258        String log = new JavacTask(tb, Task.Mode.CMDLINE)
259                .options("-XDrawDiagnostics",
260                         "--module-source-path", src.toString(),
261                         "--add-exports", "m1/p1=DoesNotExist")
262                .outdir(classes)
263                .files(findJavaFiles(src))
264                .run()
265                .writeAll()
266                .getOutput(Task.OutputKind.DIRECT);
267
268        checkOutputContains(log,
269            "- compiler.warn.module.for.option.not.found: --add-exports, DoesNotExist");
270    }
271
272    @Test
273    public void testDuplicate(Path base) throws Exception {
274        Path src = base.resolve("src");
275        Path src_m1 = src.resolve("m1");
276        tb.writeJavaFiles(src_m1,
277                          "module m1 { }",
278                          "package p1; public class C1 { }");
279        Path src_m2 = src.resolve("m2");
280        tb.writeJavaFiles(src_m2,
281                          "module m2 { }",
282                          "package p2; class C2 { p1.C1 c1; }");
283        Path classes = base.resolve("classes");
284        tb.createDirectories(classes);
285
286        new JavacTask(tb)
287                .options("--module-source-path", src.toString(),
288                         "--add-exports", "m1/p1=m2,m2")
289                .outdir(classes)
290                .files(findJavaFiles(src))
291                .run()
292                .writeAll();
293    }
294
295    @Test
296    public void testRepeated_SameTarget(Path base) throws Exception {
297        Path src = base.resolve("src");
298        Path src_m1 = src.resolve("m1");
299        tb.writeJavaFiles(src_m1,
300                          "module m1 { }",
301                          "package p1; public class C1 { }");
302        Path src_m2 = src.resolve("m2");
303        tb.writeJavaFiles(src_m2,
304                          "module m2 { }",
305                          "package p2; class C2 { p1.C1 c1; }");
306        Path classes = base.resolve("classes");
307        tb.createDirectories(classes);
308
309        new JavacTask(tb)
310                .options("--module-source-path", src.toString(),
311                         "--add-exports", "m1/p1=m2",
312                         "--add-exports", "m1/p1=m2")
313                .outdir(classes)
314                .files(findJavaFiles(src))
315                .run()
316                .writeAll();
317    }
318
319    @Test
320    public void testRepeated_DifferentTarget(Path base) throws Exception {
321        Path src = base.resolve("src");
322        Path src_m1 = src.resolve("m1");
323        tb.writeJavaFiles(src_m1,
324                          "module m1 { }",
325                          "package p1; public class C1 { }");
326        Path src_m2 = src.resolve("m2");
327        tb.writeJavaFiles(src_m2,
328                          "module m2 { }",
329                          "package p2; class C2 { p1.C1 c1; }");
330        Path src_m3 = src.resolve("m3");
331        tb.writeJavaFiles(src_m3,
332                          "module m3 { }",
333                          "package p3; class C3 { p1.C1 c1; }");
334        Path classes = base.resolve("classes");
335        tb.createDirectories(classes);
336
337        new JavacTask(tb)
338                .options("--module-source-path", src.toString(),
339                         "--add-exports", "m1/p1=m2",
340                         "--add-exports", "m1/p1=m3")
341                .outdir(classes)
342                .files(findJavaFiles(src))
343                .run()
344                .writeAll();
345    }
346}
347