1 /*

     2  * Copyright (c) 2015, 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 8144342 8149658 8162713

    26  * @summary javac doesn't report errors if module exports non-existent package

    27  * @library /tools/lib

    28  * @modules

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

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

    31  * @build toolbox.ToolBox toolbox.JavacTask ModuleTestBase

    32  * @run main ReportNonExistentPackageTest

    33  */

    34 

    35 import java.nio.file.Files;

    36 import java.nio.file.Path;

    37 

    38 import toolbox.JavacTask;

    39 import toolbox.Task;

    40 import toolbox.ToolBox;

    41 

    42 public class ReportNonExistentPackageTest extends ModuleTestBase {

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

    44         ReportNonExistentPackageTest t = new ReportNonExistentPackageTest();

    45         t.runTests();

    46     }

    47 

    48     @Test

    49     public void testExportUnknownPackage(Path base) throws Exception {

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

    51         tb.writeJavaFiles(src, "module m { exports p1; }");

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

    53         Files.createDirectories(classes);

    54 

    55         String log = new JavacTask(tb)

    56                 .options("-XDrawDiagnostics")

    57                 .outdir(classes)

    58                 .files(findJavaFiles(src))

    59                 .run(Task.Expect.FAIL)

    60                 .writeAll()

    61                 .getOutput(Task.OutputKind.DIRECT);

    62         if (!log.contains("module-info.java:1:20: compiler.err.package.empty.or.not.found: p1"))

    63             throw new Exception("expected output not found");

    64     }

    65 

    66     @Test

    67     public void testExportEmptyPackage(Path base) throws Exception {

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

    69         tb.writeJavaFiles(src,

    70                 "module m { exports p1; }",

    71                 "package p1;");

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

    73         Files.createDirectories(classes);

    74 

    75         String log = new JavacTask(tb)

    76                 .options("-XDrawDiagnostics")

    77                 .outdir(classes)

    78                 .files(findJavaFiles(src))

    79                 .run(Task.Expect.FAIL)

    80                 .writeAll()

    81                 .getOutput(Task.OutputKind.DIRECT);

    82         if (!log.contains("module-info.java:1:20: compiler.err.package.empty.or.not.found: p1"))

    83             throw new Exception("expected output not found");

    84     }

    85 

    86     @Test

    87     public void testPackageWithMemberWOPackageDeclaration(Path base) throws Exception {

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

    89         tb.writeJavaFiles(src, "module m { exports p1; }");

    90         Path p1 = src.resolve("p1");

    91         Path C = p1.resolve("C.java");

    92         tb.writeFile(C, "// comment");

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

    94         Files.createDirectories(classes);

    95 

    96         String log = new JavacTask(tb)

    97                 .options("-XDrawDiagnostics")

    98                 .outdir(classes)

    99                 .files(findJavaFiles(src))

   100                 .run(Task.Expect.FAIL)

   101                 .writeAll()

   102                 .getOutput(Task.OutputKind.DIRECT);

   103         if (!log.contains("module-info.java:1:20: compiler.err.package.empty.or.not.found: p1"))

   104             throw new Exception("expected output not found");

   105     }

   106 

   107     @Test

   108     public void testOpensEmptyPackage(Path base) throws Exception {

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

   110         tb.writeJavaFiles(src,

   111                 "module m { opens p; }");

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

   113         Files.createDirectories(classes);

   114 

   115         String log = new JavacTask(tb)

   116                 .options("-XDrawDiagnostics")

   117                 .outdir(classes)

   118                 .files(findJavaFiles(src))

   119                 .run(Task.Expect.SUCCESS)

   120                 .writeAll()

   121                 .getOutput(Task.OutputKind.DIRECT);

   122         if (!log.contains("module-info.java:1:18: compiler.warn.package.empty.or.not.found: p"))

   123             throw new Exception("expected output not found, actual output: " + log);

   124     }

   125 

   126     @Test

   127     public void testOpensEmptyPackageSuppressed(Path base) throws Exception {

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

   129         tb.writeJavaFiles(src,

   130                 "@SuppressWarnings(\"opens\") module m { opens p; }");

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

   132         Files.createDirectories(classes);

   133 

   134         String log = new JavacTask(tb)

   135                 .options("-XDrawDiagnostics")

   136                 .outdir(classes)

   137                 .files(findJavaFiles(src))

   138                 .run(Task.Expect.SUCCESS)

   139                 .writeAll()

   140                 .getOutput(Task.OutputKind.DIRECT);

   141         if (!log.equals(""))

   142             throw new Exception("expected output not found, actual output: " + log);

   143     }

   144 

   145     @Test

   146     public void testOpenOnlyWithResources(Path base) throws Exception {

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

   148         tb.writeJavaFiles(src,

   149                 "module m { opens p; }");

   150         Path resource = src.resolve("p").resolve("resource.properties");

   151         Files.createDirectories(resource.getParent());

   152         Files.newOutputStream(resource).close();

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

   154         Files.createDirectories(classes);

   155 

   156         String log = new JavacTask(tb)

   157                 .sourcepath(src.toString())

   158                 .outdir(classes)

   159                 .files(findJavaFiles(src))

   160                 .run()

   161                 .writeAll()

   162                 .getOutput(Task.OutputKind.DIRECT);

   163         if (!log.equals(""))

   164             throw new Exception("expected output not found, actual output: " + log);

   165     }

   166 }