Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
langtools/test/tools/javac/processing/model/element/TestExecutableElement.java
changeset 21006 534673718919
parent 16803 3bdc22a32b0e
child 30730 d3ce7619db2c
equal deleted inserted replaced
21005:4db633bd7696 21006:534673718919 
    21  * questions.
 
    21  * questions.
 
    22  */
 
    22  */
 
    23 
    23 
    24 /*
 
    24 /*
 
    25  * @test
 
    25  * @test
 
    26  * @bug 8005046 8011052
 
    26  * @bug 8005046 8011052 8025087
 
    27  * @summary Test basic properties of javax.lang.element.Element
 
    27  * @summary Test basic properties of javax.lang.element.ExecutableElement
 
    28  * @author  Joseph D. Darcy
 
    28  * @author  Joseph D. Darcy
 
    29  * @library /tools/javac/lib
 
    29  * @library /tools/javac/lib
 
    30  * @build   JavacTestingAbstractProcessor TestExecutableElement
 
    30  * @build   JavacTestingAbstractProcessor TestExecutableElement
 
    31  * @compile -processor TestExecutableElement -proc:only TestExecutableElement.java
 
    31  * @compile -processor TestExecutableElement -proc:only -AexpectedMethodCount=7 TestExecutableElement.java
 
       
    32  * @compile/process -processor TestExecutableElement -proc:only -AexpectedMethodCount=3 ProviderOfDefault
 
    32  */
 
    33  */
 
    33 
    34 
    34 import java.lang.annotation.*;
 
    35 import java.lang.annotation.*;
 
    35 import java.util.Formatter;
 
    36 import java.util.Formatter;
 
    36 import java.util.Set;
 
    37 import java.util.Set;
 
    37 import java.util.Objects;
 
       
    38 import java.util.regex.*;
 
    38 import java.util.regex.*;
 
    39 import javax.annotation.processing.*;
 
    39 import javax.annotation.processing.*;
 
    40 import javax.lang.model.SourceVersion;
 
       
    41 import static javax.lang.model.SourceVersion.*;
 
       
    42 import javax.lang.model.element.*;
 
    40 import javax.lang.model.element.*;
 
    43 import javax.lang.model.util.*;
 
       
    44 import static javax.lang.model.util.ElementFilter.*;
 
    41 import static javax.lang.model.util.ElementFilter.*;
 
    45 import static javax.tools.Diagnostic.Kind.*;
 
    42 import static javax.tools.Diagnostic.Kind.*;
 
    46 import static javax.tools.StandardLocation.*;
 
       
    47 
    43 
    48 /**
 
    44 /**
 
    49  * Test some basic workings of javax.lang.element.ExecutableElement
 
    45  * Test some basic workings of javax.lang.element.ExecutableElement
 
    50  */
 
    46  */
 
       
    47 @SupportedOptions("expectedMethodCount")
 
    51 public class TestExecutableElement extends JavacTestingAbstractProcessor implements ProviderOfDefault {
 
    48 public class TestExecutableElement extends JavacTestingAbstractProcessor implements ProviderOfDefault {
 
       
    49     private int seenMethods = 0;
 
    52     @IsDefault(false)
 
    50     @IsDefault(false)
 
    53     public boolean process(Set<? extends TypeElement> annotations,
 
    51     public boolean process(Set<? extends TypeElement> annotations,
 
    54                            RoundEnvironment roundEnv) {
 
    52                            RoundEnvironment roundEnv) {
 
    55         int errors = 0;
 
       
    56         if (!roundEnv.processingOver()) {
 
    53         if (!roundEnv.processingOver()) {
 
    57             boolean hasRun = false;
 
       
    58             for (Element element : roundEnv.getRootElements()) {
 
    54             for (Element element : roundEnv.getRootElements()) {
 
    59                 for (ExecutableElement method : methodsIn(element.getEnclosedElements())) {
 
    55                 for (ExecutableElement method : methodsIn(element.getEnclosedElements())) {
 
    60                     hasRun = true;
 
    56                     checkIsDefault(method);
 
    61                     errors += checkIsDefault(method);
 
    57                     seenMethods++;
 
    62                 }
 
    58                 }
 
    63             }
 
    59             }
 
       
    60         } else {
 
       
    61             String expectedMethodCountStr = processingEnv.getOptions().get("expectedMethodCount");
 
       
    62             if (expectedMethodCountStr == null) {
 
       
    63                 messager.printMessage(ERROR, "No expected method count specified.");
 
       
    64             } else {
 
       
    65                 int expectedMethodCount = Integer.parseInt(expectedMethodCountStr);
 
    64 
    66 
    65             if (!hasRun) {
 
    67                 if (seenMethods != expectedMethodCount) {
 
    66                 messager.printMessage(ERROR, "No test cases run; test fails.");
 
    68                     messager.printMessage(ERROR, "Wrong number of seen methods: " + seenMethods);
 
       
    69                 }
 
    67             }
 
    70             }
 
    68         }
 
    71         }
 
    69         return true;
 
    72         return true;
 
    70     }
 
    73     }
 
    71 
    74 
    72     @IsDefault(false)
 
    75     @IsDefault(false)
 
    73     int checkIsDefault(ExecutableElement method) {
 
    76     void checkIsDefault(ExecutableElement method) {
 
    74         System.out.println("Testing " + method);
 
    77         System.out.println("Testing " + method);
 
    75         IsDefault expectedIsDefault = method.getAnnotation(IsDefault.class);
 
    78         IsDefault expectedIsDefault = method.getAnnotation(IsDefault.class);
 
    76 
    79 
    77         boolean expectedDefault = (expectedIsDefault != null) ?
 
    80         boolean expectedDefault = (expectedIsDefault != null) ?
 
    78             expectedIsDefault.value() :
 
    81             expectedIsDefault.value() :
 
   114             messager.printMessage(ERROR,
 
   117             messager.printMessage(ERROR,
 
   115                                   new Formatter().format("Unexpected Executable.isDefault result: got ``%s'', expected ``%s''.",
 
   118                                   new Formatter().format("Unexpected Executable.isDefault result: got ``%s'', expected ``%s''.",
 
   116                                                          expectedDefault,
 
   119                                                          expectedDefault,
 
   117                                                          methodIsDefault).toString(),
 
   120                                                          methodIsDefault).toString(),
 
   118                                   method);
 
   121                                   method);
 
   119             return 1;
 
       
   120         }
 
   122         }
 
   121         return 0;
 
       
   122     }
 
   123     }
 
   123 }
 
   124 }
 
   124 
   125 
   125 /**
 
   126 /**
 
   126  * Expected value of the ExecutableElement.isDefault method.
 
   127  * Expected value of the ExecutableElement.isDefault method.
 
   140     boolean process(Set<? extends TypeElement> annotations,
 
   141     boolean process(Set<? extends TypeElement> annotations,
 
   141                     RoundEnvironment roundEnv);
 
   142                     RoundEnvironment roundEnv);
 
   142 
   143 
   143     @IsDefault(value=true, expectedTextRegex="\\s*@IsDefault\\(.*\\)\\s*default strictfp void quux\\(\\);\\s*$")
 
   144     @IsDefault(value=true, expectedTextRegex="\\s*@IsDefault\\(.*\\)\\s*default strictfp void quux\\(\\);\\s*$")
 
   144     default strictfp void quux() {};
 
   145     default strictfp void quux() {};
 
       
   146     @IsDefault(false)
 
       
   147     static void statik() {}
 
   145 }
 
   148 }
jdk-sandbox