1 /* 2 * Copyright (c) 2006, 2010, 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 * @test 26 * @bug 6341866 27 * @summary Source files loaded from source path are not subject to annotation processing 28 * @build Anno T6341866 29 * @run main T6341866 30 */ 31 32 import java.io.*; 33 import java.util.*; 34 import javax.annotation.processing.*; 35 import javax.tools.*; 36 37 /** 38 * For each of a number of implicit compilation scenarios, 39 * and for each of a set of annotation processing scenarios, 40 * verify that a class file is generated, or not, for an 41 * implicitly compiled source file and that the correct 42 * warning message is given for implicitly compiled files 43 * when annotation processing. 44 */ 45 public class T6341866 { 46 static final String testSrc = System.getProperty("test.src", "."); 47 static final String testClasses = System.getProperty("test.classes", "."); 48 static final File a_java = new File(testSrc, "A.java"); 49 static final File a_class = new File("A.class"); 50 static final File b_java = new File(testSrc, "B.java"); 51 static final File b_class = new File("B.class"); 52 static final File processorServices = services(Processor.class); 53 54 enum ImplicitType { 55 NONE(null), // don't use implicit compilation 56 OPT_UNSET(null), // implicit compilation, but no -implicit option 57 OPT_NONE("-implicit:none"), // implicit compilation wiith -implicit:none 58 OPT_CLASS("-implicit:class"); // implicit compilation wiith -implicit:class 59 60 ImplicitType(String opt) { 61 this.opt = opt; 62 } 63 final String opt; 64 }; 65 66 enum AnnoType { 67 NONE, // no annotation processing 68 SERVICE, // implicit annotation processing, via ServiceLoader 69 SPECIFY // explicit annotation processing 70 }; 71 72 73 public static void main(String ... args) throws Exception { 74 boolean ok = true; 75 76 // iterate over all combinations 77 for (ImplicitType implicitType: EnumSet.allOf(ImplicitType.class)) { 78 for (AnnoType annoType: EnumSet.allOf(AnnoType.class)) { 79 ok &= test(implicitType, annoType); 80 } 81 } 82 83 if (!ok) 84 throw new AssertionError("test failed"); 85 } 86 87 /** 88 * Verify that a class file is generated, or not, for an implicitly compiled source file, 89 * and that the correct warning message is given for implicitly compiled files when annotation processing. 90 */ 91 static boolean test(ImplicitType implicitType, AnnoType annoType) throws IOException { 92 System.err.println("test implicit=" + implicitType + " anno=" + annoType); 93 94 // ensure clean start 95 a_class.delete(); 96 b_class.delete(); 97 processorServices.delete(); 98 99 List<String> opts = new ArrayList<String>(); 100 opts.addAll(Arrays.asList("-d", ".", "-sourcepath", testSrc, "-classpath", testClasses, "-source", "1.6", "-Xlint:-options")); 101 if (implicitType.opt != null) 102 opts.add(implicitType.opt); 103 104 switch (annoType) { 105 case SERVICE: 106 createProcessorServices(Anno.class.getName()); 107 break; 108 case SPECIFY: 109 opts.addAll(Arrays.asList("-processor", Anno.class.getName())); 110 break; 111 } 112 113 114 JavaCompiler javac = ToolProvider.getSystemJavaCompiler(); 115 MyDiagListener dl = new MyDiagListener(); 116 StandardJavaFileManager fm = javac.getStandardFileManager(dl, null, null); 117 118 // Note: class A references class B, so compile A if we want implicit compilation 119 File file = (implicitType != ImplicitType.NONE) ? a_java : b_java; 120 Iterable<? extends JavaFileObject> files = fm.getJavaFileObjects(file); 121 122 //System.err.println("compile: " + opts + " " + files); 123 124 boolean ok = javac.getTask(null, fm, dl, opts, null, files).call(); 125 if (!ok) { 126 error("compilation failed"); 127 return false; 128 } 129 130 // check implicit compilation results if necessary 131 if (implicitType != ImplicitType.NONE) { 132 boolean expectClass = (implicitType != ImplicitType.OPT_NONE); 133 if (b_class.exists() != expectClass) { 134 if (b_class.exists()) 135 error("B implicitly compiled unexpectedly"); 136 else 137 error("B not impliictly compiled"); 138 return false; 139 } 140 } 141 142 // check message key results 143 String expectKey = null; 144 if (implicitType == ImplicitType.OPT_UNSET) { 145 switch (annoType) { 146 case SERVICE: 147 expectKey = "compiler.warn.proc.use.proc.or.implicit"; 148 break; 149 case SPECIFY: 150 expectKey = "compiler.warn.proc.use.implicit"; 151 break; 152 } 153 } 154 155 if (expectKey == null) { 156 if (dl.diagCodes.size() != 0) { 157 error("no diagnostics expected"); 158 return false; 159 } 160 } else { 161 if (!(dl.diagCodes.size() == 1 && dl.diagCodes.get(0).equals(expectKey))) { 162 error("unexpected diagnostics generated"); 163 return false; 164 } 165 } 166 167 return true; 168 } 169 170 static void createProcessorServices(String name) throws IOException { 171 processorServices.getParentFile().mkdirs(); 172 173 BufferedWriter out = new BufferedWriter(new FileWriter(processorServices)); 174 out.write(name); 175 out.newLine(); 176 out.close(); 177 } 178 179 static class MyDiagListener implements DiagnosticListener<JavaFileObject> { 180 public void report(Diagnostic d) { 181 diagCodes.add(d.getCode()); 182 System.err.println(d); 183 } 184 185 List<String> diagCodes = new ArrayList<String>(); 186 } 187 188 static void error(String msg) { 189 System.err.println("ERROR: " + msg); 190 } 191 192 static File services(Class<?> service) { 193 String[] dirs = { testClasses, "META-INF", "services" }; 194 File dir = null; 195 for (String d: dirs) 196 dir = (dir == null ? new File(d) : new File(dir, d)); 197 198 return new File(dir, service.getName()); 199 } 200 }