Mercurial > jdk8-mips64-public > langtools / file revision

 /*

  * Copyright 2006-2009 Sun Microsystems, Inc.  All Rights Reserved.

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

  *

  * This code is free software; you can redistribute it and/or modify it

  * under the terms of the GNU General Public License version 2 only, as

  * published by the Free Software Foundation.

  *

  * This code is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

  * CA 95054 USA or visit www.sun.com if you need additional information or

  * have any questions.

  */

 /*

  * @test

  * @bug 6397298 6400986 6425592 6449798 6453386 6508401 6498938

  * @summary Tests that getElementsAnnotatedWith works properly.

  * @author  Joseph D. Darcy

  * @compile TestElementsAnnotatedWith.java

  * @compile InheritedAnnotation.java

  * @compile -processor TestElementsAnnotatedWith -proc:only SurfaceAnnotations.java

  * @compile -processor TestElementsAnnotatedWith -proc:only BuriedAnnotations.java

  * @compile -processor TestElementsAnnotatedWith -proc:only Part1.java Part2.java

  * @compile -processor TestElementsAnnotatedWith -proc:only C2.java

  * @compile -processor TestElementsAnnotatedWith -proc:only Foo.java

  * @compile -XD-d=. Foo.java

  * @compile -processor TestElementsAnnotatedWith -proc:only TestElementsAnnotatedWith.java

  */

 import java.lang.annotation.Annotation;

 import java.io.*;

 import java.util.Collections;

 import java.util.Set;

 import java.util.HashSet;

 import java.util.List;

 import java.util.ArrayList;

 import java.util.Arrays;

 import javax.annotation.processing.*;

 import javax.tools.*;

 import javax.lang.model.SourceVersion;

 import javax.lang.model.element.*;

 import javax.lang.model.util.*;

 import static javax.lang.model.util.ElementFilter.*;

 /**

  * This processor verifies that the information returned by

  * getElementsAnnotatedWith is consistent with the expected results

  * stored in an AnnotatedElementInfo annotation.

  */

 @SupportedAnnotationTypes("*")

 @AnnotatedElementInfo(annotationName="java.lang.SuppressWarnings", expectedSize=0, names={})

 public class TestElementsAnnotatedWith extends AbstractProcessor {

     public boolean process(Set<? extends TypeElement> annotations,

                            RoundEnvironment roundEnvironment) {

         Elements elementUtils = processingEnv.getElementUtils();

         TypeElement annotatedElementInfoElement =

             elementUtils.getTypeElement("AnnotatedElementInfo");

         Set<? extends Element> resultsMeta = Collections.emptySet();

         Set<? extends Element> resultsBase = Collections.emptySet();

         if (!roundEnvironment.processingOver()) {

             testNonAnnotations(roundEnvironment);

             // Verify AnnotatedElementInfo is present on the first

             // specified type.

             TypeElement firstType = typesIn(roundEnvironment.getRootElements()).iterator().next();

             AnnotatedElementInfo annotatedElementInfo = firstType.getAnnotation(AnnotatedElementInfo.class);

             boolean failed = false;

             if (annotatedElementInfo == null)

                 throw new IllegalArgumentException("Missing AnnotatedElementInfo annotation on " +

                                                   firstType);

             else {

                 // Verify that the annotation information is as

                 // expected.

                 Set<String> expectedNames = new HashSet<String>(Arrays.asList(annotatedElementInfo.names()));

                 resultsMeta =

                     roundEnvironment.

                     getElementsAnnotatedWith(elementUtils.

                                              getTypeElement(annotatedElementInfo.

                                                             annotationName())) ;

                 System.err.println("Results: " + resultsMeta);

                 if (resultsMeta.size() != annotatedElementInfo.expectedSize()) {

                     failed = true;

                     System.err.printf("Bad number of elements; expected %d, got %d%n",

                                       annotatedElementInfo.expectedSize(), resultsMeta.size());

                 } else {

                     for(Element element : resultsMeta) {

                         String simpleName = element.getSimpleName().toString();

                         if (!expectedNames.contains(simpleName) ) {

                             failed = true;

                             System.err.println("Name ``" + simpleName + "'' not expected.");

                         }

                     }

                 }

             }

             resultsBase = computeResultsBase(roundEnvironment, annotatedElementInfo.annotationName());

             if (!resultsMeta.equals(resultsBase)) {

                 failed = true;

                 System.err.println("Base and Meta sets unequal;\n meta: " + resultsMeta +

                                    "\nbase: " + resultsBase);

             }

             if (failed) {

                 System.err.println("AnnotatedElementInfo: " + annotatedElementInfo);

                 throw new RuntimeException();

             }

             if("TestElementsAnnotatedWith".equals(firstType.getSimpleName().toString()))

                writeClassFile(); // Start another round to test class file input

         } else {

             // If processing is over without an error, the specified

             // elements should be empty so an empty set should be returned.

             resultsMeta = roundEnvironment.getElementsAnnotatedWith(annotatedElementInfoElement);

             resultsBase = roundEnvironment.getElementsAnnotatedWith(AnnotatedElementInfo.class);

             if (!resultsMeta.isEmpty())

                 throw new RuntimeException("Nonempty resultsMeta: " + resultsMeta);

             if (!resultsBase.isEmpty())

                 throw new RuntimeException("Nonempty resultsBase: " + resultsBase);

         }

         return true;

     }

     private Set<? extends Element> computeResultsBase(RoundEnvironment roundEnvironment, String name) {

         try {

             return roundEnvironment.

                 getElementsAnnotatedWith(Class.forName(name).asSubclass(Annotation.class));

         } catch(ClassNotFoundException cnfe) {

             throw new RuntimeException(cnfe);

         }

     }

     /**

      * Verify non-annotation types result in

      * IllegalArgumentExceptions.

      */

     private void testNonAnnotations(RoundEnvironment roundEnvironment) {

         try {

             Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith((Class)Object.class );

             throw new RuntimeException("Illegal argument exception not thrown");

         } catch(IllegalArgumentException iae) {}

         try {

             Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(processingEnv.

                                                                                         getElementUtils().

                                                                                         getTypeElement("java.lang.Object") );

             throw new RuntimeException("Illegal argument exception not thrown");

         } catch(IllegalArgumentException iae) {}

     }

     /*

      * Hack alert!  The class file read below is generated by the

      * "@compile -XD-d=. Foo.java" directive above.  This sneakily

      * overrides the output location to the current directory where a

      * subsequent @compile can read the file.  This could be improved

      * if either a new directive like @process accepted class file

      * arguments (the javac command accepts such arguments but

      * @compile does not) or the test.src and test.classes properties

      * were set to be read with @compile jobs.

      */

     private void writeClassFile() {

         try {

             Filer filer = processingEnv.getFiler();

             JavaFileObject jfo = filer.createClassFile("Foo");

             OutputStream os = jfo.openOutputStream();

             // Copy the bytes over

             System.out.println((new File(".")).getAbsolutePath());

             InputStream io = new BufferedInputStream(new FileInputStream(new File(".", "Foo.class")));

             try {

                 int datum = io.read();

                 while(datum != -1) {

                     os.write(datum);

                     datum = io.read();

                 }

             } finally {

                 io.close();

             }

             os.close();

         } catch (IOException ioe) {

             throw new RuntimeException(ioe);

         }

     }

     @Override

     public SourceVersion getSupportedSourceVersion() {

         return SourceVersion.latest();

     }

 }