1 /*
   2  * Copyright (c) 2004, 2007, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   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
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 
  25 import com.sun.mirror.apt.*;
  26 import com.sun.mirror.declaration.*;
  27 import com.sun.mirror.type.*;
  28 import com.sun.mirror.util.*;
  29 
  30 import java.util.Collection;
  31 import java.util.Set;
  32 import java.util.Arrays;
  33 
  34 import java.io.IOException;
  35 import java.io.File;
  36 
  37 import static java.util.Collections.*;
  38 import static com.sun.mirror.util.DeclarationVisitors.*;
  39 
  40 /*
  41  * Factory to help test updated discovery policy.
  42  */
  43 public class Round2Apf implements AnnotationProcessorFactory {
  44     // Process @Round2
  45     private static final Collection<String> supportedAnnotations
  46         = unmodifiableCollection(Arrays.asList("Round2"));
  47 
  48     // No supported options
  49     private static final Collection<String> supportedOptions = emptySet();
  50 
  51     public Collection<String> supportedAnnotationTypes() {
  52         return supportedAnnotations;
  53     }
  54 
  55     public Collection<String> supportedOptions() {
  56         return supportedOptions;
  57     }
  58 
  59     private static int round = 0;
  60 
  61     public AnnotationProcessor getProcessorFor(
  62             Set<AnnotationTypeDeclaration> atds,
  63             AnnotationProcessorEnvironment env) {
  64         return new Round2Ap(env, atds.size() == 0);
  65     }
  66 
  67     private static class Round2Ap implements AnnotationProcessor {
  68         private final AnnotationProcessorEnvironment env;
  69         private final boolean empty;
  70 
  71         Round2Ap(AnnotationProcessorEnvironment env, boolean empty) {
  72             this.env = env;
  73             this.empty = empty;
  74         }
  75 
  76         public void process() {
  77             Round2Apf.round++;
  78             Filer f = env.getFiler();
  79             try {
  80                 f.createSourceFile("Dummy2").println("@Round2 class Dummy2{}");
  81                 throw new RuntimeException("Duplicate file creation allowed");
  82             } catch (IOException io) {}
  83 
  84             try {
  85                 f.createTextFile(Filer.Location.SOURCE_TREE,
  86                                  "",
  87                                  new File("foo.txt"),
  88                                  null).println("xxyzzy");
  89                 throw new RuntimeException("Duplicate file creation allowed");
  90             } catch (IOException io) {}
  91 
  92             try {
  93                 f.createClassFile("Vacant");
  94                 throw new RuntimeException("Duplicate file creation allowed");
  95             } catch (IOException io) {}
  96 
  97             try {
  98                 f.createBinaryFile(Filer.Location.CLASS_TREE,
  99                                    "",
 100                                    new File("onezero"));
 101                 throw new RuntimeException("Duplicate file creation allowed");
 102             } catch (IOException io) {}
 103 
 104 
 105 
 106             try {
 107                 if (!empty) {
 108                     // Create corresponding files of opposite kind to
 109                     // the files created by Round1Apf; these should
 110                     // only generate warnings
 111                     f.createClassFile("Dummy2");
 112                     f.createSourceFile("Vacant").println("class Vacant{}");
 113 
 114                     f.createSourceFile("Dummy3").println("@Round3 class Dummy3{}");
 115 
 116                     // This should generated a warning too
 117                     f.createClassFile("Dummy3");
 118                 }
 119             } catch (java.io.IOException ioe) {
 120                 throw new RuntimeException(ioe);
 121             }
 122 
 123             System.out.println("Round2Apf: " + round);
 124         }
 125     }
 126 }