ModuleInfoPatchPath.java revision 4054:24fa5d195595 
1/*
2 * Copyright (c) 2017, 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 * @bug 8175057
27 * @summary Verify that having module-info on patch path works correctly.
28 * @library /tools/lib
29 * @modules
30 *      jdk.compiler/com.sun.tools.javac.api
31 *      jdk.compiler/com.sun.tools.javac.code
32 *      jdk.compiler/com.sun.tools.javac.main
33 *      jdk.compiler/com.sun.tools.javac.processing
34 *      jdk.compiler/com.sun.tools.javac.util
35 * @build toolbox.ToolBox toolbox.JarTask toolbox.JavacTask ModuleTestBase
36 * @run main ModuleInfoPatchPath
37 */
38
39import java.nio.file.Files;
40import java.nio.file.Path;
41import java.util.List;
42
43import toolbox.JavacTask;
44import toolbox.Task.OutputKind;
45
46public class ModuleInfoPatchPath extends ModuleTestBase {
47
48    public static void main(String... args) throws Exception {
49        new ModuleInfoPatchPath().runTests();
50    }
51
52    @Test
53    public void testModuleInfoToModulePath(Path base) throws Exception {
54        Path src = base.resolve("src");
55        tb.writeJavaFiles(src,
56                          "module m { exports api; }",
57                          "package api; public class Api {}");
58        Path patch = base.resolve("patch");
59        tb.writeJavaFiles(patch,
60                          "module m { requires java.compiler; exports api; }",
61                          "package api; public class Api { public static javax.lang.model.element.Element element; }");
62        Path classes = base.resolve("classes");
63        Path mClasses = classes.resolve("m");
64        tb.createDirectories(mClasses);
65
66        System.err.println("Building the vanilla module...");
67
68        new JavacTask(tb)
69            .outdir(mClasses)
70            .files(findJavaFiles(src))
71            .run()
72            .writeAll();
73
74        Path test = base.resolve("test");
75        tb.writeJavaFiles(test,
76                          "module test { requires m; }",
77                          "package test; public class Test { private void test() { api.Api.element = null; } }");
78
79        Path testClasses = classes.resolve("test");
80        tb.createDirectories(testClasses);
81
82        System.err.println("Building patched module...");
83
84        new JavacTask(tb)
85            .options("--module-path", mClasses.toString(),
86                     "--patch-module", "m=" + patch.toString())
87            .outdir(testClasses)
88            .files(findJavaFiles(test))
89            .run()
90            .writeAll();
91
92        Path patchClasses = classes.resolve("patch");
93        tb.createDirectories(patchClasses);
94
95        System.err.println("Building patch...");
96
97        new JavacTask(tb)
98            .outdir(patchClasses)
99            .files(findJavaFiles(patch))
100            .run()
101            .writeAll();
102
103        tb.cleanDirectory(testClasses);
104
105        Files.delete(patch.resolve("module-info.java"));
106        Files.copy(patchClasses.resolve("module-info.class"), patch.resolve("module-info.class"));
107
108        System.err.println("Building patched module against binary patch...");
109
110        new JavacTask(tb)
111            .options("--module-path", mClasses.toString(),
112                     "--patch-module", "m=" + patch.toString())
113            .outdir(testClasses)
114            .files(findJavaFiles(test))
115            .run()
116            .writeAll();
117    }
118
119    @Test
120    public void testModuleInfoToSourcePath(Path base) throws Exception {
121        Path src = base.resolve("src");
122        tb.writeJavaFiles(src,
123                          "module m { exports api; }",
124                          "package api; public class Api {}",
125                          "package test; public class Test { private void test() { api.Api.element = null; } }");
126        Path patch = base.resolve("patch");
127        tb.writeJavaFiles(patch,
128                          "module m { requires java.compiler; exports api; }",
129                          "package api; public class Api { public static javax.lang.model.element.Element element; }");
130        Path classes = base.resolve("classes");
131        Path mClasses = classes.resolve("m");
132        tb.createDirectories(mClasses);
133
134        System.err.println("Building patched module against source patch...");
135
136        new JavacTask(tb)
137            .options("--patch-module", "m=" + patch.toString(),
138                     "-sourcepath", src.toString())
139            .outdir(mClasses)
140            .files(findJavaFiles(src.resolve("test")))
141            .run()
142            .writeAll();
143
144        //incremental compilation:
145        List<String> log;
146
147        System.err.println("Incremental building of patched module against source patch, no module-info...");
148
149        log = new JavacTask(tb)
150                .options("--patch-module", "m=" + patch.toString(),
151                         "-sourcepath", src.toString(),
152                         "-verbose")
153                .outdir(mClasses)
154                .files(findJavaFiles(src.resolve("test")))
155                .run()
156                .writeAll()
157                .getOutputLines(OutputKind.DIRECT);
158
159        if (log.stream().filter(line -> line.contains("[parsing started")).count() != 1) {
160            throw new AssertionError("incorrect number of parsing events.");
161        }
162
163        System.err.println("Incremental building of patched module against source patch, with module-info...");
164
165        log = new JavacTask(tb)
166                .options("--patch-module", "m=" + patch.toString(),
167                         "-sourcepath", src.toString(),
168                         "-verbose")
169                .outdir(mClasses)
170                .files(findJavaFiles(patch.resolve("module-info.java"), src.resolve("test")))
171                .run()
172                .writeAll()
173                .getOutputLines(OutputKind.DIRECT);
174
175        if (log.stream().filter(line -> line.contains("[parsing started")).count() != 2) {
176            throw new AssertionError("incorrect number of parsing events.");
177        }
178
179        tb.cleanDirectory(mClasses);
180
181        System.err.println("Building patched module against source patch with source patch on patch path...");
182
183        new JavacTask(tb)
184            .options("--patch-module", "m=" + patch.toString(),
185                     "-sourcepath", src.toString())
186            .outdir(mClasses)
187            .files(findJavaFiles(src.resolve("test"), patch))
188            .run()
189            .writeAll();
190
191        Path patchClasses = classes.resolve("patch");
192        tb.createDirectories(patchClasses);
193
194        System.err.println("Building patch...");
195
196        new JavacTask(tb)
197            .outdir(patchClasses)
198            .files(findJavaFiles(patch))
199            .run()
200            .writeAll();
201
202        tb.cleanDirectory(mClasses);
203
204        Files.delete(patch.resolve("module-info.java"));
205        Files.copy(patchClasses.resolve("module-info.class"), patch.resolve("module-info.class"));
206
207        System.err.println("Building patched module against binary patch...");
208
209        new JavacTask(tb)
210            .options("--patch-module", "m=" + patch.toString(),
211                     "-sourcepath", src.toString())
212            .outdir(mClasses)
213            .files(findJavaFiles(src.resolve("test")))
214            .run()
215            .writeAll();
216
217        tb.cleanDirectory(mClasses);
218
219        System.err.println("Building patched module against binary patch with source patch on patch path...");
220
221        new JavacTask(tb)
222            .options("--patch-module", "m=" + patch.toString(),
223                     "-sourcepath", src.toString())
224            .outdir(mClasses)
225            .files(findJavaFiles(src.resolve("test"), patch))
226            .run()
227            .writeAll();
228    }
229
230    @Test
231    public void testModuleInfoToModuleSourcePath(Path base) throws Exception {
232        Path src = base.resolve("src");
233        Path m = src.resolve("m");
234        tb.writeJavaFiles(m,
235                          "module m { exports api; }",
236                          "package api; public class Api {}",
237                          "package test; public class Test { private void test() { api.Api.element = null; } }");
238        Path patch = base.resolve("patch");
239        tb.writeJavaFiles(patch,
240                          "module m { requires java.compiler; exports api; }",
241                          "package api; public class Api { public static javax.lang.model.element.Element element; }");
242        Path classes = base.resolve("classes");
243        Path mClasses = classes.resolve("m");
244        tb.createDirectories(mClasses);
245
246        System.err.println("Building patched module against source patch...");
247
248        new JavacTask(tb)
249            .options("--patch-module", "m=" + patch.toString(),
250                     "--module-source-path", src.toString())
251            .outdir(mClasses)
252            .files(findJavaFiles(m.resolve("test")))
253            .run()
254            .writeAll();
255
256        //incremental compilation:
257
258        System.err.println("Incremental building of patched module against source patch...");
259
260        List<String> log = new JavacTask(tb)
261                .options("--patch-module", "m=" + patch.toString(),
262                         "--module-source-path", src.toString(),
263                         "-verbose")
264                .outdir(mClasses)
265                .files(findJavaFiles(m.resolve("test")))
266                .run()
267                .writeAll()
268                .getOutputLines(OutputKind.DIRECT);
269
270        if (log.stream().filter(line -> line.contains("[parsing started")).count() != 1) {
271            throw new AssertionError("incorrect number of parsing events.");
272        }
273
274        tb.cleanDirectory(mClasses);
275
276        System.err.println("Building patched module against source patch with source patch on patch path...");
277
278        new JavacTask(tb)
279            .options("--patch-module", "m=" + patch.toString(),
280                     "--module-source-path", src.toString())
281            .outdir(mClasses)
282            .files(findJavaFiles(m.resolve("test"), patch))
283            .run()
284            .writeAll();
285
286        Path patchClasses = classes.resolve("patch");
287        tb.createDirectories(patchClasses);
288
289        System.err.println("Building patch...");
290
291        new JavacTask(tb)
292            .outdir(patchClasses)
293            .files(findJavaFiles(patch))
294            .run()
295            .writeAll();
296
297        tb.cleanDirectory(mClasses);
298
299        Files.delete(patch.resolve("module-info.java"));
300        Files.copy(patchClasses.resolve("module-info.class"), patch.resolve("module-info.class"));
301
302        System.err.println("Building patched module against binary patch...");
303
304        new JavacTask(tb)
305            .options("--patch-module", "m=" + patch.toString(),
306                     "--module-source-path", src.toString())
307            .outdir(mClasses)
308            .files(findJavaFiles(m.resolve("test")))
309            .run()
310            .writeAll();
311
312        tb.cleanDirectory(mClasses);
313
314        System.err.println("Building patched module against binary patch with source patch on patch path...");
315
316        new JavacTask(tb)
317            .options("--patch-module", "m=" + patch.toString(),
318                     "--module-source-path", src.toString())
319            .outdir(mClasses)
320            .files(findJavaFiles(m.resolve("test"), patch))
321            .run()
322            .writeAll();
323    }
324
325}
326