langtools/test/tools/javac/modules/AnnotationProcessing.java
changeset 36778 e04318f39f92
parent 36526 3b41f1c69604
child 37758 3ecf9b414e05
equal deleted inserted replaced
36777:28d33fb9097f 36778:e04318f39f92
    26  * @summary Verify that annotation processing works.
    26  * @summary Verify that annotation processing works.
    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 AnnotationProcessing
    32  * @run main AnnotationProcessing
    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;
    56 import javax.lang.model.element.TypeElement;
    55 import javax.lang.model.element.TypeElement;
    57 import javax.lang.model.type.TypeKind;
    56 import javax.lang.model.type.TypeKind;
    58 import javax.lang.model.util.ElementFilter;
    57 import javax.lang.model.util.ElementFilter;
    59 import javax.lang.model.util.ElementScanner9;
    58 import javax.lang.model.util.ElementScanner9;
    60 
    59 
       
    60 import toolbox.JavacTask;
       
    61 import toolbox.Task;
       
    62 import toolbox.ToolBox;
       
    63 
    61 public class AnnotationProcessing extends ModuleTestBase {
    64 public class AnnotationProcessing extends ModuleTestBase {
    62 
    65 
    63     public static void main(String... args) throws Exception {
    66     public static void main(String... args) throws Exception {
    64         new AnnotationProcessing().runTests();
    67         new AnnotationProcessing().runTests();
    65     }
    68     }
    75 
    78 
    76         tb.writeJavaFiles(m1,
    79         tb.writeJavaFiles(m1,
    77                           "module m1 { }",
    80                           "module m1 { }",
    78                           "package impl; public class Impl { }");
    81                           "package impl; public class Impl { }");
    79 
    82 
    80         String log = tb.new JavacTask()
    83         String log = new JavacTask(tb)
    81                 .options("-modulesourcepath", moduleSrc.toString(),
    84                 .options("-modulesourcepath", moduleSrc.toString(),
    82                          "-processor", AP.class.getName(),
    85                          "-processor", AP.class.getName(),
    83                          "-AexpectedEnclosedElements=m1=>impl")
    86                          "-AexpectedEnclosedElements=m1=>impl")
    84                 .outdir(classes)
    87                 .outdir(classes)
    85                 .files(findJavaFiles(moduleSrc))
    88                 .files(findJavaFiles(moduleSrc))
    86                 .run()
    89                 .run()
    87                 .writeAll()
    90                 .writeAll()
    88                 .getOutput(ToolBox.OutputKind.DIRECT);
    91                 .getOutput(Task.OutputKind.DIRECT);
    89 
    92 
    90         if (!log.isEmpty())
    93         if (!log.isEmpty())
    91             throw new AssertionError("Unexpected output: " + log);
    94             throw new AssertionError("Unexpected output: " + log);
    92     }
    95     }
    93 
    96 
   107 
   110 
   108         tb.writeJavaFiles(m2,
   111         tb.writeJavaFiles(m2,
   109                           "module m2 { }",
   112                           "module m2 { }",
   110                           "package impl2; public class Impl2 { }");
   113                           "package impl2; public class Impl2 { }");
   111 
   114 
   112         String log = tb.new JavacTask()
   115         String log = new JavacTask(tb)
   113                 .options("-modulesourcepath", moduleSrc.toString(),
   116                 .options("-modulesourcepath", moduleSrc.toString(),
   114                          "-processor", AP.class.getName(),
   117                          "-processor", AP.class.getName(),
   115                          "-AexpectedEnclosedElements=m1=>impl1,m2=>impl2")
   118                          "-AexpectedEnclosedElements=m1=>impl1,m2=>impl2")
   116                 .outdir(classes)
   119                 .outdir(classes)
   117                 .files(findJavaFiles(moduleSrc))
   120                 .files(findJavaFiles(moduleSrc))
   118                 .run()
   121                 .run()
   119                 .writeAll()
   122                 .writeAll()
   120                 .getOutput(ToolBox.OutputKind.DIRECT);
   123                 .getOutput(Task.OutputKind.DIRECT);
   121 
   124 
   122         if (!log.isEmpty())
   125         if (!log.isEmpty())
   123             throw new AssertionError("Unexpected output: " + log);
   126             throw new AssertionError("Unexpected output: " + log);
   124     }
   127     }
   125 
   128 
   204         tb.writeJavaFiles(m1,
   207         tb.writeJavaFiles(m1,
   205                           "module m1 { exports api; uses api.Api; provides api.Api with impl.Impl; }",
   208                           "module m1 { exports api; uses api.Api; provides api.Api with impl.Impl; }",
   206                           "package api; public class Api { }",
   209                           "package api; public class Api { }",
   207                           "package impl; public class Impl extends api.Api { }");
   210                           "package impl; public class Impl extends api.Api { }");
   208 
   211 
   209         String log = tb.new JavacTask()
   212         String log = new JavacTask(tb)
   210                 .options("-doe", "-processor", VerifyUsesProvidesAP.class.getName())
   213                 .options("-doe", "-processor", VerifyUsesProvidesAP.class.getName())
   211                 .outdir(classes)
   214                 .outdir(classes)
   212                 .files(findJavaFiles(moduleSrc))
   215                 .files(findJavaFiles(moduleSrc))
   213                 .run()
   216                 .run()
   214                 .writeAll()
   217                 .writeAll()
   215                 .getOutput(ToolBox.OutputKind.DIRECT);
   218                 .getOutput(Task.OutputKind.DIRECT);
   216 
   219 
   217         if (!log.isEmpty())
   220         if (!log.isEmpty())
   218             throw new AssertionError("Unexpected output: " + log);
   221             throw new AssertionError("Unexpected output: " + log);
   219     }
   222     }
   220 
   223 
   258         Files.createDirectories(classes);
   261         Files.createDirectories(classes);
   259 
   262 
   260         tb.writeJavaFiles(src,
   263         tb.writeJavaFiles(src,
   261                           "package api; public class Api { }");
   264                           "package api; public class Api { }");
   262 
   265 
   263         String log = tb.new JavacTask()
   266         String log = new JavacTask(tb)
   264                 .options("-processor", VerifyPackageNoModule.class.getName(),
   267                 .options("-processor", VerifyPackageNoModule.class.getName(),
   265                          "-source", "8",
   268                          "-source", "8",
   266                          "-Xlint:-options")
   269                          "-Xlint:-options")
   267                 .outdir(classes)
   270                 .outdir(classes)
   268                 .files(findJavaFiles(src))
   271                 .files(findJavaFiles(src))
   269                 .run()
   272                 .run()
   270                 .writeAll()
   273                 .writeAll()
   271                 .getOutput(ToolBox.OutputKind.DIRECT);
   274                 .getOutput(Task.OutputKind.DIRECT);
   272 
   275 
   273         if (!log.isEmpty())
   276         if (!log.isEmpty())
   274             throw new AssertionError("Unexpected output: " + log);
   277             throw new AssertionError("Unexpected output: " + log);
   275     }
   278     }
   276 
   279