langtools/test/tools/javac/modules/SingleModuleModeTest.java
changeset 36778 e04318f39f92
parent 36526 3b41f1c69604
child 37758 3ecf9b414e05
equal deleted inserted replaced
36777:28d33fb9097f 36778:e04318f39f92
    26  * @summary tests for single module mode compilation
    26  * @summary tests for single module mode compilation
    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 SingleModuleModeTest
    32  * @run main SingleModuleModeTest
    34  */
    33  */
    35 
    34 
    36 import java.nio.file.Files;
    35 import java.nio.file.Files;
    37 import java.nio.file.Path;
    36 import java.nio.file.Path;
    40 import javax.annotation.processing.AbstractProcessor;
    39 import javax.annotation.processing.AbstractProcessor;
    41 import javax.annotation.processing.RoundEnvironment;
    40 import javax.annotation.processing.RoundEnvironment;
    42 import javax.annotation.processing.SupportedAnnotationTypes;
    41 import javax.annotation.processing.SupportedAnnotationTypes;
    43 import javax.lang.model.SourceVersion;
    42 import javax.lang.model.SourceVersion;
    44 import javax.lang.model.element.TypeElement;
    43 import javax.lang.model.element.TypeElement;
       
    44 
       
    45 import toolbox.JavacTask;
       
    46 import toolbox.Task;
       
    47 import toolbox.ToolBox;
    45 
    48 
    46 public class SingleModuleModeTest extends ModuleTestBase{
    49 public class SingleModuleModeTest extends ModuleTestBase{
    47 
    50 
    48     public static void main(String... args) throws Exception {
    51     public static void main(String... args) throws Exception {
    49         new SingleModuleModeTest().run();
    52         new SingleModuleModeTest().run();
    59     void testTooManyModules(Path base) throws Exception {
    62     void testTooManyModules(Path base) throws Exception {
    60         Path src = base.resolve("src");
    63         Path src = base.resolve("src");
    61         tb.writeJavaFiles(src.resolve("m1"), "module m1 { }");
    64         tb.writeJavaFiles(src.resolve("m1"), "module m1 { }");
    62         tb.writeJavaFiles(src.resolve("m2"), "module m2 { }");
    65         tb.writeJavaFiles(src.resolve("m2"), "module m2 { }");
    63 
    66 
    64         String log = tb.new JavacTask()
    67         String log = new JavacTask(tb)
    65                 .options("-XDrawDiagnostics")
    68                 .options("-XDrawDiagnostics")
    66                 .files(findJavaFiles(src))
    69                 .files(findJavaFiles(src))
    67                 .run(ToolBox.Expect.FAIL)
    70                 .run(Task.Expect.FAIL)
    68                 .writeAll()
    71                 .writeAll()
    69                 .getOutput(ToolBox.OutputKind.DIRECT);
    72                 .getOutput(Task.OutputKind.DIRECT);
    70 
    73 
    71         if (!log.contains("module-info.java:1:1: compiler.err.too.many.modules"))
    74         if (!log.contains("module-info.java:1:1: compiler.err.too.many.modules"))
    72             throw new Exception("expected output not found");
    75             throw new Exception("expected output not found");
    73     }
    76     }
    74 
    77 
    77         Path src = base.resolve("src");
    80         Path src = base.resolve("src");
    78         tb.writeJavaFiles(src,
    81         tb.writeJavaFiles(src,
    79                 "module m { }",
    82                 "module m { }",
    80                 "class C { }");
    83                 "class C { }");
    81 
    84 
    82         tb.new JavacTask()
    85         new JavacTask(tb)
    83                 .classpath(src)
    86                 .classpath(src)
    84                 .files(src.resolve("C.java"))
    87                 .files(src.resolve("C.java"))
    85                 .run()
    88                 .run()
    86                 .writeAll();
    89                 .writeAll();
    87     }
    90     }
    93                 "module m { }",
    96                 "module m { }",
    94                 "class C { }");
    97                 "class C { }");
    95         Path classes = base.resolve("classes");
    98         Path classes = base.resolve("classes");
    96         Files.createDirectories(classes);
    99         Files.createDirectories(classes);
    97 
   100 
    98         tb.new JavacTask()
   101         new JavacTask(tb)
    99                 .outdir(classes)
   102                 .outdir(classes)
   100                 .files(src.resolve("module-info.java"))
   103                 .files(src.resolve("module-info.java"))
   101                 .run()
   104                 .run()
   102                 .writeAll();
   105                 .writeAll();
   103 
   106 
   104         tb.new JavacTask()
   107         new JavacTask(tb)
   105                 .classpath(classes)
   108                 .classpath(classes)
   106                 .files(src.resolve("C.java"))
   109                 .files(src.resolve("C.java"))
   107                 .run()
   110                 .run()
   108                 .writeAll();
   111                 .writeAll();
   109     }
   112     }
   115                 "module m { uses java.lang.Runnable; }",
   118                 "module m { uses java.lang.Runnable; }",
   116                 "class C { }");
   119                 "class C { }");
   117         Path classes = base.resolve("classes");
   120         Path classes = base.resolve("classes");
   118         Files.createDirectories(classes);
   121         Files.createDirectories(classes);
   119 
   122 
   120         tb.new JavacTask()
   123         new JavacTask(tb)
   121                 .outdir(classes)
   124                 .outdir(classes)
   122                 .files(src.resolve("module-info.java"))
   125                 .files(src.resolve("module-info.java"))
   123                 .run()
   126                 .run()
   124                 .writeAll();
   127                 .writeAll();
   125 
   128 
   126         tb.new JavacTask()
   129         new JavacTask(tb)
   127                 .options("-processor", VerifyUsesProvides.class.getName(),
   130                 .options("-processor", VerifyUsesProvides.class.getName(),
   128                          "-processorpath", System.getProperty("test.classes"))
   131                          "-processorpath", System.getProperty("test.classes"))
   129                 .outdir(classes)
   132                 .outdir(classes)
   130                 .classpath(classes)
   133                 .classpath(classes)
   131                 .files(src.resolve("C.java"))
   134                 .files(src.resolve("C.java"))
   140                 "module m { uses java.lang.Runnable; }",
   143                 "module m { uses java.lang.Runnable; }",
   141                 "class C { }");
   144                 "class C { }");
   142         Path classes = base.resolve("classes");
   145         Path classes = base.resolve("classes");
   143         Files.createDirectories(classes);
   146         Files.createDirectories(classes);
   144 
   147 
   145         tb.new JavacTask()
   148         new JavacTask(tb)
   146                 .options("-processor", VerifyUsesProvides.class.getName(),
   149                 .options("-processor", VerifyUsesProvides.class.getName(),
   147                          "-processorpath", System.getProperty("test.classes"))
   150                          "-processorpath", System.getProperty("test.classes"))
   148                 .outdir(classes)
   151                 .outdir(classes)
   149                 .sourcepath(src)
   152                 .sourcepath(src)
   150                 .classpath(classes)
   153                 .classpath(classes)