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 

    39 import java.nio.file.Files;

    40 import java.nio.file.Path;

    41 import java.util.List;

    42 

    43 import toolbox.JavacTask;

    44 import toolbox.Task.OutputKind;

    45 

    46 public 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 }