1 /* 2 * Copyright (c) 2015, 2016, 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 8072480 27 * @summary Ensure all methods of PlatformProvider are called correctly, and their result is used 28 * correctly. 29 * @library /tools/lib 30 * @modules jdk.compiler/com.sun.tools.javac.api 31 * jdk.compiler/com.sun.tools.javac.main 32 * jdk.compiler/com.sun.tools.javac.platform 33 * jdk.compiler/com.sun.tools.javac.util 34 * @build toolbox.ToolBox PlatformProviderTest 35 * @run main/othervm PlatformProviderTest 36 */ 37 38 import java.io.IOException; 39 import java.io.Writer; 40 import java.lang.reflect.Field; 41 import java.nio.file.Files; 42 import java.nio.file.Path; 43 import java.nio.file.Paths; 44 import java.util.ArrayList; 45 import java.util.Arrays; 46 import java.util.Collection; 47 import java.util.Collections; 48 import java.util.List; 49 import java.util.Map; 50 import java.util.Set; 51 52 import javax.annotation.processing.AbstractProcessor; 53 import javax.annotation.processing.Processor; 54 import javax.annotation.processing.RoundEnvironment; 55 import javax.annotation.processing.SupportedAnnotationTypes; 56 import javax.annotation.processing.SupportedOptions; 57 import javax.lang.model.SourceVersion; 58 import javax.lang.model.element.TypeElement; 59 import javax.tools.JavaCompiler; 60 import javax.tools.StandardJavaFileManager; 61 import javax.tools.StandardLocation; 62 import javax.tools.ToolProvider; 63 64 // import com.sun.source.util.JavacTask; 65 import com.sun.source.util.Plugin; 66 import com.sun.tools.javac.platform.PlatformDescription; 67 import com.sun.tools.javac.platform.PlatformProvider; 68 import com.sun.tools.javac.util.Log; 69 70 import toolbox.JavacTask; 71 import toolbox.Task; 72 import toolbox.ToolBox; 73 74 public class PlatformProviderTest implements PlatformProvider { 75 76 public static void main(String... args) throws IOException { 77 new PlatformProviderTest().run(); 78 } 79 80 void run() throws IOException { 81 Path registration = Paths.get(System.getProperty("test.classes"), 82 "META-INF", 83 "services", 84 "com.sun.tools.javac.platform.PlatformProvider"); 85 Files.createDirectories(registration.getParent()); 86 try (Writer metaInf = Files.newBufferedWriter(registration)) { 87 metaInf.write(PlatformProviderTest.class.getName()); 88 } 89 90 doTest("name", ""); 91 doTest("name:param", "param"); 92 doTestFailure(); 93 } 94 95 void doTest(String platformSpec, String expectedParameter) { 96 ToolBox tb = new ToolBox(); 97 Task.Result result = 98 new JavacTask(tb, Task.Mode.EXEC) 99 .outdir(".") 100 .options("-J-classpath", 101 "-J" + System.getProperty("test.classes"), 102 "-J-XaddExports:jdk.compiler/com.sun.tools.javac.platform=ALL-UNNAMED", 103 "-J-XaddExports:jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED", 104 "-XDrawDiagnostics", 105 "-release", 106 platformSpec, 107 System.getProperty("test.src") + "/PlatformProviderTestSource.java") 108 .run(); 109 110 List<String> expectedOutput = 111 Arrays.asList("getSupportedPlatformNames", 112 "getPlatform(name, " + expectedParameter + ")", 113 "getSourceVersion", 114 "getTargetVersion", 115 "getPlatformPath", 116 "testPlugin: [testPluginKey=testPluginValue]", 117 "process: {testAPKey=testAPValue}", 118 "process: {testAPKey=testAPValue}", 119 "PlatformProviderTestSource.java:4:49: compiler.warn.raw.class.use: java.util.ArrayList, java.util.ArrayList<E>", 120 "compiler.misc.count.warn", 121 "close"); 122 List<String> actualOutput = result.getOutputLines(Task.OutputKind.STDERR); 123 result.writeAll(); 124 if (!expectedOutput.equals(actualOutput)) { 125 throw new AssertionError( "Expected output: " + expectedOutput + 126 "; actual output: " + actualOutput); 127 } 128 result.writeAll(); 129 } 130 131 void doTestFailure() { 132 ToolBox tb = new ToolBox(); 133 Task.Result result = 134 new JavacTask(tb, Task.Mode.EXEC) 135 .outdir(".") 136 .options("-J-classpath", 137 "-J" + System.getProperty("test.classes"), 138 "-J-XaddExports:jdk.compiler/com.sun.tools.javac.platform=ALL-UNNAMED", 139 "-J-XaddExports:jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED", 140 "-release", 141 "fail", 142 System.getProperty("test.src") + "/PlatformProviderTestSource.java") 143 .run(Task.Expect.FAIL); 144 145 List<String> expectedOutput = 146 Arrays.asList("getSupportedPlatformNames", 147 "getPlatform(fail, )", 148 "javac: javac.err.unsupported.release.version", 149 "javac.msg.usage"); 150 List<String> actualOutput = result.getOutputLines(Task.OutputKind.STDERR); 151 result.writeAll(); 152 if (!expectedOutput.equals(actualOutput)) { 153 throw new AssertionError( "Expected output: " + expectedOutput + 154 "; actual output: " + actualOutput); 155 } 156 result.writeAll(); 157 } 158 159 @Override 160 public Iterable<String> getSupportedPlatformNames() { 161 System.err.println("getSupportedPlatformNames"); 162 return Arrays.asList("name", "fail"); 163 } 164 165 @Override 166 public PlatformDescription getPlatform(String platformName, String options) throws PlatformNotSupported { 167 System.err.println("getPlatform(" + platformName + ", " + options + ")"); 168 169 if ("fail".equals(platformName)) { 170 throw new PlatformNotSupported(); 171 } 172 173 return new DescriptionImpl(); 174 } 175 176 static { 177 try { 178 Field useRawMessages = Log.class.getDeclaredField("useRawMessages"); 179 180 useRawMessages.setAccessible(true); 181 useRawMessages.set(null, true); 182 } catch (Exception ex) { 183 throw new IllegalStateException(ex); 184 } 185 } 186 187 class DescriptionImpl implements PlatformDescription { 188 189 private final JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); 190 private final StandardJavaFileManager fm = compiler.getStandardFileManager(null, null, null); 191 192 193 @Override 194 public Collection<Path> getPlatformPath() { 195 System.err.println("getPlatformPath"); 196 List<Path> result = new ArrayList<>(); 197 fm.getLocationAsPaths(StandardLocation.PLATFORM_CLASS_PATH).forEach(p -> { result.add(p); }); 198 return result; 199 } 200 201 @Override 202 public String getSourceVersion() { 203 System.err.println("getSourceVersion"); 204 return "8"; 205 } 206 207 @Override 208 public String getTargetVersion() { 209 System.err.println("getTargetVersion"); 210 return "8"; 211 } 212 213 @Override 214 public List<PluginInfo<Processor>> getAnnotationProcessors() { 215 return Arrays.asList(new PluginInfo<Processor>() { 216 @Override 217 public String getName() { 218 return "test"; 219 } 220 @Override 221 public Map<String, String> getOptions() { 222 return Collections.singletonMap("testAPKey", "testAPValue"); 223 } 224 @Override 225 public Processor getPlugin() { 226 return new ProcessorImpl(); 227 } 228 }); 229 } 230 231 @Override 232 public List<PluginInfo<Plugin>> getPlugins() { 233 return Arrays.asList(new PluginInfo<Plugin>() { 234 @Override 235 public String getName() { 236 return "testPlugin"; 237 } 238 @Override 239 public Map<String, String> getOptions() { 240 return Collections.singletonMap("testPluginKey", "testPluginValue"); 241 } 242 @Override 243 public Plugin getPlugin() { 244 return new PluginImpl(); 245 } 246 }); 247 } 248 249 @Override 250 public List<String> getAdditionalOptions() { 251 return Arrays.asList("-Xlint:rawtypes", "-XDrawDiagnostics"); 252 } 253 254 @Override 255 public void close() throws IOException { 256 System.err.println("close"); 257 fm.close(); 258 } 259 260 } 261 262 @SupportedAnnotationTypes("*") 263 @SupportedOptions("testAPKey") 264 class ProcessorImpl extends AbstractProcessor { 265 266 @Override 267 public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { 268 System.err.println("process: " + processingEnv.getOptions()); 269 return true; 270 } 271 272 @Override 273 public SourceVersion getSupportedSourceVersion() { 274 return SourceVersion.latest(); 275 } 276 277 } 278 279 class PluginImpl implements Plugin { 280 281 @Override 282 public String getName() { 283 return "testPluginName"; 284 } 285 286 @Override 287 public void init(com.sun.source.util.JavacTask task, String... args) { 288 System.err.println("testPlugin: " + Arrays.toString(args)); 289 } 290 291 } 292 }