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