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 8178152

    27  * @summary Verify unsupported modules and module options handling.

    28  * @library /tools/lib

    29  * @modules jdk.compiler/com.sun.tools.javac.api

    30  *          jdk.compiler/com.sun.tools.javac.main

    31  *          jdk.compiler/com.sun.tools.javac.jvm

    32  *          jdk.jdeps/com.sun.tools.classfile

    33  *          jdk.jdeps/com.sun.tools.javap

    34  * @build toolbox.ToolBox toolbox.JarTask toolbox.JavacTask toolbox.JavapTask toolbox.TestRunner

    35  * @run main ReleaseOptionUnsupported

    36  */

    37 

    38 import java.io.IOException;

    39 import java.nio.file.Path;

    40 import java.nio.file.Paths;

    41 import java.util.Arrays;

    42 import java.util.List;

    43 

    44 import com.sun.tools.javac.jvm.Target;

    45 import toolbox.JavacTask;

    46 import toolbox.Task;

    47 import toolbox.Task.Expect;

    48 import toolbox.TestRunner;

    49 import toolbox.ToolBox;

    50 

    51 public class ReleaseOptionUnsupported extends TestRunner {

    52 

    53     private final ToolBox tb = new ToolBox();

    54 

    55     public ReleaseOptionUnsupported() {

    56         super(System.err);

    57     }

    58 

    59     public static void main(String... args) throws Exception {

    60         new ReleaseOptionUnsupported().runTests();

    61     }

    62 

    63     @Test

    64     public void testUnsafe(Path base) throws IOException {

    65         Path src = base.resolve("src");

    66         tb.writeJavaFiles(src,

    67                           "module m { requires jdk.unsupported; }",

    68                           "package test; public class Test { sun.misc.Unsafe unsafe; } ");

    69         Path classes = base.resolve("classes");

    70         tb.createDirectories(classes);

    71 

    72         List<String> log;

    73         List<String> expected = Arrays.asList(

    74                 "Test.java:1:43: compiler.warn.sun.proprietary: sun.misc.Unsafe",

    75                 "1 warning"

    76         );

    77 

    78         log = new JavacTask(tb)

    79                 .options("-XDrawDiagnostics")

    80                 .outdir(classes)

    81                 .files(tb.findJavaFiles(src))

    82                 .run(Expect.SUCCESS)

    83                 .writeAll()

    84                 .getOutputLines(Task.OutputKind.DIRECT);

    85 

    86         if (!expected.equals(log)) {

    87             throw new AssertionError("Unexpected output: " + log);

    88         }

    89 

    90         log = new JavacTask(tb)

    91                 .options("-XDrawDiagnostics",

    92                          "--release", Target.DEFAULT.multiReleaseValue())

    93                 .outdir(classes)

    94                 .files(tb.findJavaFiles(src))

    95                 .run(Expect.SUCCESS)

    96                 .writeAll()

    97                 .getOutputLines(Task.OutputKind.DIRECT);

    98 

    99         if (!expected.equals(log)) {

   100             throw new AssertionError("Unexpected output: " + log);

   101         }

   102     }

   103 

   104     @Test

   105     public void testUnsafeUnnamed(Path base) throws IOException {

   106         Path src = base.resolve("src");

   107         tb.writeJavaFiles(src,

   108                           "package test; public class Test { sun.misc.Unsafe unsafe; } ");

   109         Path classes = base.resolve("classes");

   110         tb.createDirectories(classes);

   111 

   112         List<String> log;

   113         List<String> expected = Arrays.asList(

   114                 "Test.java:1:43: compiler.warn.sun.proprietary: sun.misc.Unsafe",

   115                 "1 warning"

   116         );

   117 

   118         log = new JavacTask(tb)

   119                 .options("-XDrawDiagnostics")

   120                 .outdir(classes)

   121                 .files(tb.findJavaFiles(src))

   122                 .run(Expect.SUCCESS)

   123                 .writeAll()

   124                 .getOutputLines(Task.OutputKind.DIRECT);

   125 

   126         if (!expected.equals(log)) {

   127             throw new AssertionError("Unexpected output: " + log);

   128         }

   129 

   130         log = new JavacTask(tb)

   131                 .options("-XDrawDiagnostics",

   132                          "--release", Target.DEFAULT.multiReleaseValue())

   133                 .outdir(classes)

   134                 .files(tb.findJavaFiles(src))

   135                 .run(Expect.SUCCESS)

   136                 .writeAll()

   137                 .getOutputLines(Task.OutputKind.DIRECT);

   138 

   139         if (!expected.equals(log)) {

   140             throw new AssertionError("Unexpected output: " + log);

   141         }

   142     }

   143 

   144     @Test

   145     public void testAddExports(Path base) throws IOException {

   146         Path src = base.resolve("src");

   147         tb.writeJavaFiles(src,

   148                           "module m { }",

   149                           "package test; public class Test { jdk.internal.misc.Unsafe unsafe; } ");

   150         Path classes = base.resolve("classes");

   151         tb.createDirectories(classes);

   152 

   153         new JavacTask(tb)

   154                 .options("-XDrawDiagnostics",

   155                          "--add-exports", "java.base/jdk.internal.misc=m")

   156                 .outdir(classes)

   157                 .files(tb.findJavaFiles(src))

   158                 .run(Expect.SUCCESS)

   159                 .writeAll()

   160                 .getOutputLines(Task.OutputKind.DIRECT);

   161 

   162         List<String> log;

   163         List<String> expected;

   164 

   165         log = new JavacTask(tb)

   166                 .options("-XDrawDiagnostics",

   167                          "--add-exports", "java.base/jdk.internal.misc=m",

   168                          "--release", Target.DEFAULT.multiReleaseValue())

   169                 .outdir(classes)

   170                 .files(tb.findJavaFiles(src))

   171                 .run(Expect.FAIL)

   172                 .writeAll()

   173                 .getOutputLines(Task.OutputKind.DIRECT);

   174 

   175         expected = Arrays.asList(

   176                 "- compiler.err.add.exports.with.release: java.base",

   177                 "1 error"

   178         );

   179 

   180         if (!expected.equals(log)) {

   181             throw new AssertionError("Unexpected output: " + log);

   182         }

   183 

   184         //OK to add exports a package of a non-system module:

   185         tb.writeJavaFiles(src,

   186                           "package test; public class Test { } ");

   187         tb.createDirectories(classes);

   188 

   189         new JavacTask(tb)

   190                 .options("-XDrawDiagnostics",

   191                          "--add-exports", "m/test=ALL-UNNAMED",

   192                          "--release", Target.DEFAULT.multiReleaseValue())

   193                 .outdir(classes)

   194                 .files(tb.findJavaFiles(src))

   195                 .run(Expect.SUCCESS)

   196                 .writeAll()

   197                 .getOutputLines(Task.OutputKind.DIRECT);

   198     }

   199 

   200     @Test

   201     public void testAddReads(Path base) throws IOException {

   202         Path src = base.resolve("src");

   203         tb.writeJavaFiles(src,

   204                           "module m { }",

   205                           "package test; public class Test { } ");

   206         Path classes = base.resolve("classes");

   207         tb.createDirectories(classes);

   208 

   209         new JavacTask(tb)

   210                 .options("-XDrawDiagnostics",

   211                          "--add-reads", "java.base=m")

   212                 .outdir(classes)

   213                 .files(tb.findJavaFiles(src))

   214                 .run(Expect.SUCCESS)

   215                 .writeAll()

   216                 .getOutputLines(Task.OutputKind.DIRECT);

   217 

   218         List<String> log;

   219         List<String> expected;

   220 

   221         log = new JavacTask(tb)

   222                 .options("-XDrawDiagnostics",

   223                          "--add-reads", "java.base=m",

   224                          "--release", Target.DEFAULT.multiReleaseValue())

   225                 .outdir(classes)

   226                 .files(tb.findJavaFiles(src))

   227                 .run(Expect.FAIL)

   228                 .writeAll()

   229                 .getOutputLines(Task.OutputKind.DIRECT);

   230 

   231         expected = Arrays.asList(

   232                 "- compiler.err.add.reads.with.release: java.base",

   233                 "1 error"

   234         );

   235 

   236         if (!expected.equals(log)) {

   237             throw new AssertionError("Unexpected output: " + log);

   238         }

   239 

   240         //OK to add reads a package of a non-system module:

   241         tb.createDirectories(classes);

   242 

   243         new JavacTask(tb)

   244                 .options("-XDrawDiagnostics",

   245                          "--add-reads", "m=java.base",

   246                          "--release", Target.DEFAULT.multiReleaseValue())

   247                 .outdir(classes)

   248                 .files(tb.findJavaFiles(src))

   249                 .run(Expect.SUCCESS)

   250                 .writeAll()

   251                 .getOutputLines(Task.OutputKind.DIRECT);

   252     }

   253 

   254     @Test

   255     public void testPatchModule(Path base) throws IOException {

   256         Path src = base.resolve("src");

   257         tb.writeJavaFiles(src,

   258                           "module m { }",

   259                           "package test; public class Test { } ");

   260         Path classes = base.resolve("classes");

   261         tb.createDirectories(classes);

   262         Path patch = base.resolve("patch");

   263         tb.createDirectories(patch);

   264 

   265         new JavacTask(tb)

   266                 .options("-XDrawDiagnostics",

   267                          "--patch-module", "java.base=" + patch)

   268                 .outdir(classes)

   269                 .files(tb.findJavaFiles(src))

   270                 .run(Expect.SUCCESS)

   271                 .writeAll()

   272                 .getOutputLines(Task.OutputKind.DIRECT);

   273 

   274         List<String> log;

   275         List<String> expected;

   276 

   277         log = new JavacTask(tb)

   278                 .options("-XDrawDiagnostics",

   279                          "--patch-module", "java.base=" + patch,

   280                          "--release", Target.DEFAULT.multiReleaseValue())

   281                 .outdir(classes)

   282                 .files(tb.findJavaFiles(src))

   283                 .run(Expect.FAIL)

   284                 .writeAll()

   285                 .getOutputLines(Task.OutputKind.DIRECT);

   286 

   287         expected = Arrays.asList(

   288                 "- compiler.err.patch.module.with.release: java.base",

   289                 "1 error"

   290         );

   291 

   292         if (!expected.equals(log)) {

   293             throw new AssertionError("Unexpected output: " + log);

   294         }

   295 

   296         //OK to patch a non-system module:

   297         tb.createDirectories(classes);

   298 

   299         new JavacTask(tb)

   300                 .options("-XDrawDiagnostics",

   301                          "--patch-module", "m=" + patch,

   302                          "--release", Target.DEFAULT.multiReleaseValue())

   303                 .outdir(classes)

   304                 .files(tb.findJavaFiles(src))

   305                 .run(Expect.SUCCESS)

   306                 .writeAll()

   307                 .getOutputLines(Task.OutputKind.DIRECT);

   308     }

   309 

   310     protected void runTests() throws Exception {

   311         runTests(m -> new Object[] { Paths.get(m.getName()) });

   312     }

   313 }