langtools/test/tools/javac/modules/ResolveTest.java
changeset 36778 e04318f39f92
parent 36526 3b41f1c69604
child 37758 3ecf9b414e05
equal deleted inserted replaced
36777:28d33fb9097f 36778:e04318f39f92
     1 /*
     1 /*
     2  * Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
     2  * Copyright (c) 2013, 2016, Oracle and/or its affiliates. All rights reserved.
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     4  *
     4  *
     5  * This code is free software; you can redistribute it and/or modify it
     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
     6  * under the terms of the GNU General Public License version 2 only, as
     7  * published by the Free Software Foundation.
     7  * published by the Free Software Foundation.
    26  * @summary tests for module resolution
    26  * @summary tests for module resolution
    27  * @library /tools/lib
    27  * @library /tools/lib
    28  * @modules
    28  * @modules
    29  *      jdk.compiler/com.sun.tools.javac.api
    29  *      jdk.compiler/com.sun.tools.javac.api
    30  *      jdk.compiler/com.sun.tools.javac.main
    30  *      jdk.compiler/com.sun.tools.javac.main
    31  *      jdk.jdeps/com.sun.tools.javap
    31  * @build toolbox.ToolBox toolbox.JavacTask ModuleTestBase
    32  * @build ToolBox ModuleTestBase
       
    33  * @run main ResolveTest
    32  * @run main ResolveTest
    34  */
    33  */
    35 
    34 
    36 import java.nio.file.*;
    35 import java.nio.file.*;
       
    36 
       
    37 import toolbox.JavacTask;
       
    38 import toolbox.Task;
       
    39 import toolbox.ToolBox;
    37 
    40 
    38 public class ResolveTest extends ModuleTestBase {
    41 public class ResolveTest extends ModuleTestBase {
    39     public static void main(String... args) throws Exception {
    42     public static void main(String... args) throws Exception {
    40         ResolveTest t = new ResolveTest();
    43         ResolveTest t = new ResolveTest();
    41         t.runTests();
    44         t.runTests();
    44     @Test
    47     @Test
    45     void testMissingSimpleTypeUnnamedModule(Path base) throws Exception {
    48     void testMissingSimpleTypeUnnamedModule(Path base) throws Exception {
    46         Path src = base.resolve("src");
    49         Path src = base.resolve("src");
    47         tb.writeJavaFiles(src, "class C { D d; }");
    50         tb.writeJavaFiles(src, "class C { D d; }");
    48 
    51 
    49         String log = tb.new JavacTask()
    52         String log = new JavacTask(tb)
    50                 .options("-XDrawDiagnostics")
    53                 .options("-XDrawDiagnostics")
    51                 .files(findJavaFiles(src))
    54                 .files(findJavaFiles(src))
    52                 .run(ToolBox.Expect.FAIL)
    55                 .run(Task.Expect.FAIL)
    53                 .writeAll()
    56                 .writeAll()
    54                 .getOutput(ToolBox.OutputKind.DIRECT);
    57                 .getOutput(Task.OutputKind.DIRECT);
    55 
    58 
    56         if (!log.contains("C.java:1:11: compiler.err.cant.resolve.location: "
    59         if (!log.contains("C.java:1:11: compiler.err.cant.resolve.location: "
    57                 + "kindname.class, D, , , (compiler.misc.location: kindname.class, C, null)"))
    60                 + "kindname.class, D, , , (compiler.misc.location: kindname.class, C, null)"))
    58             throw new Exception("expected output not found");
    61             throw new Exception("expected output not found");
    59     }
    62     }
    63         Path src = base.resolve("src");
    66         Path src = base.resolve("src");
    64         tb.writeJavaFiles(src,
    67         tb.writeJavaFiles(src,
    65                 "module m { }",
    68                 "module m { }",
    66                 "class C { D d; }");
    69                 "class C { D d; }");
    67 
    70 
    68         String log = tb.new JavacTask()
    71         String log = new JavacTask(tb)
    69                 .options("-XDrawDiagnostics")
    72                 .options("-XDrawDiagnostics")
    70                 .files(findJavaFiles(src))
    73                 .files(findJavaFiles(src))
    71                 .run(ToolBox.Expect.FAIL)
    74                 .run(Task.Expect.FAIL)
    72                 .writeAll()
    75                 .writeAll()
    73                 .getOutput(ToolBox.OutputKind.DIRECT);
    76                 .getOutput(Task.OutputKind.DIRECT);
    74 
    77 
    75         if (!log.contains("C.java:1:11: compiler.err.cant.resolve.location: "
    78         if (!log.contains("C.java:1:11: compiler.err.cant.resolve.location: "
    76                 + "kindname.class, D, , , (compiler.misc.location: kindname.class, C, null)"))
    79                 + "kindname.class, D, , , (compiler.misc.location: kindname.class, C, null)"))
    77             throw new Exception("expected output not found");
    80             throw new Exception("expected output not found");
    78     }
    81     }
    87                 "module m2 { }",
    90                 "module m2 { }",
    88                 "package p2; public class C2 { p1.C1 c; }");
    91                 "package p2; public class C2 { p1.C1 c; }");
    89         Path modules = base.resolve("modules");
    92         Path modules = base.resolve("modules");
    90         Files.createDirectories(modules);
    93         Files.createDirectories(modules);
    91 
    94 
    92         String log = tb.new JavacTask()
    95         String log = new JavacTask(tb)
    93                 .options("-XDrawDiagnostics", "-modulesourcepath", src.toString())
    96                 .options("-XDrawDiagnostics", "-modulesourcepath", src.toString())
    94                 .outdir(modules)
    97                 .outdir(modules)
    95                 .files(findJavaFiles(src))
    98                 .files(findJavaFiles(src))
    96                 .run(ToolBox.Expect.FAIL)
    99                 .run(Task.Expect.FAIL)
    97                 .writeAll()
   100                 .writeAll()
    98                 .getOutput(ToolBox.OutputKind.DIRECT);
   101                 .getOutput(Task.OutputKind.DIRECT);
    99 
   102 
   100         if (!log.contains("C2.java:1:33: compiler.err.not.def.access.package.cant.access: p1.C1, p1"))
   103         if (!log.contains("C2.java:1:33: compiler.err.not.def.access.package.cant.access: p1.C1, p1"))
   101             throw new Exception("expected output not found");
   104             throw new Exception("expected output not found");
   102     }
   105     }
   103 
   106 
   111                 "module m2 { requires m1; }",
   114                 "module m2 { requires m1; }",
   112                 "package p2; public class C2 { p1.C1 c; }");
   115                 "package p2; public class C2 { p1.C1 c; }");
   113         Path modules = base.resolve("modules");
   116         Path modules = base.resolve("modules");
   114         Files.createDirectories(modules);
   117         Files.createDirectories(modules);
   115 
   118 
   116         String log = tb.new JavacTask()
   119         String log = new JavacTask(tb)
   117                 .options("-XDrawDiagnostics", "-modulesourcepath", src.toString())
   120                 .options("-XDrawDiagnostics", "-modulesourcepath", src.toString())
   118                 .outdir(modules)
   121                 .outdir(modules)
   119                 .files(findJavaFiles(src))
   122                 .files(findJavaFiles(src))
   120                 .run(ToolBox.Expect.FAIL)
   123                 .run(Task.Expect.FAIL)
   121                 .writeAll()
   124                 .writeAll()
   122                 .getOutput(ToolBox.OutputKind.DIRECT);
   125                 .getOutput(Task.OutputKind.DIRECT);
   123 
   126 
   124         if (!log.contains("C2.java:1:33: compiler.err.not.def.access.package.cant.access: p1.C1, p1"))
   127         if (!log.contains("C2.java:1:33: compiler.err.not.def.access.package.cant.access: p1.C1, p1"))
   125             throw new Exception("expected output not found");
   128             throw new Exception("expected output not found");
   126     }
   129     }
   127 
   130 
   137         tb.writeJavaFiles(src.resolve("m3"),
   140         tb.writeJavaFiles(src.resolve("m3"),
   138                 "module m3 { requires m1; }");
   141                 "module m3 { requires m1; }");
   139         Path modules = base.resolve("modules");
   142         Path modules = base.resolve("modules");
   140         Files.createDirectories(modules);
   143         Files.createDirectories(modules);
   141 
   144 
   142         String log = tb.new JavacTask()
   145         String log = new JavacTask(tb)
   143                 .options("-XDrawDiagnostics", "-modulesourcepath", src.toString())
   146                 .options("-XDrawDiagnostics", "-modulesourcepath", src.toString())
   144                 .outdir(modules)
   147                 .outdir(modules)
   145                 .files(findJavaFiles(src))
   148                 .files(findJavaFiles(src))
   146                 .run(ToolBox.Expect.FAIL)
   149                 .run(Task.Expect.FAIL)
   147                 .writeAll()
   150                 .writeAll()
   148                 .getOutput(ToolBox.OutputKind.DIRECT);
   151                 .getOutput(Task.OutputKind.DIRECT);
   149 
   152 
   150         if (!log.contains("C2.java:1:33: compiler.err.not.def.access.package.cant.access: p1.C1, p1"))
   153         if (!log.contains("C2.java:1:33: compiler.err.not.def.access.package.cant.access: p1.C1, p1"))
   151             throw new Exception("expected output not found");
   154             throw new Exception("expected output not found");
   152     }
   155     }
   153 
   156 
   161                 "module m2 { }",
   164                 "module m2 { }",
   162                 "package p2; public class C2 { p1.C1 c; }");
   165                 "package p2; public class C2 { p1.C1 c; }");
   163         Path modules = base.resolve("modules");
   166         Path modules = base.resolve("modules");
   164         Files.createDirectories(modules);
   167         Files.createDirectories(modules);
   165 
   168 
   166         String log = tb.new JavacTask()
   169         String log = new JavacTask(tb)
   167                 .options("-XDrawDiagnostics", "-modulesourcepath", src.toString())
   170                 .options("-XDrawDiagnostics", "-modulesourcepath", src.toString())
   168                 .outdir(modules)
   171                 .outdir(modules)
   169                 .files(findJavaFiles(src))
   172                 .files(findJavaFiles(src))
   170                 .run(ToolBox.Expect.FAIL)
   173                 .run(Task.Expect.FAIL)
   171                 .writeAll()
   174                 .writeAll()
   172                 .getOutput(ToolBox.OutputKind.DIRECT);
   175                 .getOutput(Task.OutputKind.DIRECT);
   173 
   176 
   174         if (!log.contains("C2.java:1:33: compiler.err.not.def.access.package.cant.access: p1.C1, p1"))
   177         if (!log.contains("C2.java:1:33: compiler.err.not.def.access.package.cant.access: p1.C1, p1"))
   175             throw new Exception("expected output not found");
   178             throw new Exception("expected output not found");
   176     }
   179     }
   177 
   180 
   185                 "module m2 { requires m1; }",
   188                 "module m2 { requires m1; }",
   186                 "package p2; public class C2 { p1.C1 c; }");
   189                 "package p2; public class C2 { p1.C1 c; }");
   187         Path modules = base.resolve("modules");
   190         Path modules = base.resolve("modules");
   188         Files.createDirectories(modules);
   191         Files.createDirectories(modules);
   189 
   192 
   190         tb.new JavacTask()
   193         new JavacTask(tb)
   191                 .options("-XDrawDiagnostics", "-modulesourcepath", src.toString())
   194                 .options("-XDrawDiagnostics", "-modulesourcepath", src.toString())
   192                 .outdir(modules)
   195                 .outdir(modules)
   193                 .files(findJavaFiles(src))
   196                 .files(findJavaFiles(src))
   194                 .run()
   197                 .run()
   195                 .writeAll();
   198                 .writeAll();
   205                 "module m2 { requires m1; }",
   208                 "module m2 { requires m1; }",
   206                 "package p2; public class C2 { p1.C1 c; }");
   209                 "package p2; public class C2 { p1.C1 c; }");
   207         Path modules = base.resolve("modules");
   210         Path modules = base.resolve("modules");
   208         Files.createDirectories(modules);
   211         Files.createDirectories(modules);
   209 
   212 
   210         tb.new JavacTask()
   213         new JavacTask(tb)
   211                 .options("-XDrawDiagnostics", "-modulesourcepath", src.toString())
   214                 .options("-XDrawDiagnostics", "-modulesourcepath", src.toString())
   212                 .outdir(modules)
   215                 .outdir(modules)
   213                 .files(findJavaFiles(src))
   216                 .files(findJavaFiles(src))
   214                 .run()
   217                 .run()
   215                 .writeAll();
   218                 .writeAll();