| /* |
| * Copyright (c) 2014, 2016, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /* |
| * @test |
| * @bug 7026941 |
| * @summary path options ignored when reusing filemanager across tasks |
| * @modules java.compiler |
| * jdk.compiler |
| */ |
| |
| import java.io.File; |
| import java.io.FileWriter; |
| import java.io.IOException; |
| import java.io.PrintWriter; |
| import java.net.URI; |
| import java.nio.file.Files; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.EnumSet; |
| import java.util.List; |
| import java.util.Objects; |
| import java.util.jar.JarEntry; |
| import java.util.jar.JarOutputStream; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| |
| import javax.tools.JavaCompiler; |
| import javax.tools.JavaCompiler.CompilationTask; |
| import javax.tools.JavaFileObject; |
| import javax.tools.SimpleJavaFileObject; |
| import javax.tools.StandardJavaFileManager; |
| import javax.tools.StandardLocation; |
| import javax.tools.ToolProvider; |
| |
| import static javax.tools.StandardLocation.*; |
| |
| /** |
| * Test for combinations of using javac command-line options and fileManager setLocation |
| * calls to affect the locations available in the fileManager. |
| * |
| * Using a single Java compiler and file manager, for each of the standard locations, |
| * a series of operations is performed, using either compiler options or setLocation |
| * calls. Each operation includes a compilation, and then a check for the value of |
| * the standard location available in the file manager. |
| * |
| * The operations generate and use unique files to minimize the possibility of false |
| * positive results. |
| */ |
| public class TestSearchPaths { |
| |
| public static void main(String... args) throws Exception { |
| TestSearchPaths t = new TestSearchPaths(); |
| t.run(); |
| } |
| |
| void run() throws Exception { |
| compiler = ToolProvider.getSystemJavaCompiler(); |
| fileManager = compiler.getStandardFileManager(null, null, null); |
| try { |
| // basic output path |
| testClassOutput(); |
| |
| // basic search paths |
| testClassPath(); |
| testSourcePath(); |
| testPlatformClassPath(); |
| |
| // annotation processing |
| testAnnotationProcessorPath(); |
| testSourceOutput(); |
| |
| // javah equivalent |
| testNativeHeaderOutput(); |
| |
| // future-proof: guard against new StandardLocations being added |
| if (!tested.equals(EnumSet.allOf(StandardLocation.class))) { |
| // FIXME: need to update for JDK 9 locations |
| // error("not all standard locations have been tested"); |
| out.println("not yet tested: " + EnumSet.complementOf(tested)); |
| } |
| |
| if (errors > 0) { |
| throw new Exception(errors + " errors occurred"); |
| } |
| } finally { |
| fileManager.close(); |
| } |
| } |
| |
| void testClassOutput() throws IOException { |
| String test = "testClassOutput"; |
| System.err.println("test: " + test); |
| |
| for (int i = 1; i <= 5; i++) { |
| File classes = createDir(test + "/" + i + "/classes"); |
| List<String> options; |
| switch (i) { |
| default: |
| options = getOptions("-d", classes.getPath()); |
| break; |
| |
| case 3: |
| setLocation(CLASS_OUTPUT, classes); |
| options = null; |
| break; |
| } |
| List<JavaFileObject> sources = getSources("class C" + i + " { }"); |
| callTask(options, sources); |
| checkPath(CLASS_OUTPUT, Mode.EQUALS, classes); |
| checkFile(CLASS_OUTPUT, "C" + i + ".class"); |
| } |
| |
| tested.add(CLASS_OUTPUT); |
| } |
| |
| void testClassPath() throws IOException { |
| String test = "testClassPath"; |
| System.err.println("test: " + test); |
| |
| for (int i = 1; i <= 5; i++) { |
| File classes = createDir(test + "/" + i + "/classes"); |
| File classpath = new File("testClassOutput/" + i + "/classes"); |
| List<String> options; |
| switch (i) { |
| default: |
| options = getOptions("-d", classes.getPath(), "-classpath", classpath.getPath()); |
| break; |
| |
| case 3: |
| setLocation(CLASS_PATH, classpath); |
| options = getOptions("-d", classes.getPath()); |
| break; |
| |
| case 4: |
| options = getOptions("-d", classes.getPath(), "-cp", classpath.getPath()); |
| break; |
| } |
| List<JavaFileObject> sources = getSources("class D" + i + " { C" + i + " c; }"); |
| callTask(options, sources); |
| checkPath(CLASS_PATH, Mode.EQUALS, classpath); |
| checkFile(CLASS_OUTPUT, "D" + i + ".class"); |
| } |
| |
| tested.add(CLASS_PATH); |
| System.err.println(); |
| } |
| |
| void testSourcePath() throws IOException { |
| String test = "testSourcePath"; |
| System.err.println("test: " + test); |
| setLocation(CLASS_PATH); // empty |
| |
| for (int i = 1; i <= 5; i++) { |
| File src = createDir(test + "/" + i + "/src"); |
| writeFile(src, "C" + i + ".java", "class C" + i + "{ }"); |
| File classes = createDir(test + "/" + i + "/classes"); |
| File srcpath = src; |
| List<String> options; |
| switch (i) { |
| default: |
| options = getOptions("-d", classes.getPath(), "-sourcepath", srcpath.getPath()); |
| break; |
| |
| case 3: |
| setLocation(SOURCE_PATH, srcpath); |
| options = getOptions("-d", classes.getPath()); |
| break; |
| } |
| List<JavaFileObject> sources = getSources("class D" + i + " { C" + i + " c; }"); |
| callTask(options, sources); |
| checkPath(SOURCE_PATH, Mode.EQUALS, srcpath); |
| checkFile(CLASS_OUTPUT, "D" + i + ".class"); |
| } |
| |
| tested.add(SOURCE_PATH); |
| System.err.println(); |
| } |
| |
| void testPlatformClassPath() throws IOException { |
| String test = "testPlatformClassPath"; |
| System.err.println("test: " + test); |
| |
| List<File> defaultPath = getLocation(PLATFORM_CLASS_PATH); |
| StringBuilder sb = new StringBuilder(); |
| for (File f: defaultPath) { |
| if (sb.length() > 0) |
| sb.append(File.pathSeparator); |
| sb.append(f); |
| } |
| String defaultPathString = sb.toString(); |
| |
| setLocation(CLASS_PATH); // empty |
| setLocation(SOURCE_PATH); // empty |
| |
| // Use -source 8 -target 8 to enable use of platform class path options |
| // FIXME: temporarily exclude cases referring to default bootclasspath |
| // for (int i = 1; i <= 10; i++) { |
| int[] cases = new int[] { 1, 2, 4, 5, 6, 7 }; |
| for (int i : cases) { |
| File classes = createDir(test + "/" + i + "/classes"); |
| File testJars = createDir(test + "/" + i + "/testJars"); |
| File testClasses = createDir(test + "/" + i + "/testClasses"); |
| callTask(getOptions("-d", testClasses.getPath()), getSources("class C" + i + " { }")); |
| |
| List<String> options; |
| Mode mode; |
| List<File> match; |
| String reference = "C" + i + " c;"; |
| |
| File jar; |
| |
| switch (i) { |
| case 1: |
| options = getOptions("-d", classes.getPath(), |
| "-source", "8", "-target", "8", |
| "-Xbootclasspath/p:" + testClasses); |
| mode = Mode.STARTS_WITH; |
| match = Arrays.asList(testClasses); |
| break; |
| |
| case 2: |
| // the default values for -extdirs and -endorseddirs come after the bootclasspath; |
| // so to check -Xbootclasspath/a: we specify empty values for those options. |
| options = getOptions("-d", classes.getPath(), |
| "-source", "8", "-target", "8", |
| "-Xbootclasspath/a:" + testClasses, |
| "-extdirs", "", |
| "-endorseddirs", ""); |
| mode = Mode.ENDS_WITH; |
| match = Arrays.asList(testClasses); |
| break; |
| |
| case 3: |
| options = getOptions("-d", classes.getPath(), "-Xbootclasspath:" + defaultPathString); |
| mode = Mode.EQUALS; |
| match = defaultPath; |
| reference = ""; |
| break; |
| |
| case 4: |
| fileManager.setLocation(PLATFORM_CLASS_PATH, null); |
| jar = new File(testJars, "j" + i + ".jar"); |
| writeJar(jar, testClasses, "C" + i + ".class"); |
| options = getOptions("-d", classes.getPath(), |
| "-source", "8", "-target", "8", |
| "-endorseddirs", testJars.getPath()); |
| mode = Mode.CONTAINS; |
| match = Arrays.asList(jar); |
| break; |
| |
| case 5: |
| fileManager.setLocation(PLATFORM_CLASS_PATH, null); |
| jar = new File(testJars, "j" + i + ".jar"); |
| writeJar(jar, testClasses, "C" + i + ".class"); |
| options = getOptions("-d", classes.getPath(), |
| "-source", "8", "-target", "8", |
| "-Djava.endorsed.dirs=" + testJars.getPath()); |
| mode = Mode.CONTAINS; |
| match = Arrays.asList(jar); |
| break; |
| |
| case 6: |
| fileManager.setLocation(PLATFORM_CLASS_PATH, null); |
| jar = new File(testJars, "j" + i + ".jar"); |
| writeJar(jar, testClasses, "C" + i + ".class"); |
| options = getOptions("-d", classes.getPath(), |
| "-source", "8", "-target", "8", |
| "-extdirs", testJars.getPath()); |
| mode = Mode.CONTAINS; |
| match = Arrays.asList(jar); |
| break; |
| |
| case 7: |
| fileManager.setLocation(PLATFORM_CLASS_PATH, null); |
| jar = new File(testJars, "j" + i + ".jar"); |
| writeJar(jar, testClasses, "C" + i + ".class"); |
| options = getOptions("-d", classes.getPath(), |
| "-source", "8", "-target", "8", |
| "-Djava.ext.dirs=" + testJars.getPath()); |
| mode = Mode.CONTAINS; |
| match = Arrays.asList(jar); |
| break; |
| |
| case 8: |
| setLocation(PLATFORM_CLASS_PATH, defaultPath); |
| options = getOptions("-d", classes.getPath()); |
| mode = Mode.EQUALS; |
| match = defaultPath; |
| reference = ""; |
| break; |
| |
| default: |
| options = getOptions("-d", classes.getPath(), |
| "-source", "8", "-target", "8", |
| "-bootclasspath", defaultPathString); |
| mode = Mode.EQUALS; |
| match = defaultPath; |
| reference = ""; |
| break; |
| } |
| List<JavaFileObject> sources = getSources("class D" + i + " { " + reference + " }"); |
| |
| callTask(options, sources); |
| checkPath(PLATFORM_CLASS_PATH, mode, match); |
| checkFile(CLASS_OUTPUT, "D" + i + ".class"); |
| } |
| |
| tested.add(PLATFORM_CLASS_PATH); |
| System.err.println(); |
| } |
| |
| void testAnnotationProcessorPath() throws IOException { |
| String test = "testAnnotationProcessorPath"; |
| System.err.println("test: " + test); |
| |
| fileManager.setLocation(PLATFORM_CLASS_PATH, null); |
| |
| String template = |
| "import java.util.*;\n" |
| + "import javax.annotation.processing.*;\n" |
| + "import javax.lang.model.*;\n" |
| + "import javax.lang.model.element.*;\n" |
| + "@SupportedAnnotationTypes(\"*\")\n" |
| + "public class A%d extends AbstractProcessor {\n" |
| + " public boolean process(Set<? extends TypeElement> annos, RoundEnvironment rEnv) {\n" |
| + " return true;\n" |
| + " }\n" |
| + " public SourceVersion getSupportedSourceVersion() {\n" |
| + " return SourceVersion.latest();\n" |
| + " }\n" |
| + "}"; |
| |
| for (int i = 1; i <= 5; i++) { |
| File classes = createDir(test + "/" + i + "/classes"); |
| File annodir = createDir(test + "/" + i + "/processors"); |
| callTask(getOptions("-d", annodir.getPath()), getSources(String.format(template, i))); |
| File annopath = annodir; |
| List<String> options; |
| switch (i) { |
| default: |
| options = getOptions("-d", classes.getPath(), |
| "-processorpath", annopath.getPath(), |
| "-processor", "A" + i); |
| break; |
| |
| case 3: |
| setLocation(ANNOTATION_PROCESSOR_PATH, annopath); |
| options = getOptions("-d", classes.getPath(), |
| "-processor", "A" + i); |
| break; |
| } |
| List<JavaFileObject> sources = getSources("class D" + i + " { }"); |
| callTask(options, sources); |
| checkPath(ANNOTATION_PROCESSOR_PATH, Mode.EQUALS, annopath); |
| checkFile(CLASS_OUTPUT, "D" + i + ".class"); |
| } |
| |
| tested.add(ANNOTATION_PROCESSOR_PATH); |
| System.err.println(); |
| } |
| |
| void testSourceOutput() throws IOException { |
| String test = "testAnnotationProcessorPath"; |
| System.err.println("test: " + test); |
| |
| String source = |
| "import java.io.*;\n" |
| + "import java.util.*;\n" |
| + "import javax.annotation.processing.*;\n" |
| + "import javax.lang.model.*;\n" |
| + "import javax.lang.model.element.*;\n" |
| + "import javax.tools.*;\n" |
| + "@SupportedOptions(\"name\")\n" |
| + "@SupportedAnnotationTypes(\"*\")\n" |
| + "public class A extends AbstractProcessor {\n" |
| + " int round = 0;\n" |
| + " public boolean process(Set<? extends TypeElement> annos, RoundEnvironment rEnv) {\n" |
| + " if (round++ == 0) try {\n" |
| + " String name = processingEnv.getOptions().get(\"name\");\n" |
| + " JavaFileObject fo = processingEnv.getFiler().createSourceFile(name);\n" |
| + " try (Writer out = fo.openWriter()) {\n" |
| + " out.write(\"class \" + name + \" { }\");\n" |
| + " }\n" |
| + " } catch (IOException e) { throw new Error(e); }\n" |
| + " return true;\n" |
| + " }\n" |
| + " public SourceVersion getSupportedSourceVersion() {\n" |
| + " return SourceVersion.latest();\n" |
| + " }\n" |
| + "}"; |
| |
| File annodir = createDir(test + "/processors"); |
| callTask(getOptions("-d", annodir.getPath()), getSources(source)); |
| setLocation(ANNOTATION_PROCESSOR_PATH, annodir); |
| |
| for (int i = 1; i <= 5; i++) { |
| File classes = createDir(test + "/" + i + "/classes"); |
| File genSrc = createDir(test + "/" + "/genSrc"); |
| List<String> options; |
| switch (i) { |
| default: |
| options = getOptions("-d", classes.getPath(), |
| "-processor", "A", "-Aname=G" + i, |
| "-s", genSrc.getPath()); |
| break; |
| |
| case 3: |
| setLocation(SOURCE_OUTPUT, genSrc); |
| options = getOptions("-d", classes.getPath(), |
| "-processor", "A", "-Aname=G" + i); |
| break; |
| } |
| List<JavaFileObject> sources = getSources("class D" + i + " { }"); |
| callTask(options, sources); |
| checkPath(SOURCE_OUTPUT, Mode.EQUALS, genSrc); |
| checkFile(CLASS_OUTPUT, "D" + i + ".class"); |
| checkFile(CLASS_OUTPUT, "G" + i + ".class"); |
| } |
| tested.add(SOURCE_OUTPUT); |
| System.err.println(); |
| } |
| |
| void testNativeHeaderOutput() throws IOException { |
| String test = "testNativeHeaderOutput"; |
| System.err.println("test: " + test); |
| |
| for (int i = 1; i <= 5; i++) { |
| File classes = createDir(test + "/" + i + "/classes"); |
| File headers = createDir(test + "/" + i + "/hdrs"); |
| List<String> options; |
| switch (i) { |
| default: |
| options = getOptions("-d", classes.getPath(), "-h", headers.getPath()); |
| break; |
| |
| case 3: |
| setLocation(NATIVE_HEADER_OUTPUT, headers); |
| options = getOptions("-d", classes.getPath()); |
| break; |
| } |
| List<JavaFileObject> sources = getSources("class C" + i + " { native void m(); }"); |
| callTask(options, sources); |
| checkPath(NATIVE_HEADER_OUTPUT, Mode.EQUALS, headers); |
| checkFile(NATIVE_HEADER_OUTPUT, "C" + i + ".h"); |
| } |
| |
| tested.add(StandardLocation.NATIVE_HEADER_OUTPUT); |
| System.err.println(); |
| } |
| |
| List<String> getOptions(String... args) { |
| return Arrays.asList(args); |
| } |
| |
| List<JavaFileObject> getSources(String... sources) { |
| List<JavaFileObject> list = new ArrayList<>(); |
| for (String s: sources) |
| list.add(getSource(s)); |
| return list; |
| } |
| |
| JavaFileObject getSource(final String source) { |
| return new SimpleJavaFileObject(getURIFromSource(source), JavaFileObject.Kind.SOURCE) { |
| @Override |
| public CharSequence getCharContent(boolean ignoreEncodingErrors) { |
| return source; |
| } |
| }; |
| } |
| |
| void callTask(List<String> options, List<JavaFileObject> files) { |
| out.print("compile: "); |
| if (options != null) { |
| for (String o: options) { |
| if (o.length() > 64) { |
| o = o.substring(0, 32) + "..." + o.substring(o.length() - 32); |
| } |
| out.print(" " + o); |
| } |
| } |
| for (JavaFileObject f: files) |
| out.print(" " + f.getName()); |
| out.println(); |
| CompilationTask t = compiler.getTask(out, fileManager, null, options, null, files); |
| boolean ok = t.call(); |
| if (!ok) |
| error("compilation failed"); |
| } |
| |
| enum Mode { EQUALS, CONTAINS, STARTS_WITH, ENDS_WITH }; |
| |
| void checkFile(StandardLocation l, String path) { |
| if (!l.isOutputLocation()) { |
| error("Not an output location: " + l); |
| return; |
| } |
| |
| List<File> files = getLocation(l); |
| if (files == null) { |
| error("location is unset: " + l); |
| return; |
| } |
| |
| if (files.size() != 1) |
| error("unexpected number of entries on " + l + ": " + files.size()); |
| |
| File f = new File(files.get(0), path); |
| if (!f.exists()) |
| error("file not found: " + f); |
| } |
| |
| void checkPath(StandardLocation l, Mode m, File expect) { |
| checkPath(l, m, Arrays.asList(expect)); |
| } |
| |
| void checkPath(StandardLocation l, Mode m, List<File> expect) { |
| List<File> files = getLocation(l); |
| if (files == null) { |
| error("location is unset: " + l); |
| return; |
| } |
| |
| switch (m) { |
| case EQUALS: |
| if (!Objects.equals(files, expect)) { |
| error("location does not match the expected files: " + l); |
| out.println("found: " + files); |
| out.println("expect: " + expect); |
| } |
| break; |
| |
| case CONTAINS: |
| int containsIndex = Collections.indexOfSubList(files, expect); |
| if (containsIndex == -1) { |
| error("location does not contain the expected files: " + l); |
| out.println("found: " + files); |
| out.println("expect: " + expect); |
| } |
| break; |
| |
| case STARTS_WITH: |
| int startsIndex = Collections.indexOfSubList(files, expect); |
| if (startsIndex != 0) { |
| error("location does not start with the expected files: " + l); |
| out.println("found: " + files); |
| out.println("expect: " + expect); |
| } |
| break; |
| |
| case ENDS_WITH: |
| int endsIndex = Collections.lastIndexOfSubList(files, expect); |
| if (endsIndex != files.size() - expect.size()) { |
| error("location does not end with the expected files: " + l); |
| out.println("found: " + files); |
| out.println("expect: " + expect); |
| } |
| break; |
| |
| } |
| } |
| |
| List<File> getLocation(StandardLocation l) { |
| Iterable<? extends File> iter = fileManager.getLocation(l); |
| if (iter == null) |
| return null; |
| List<File> files = new ArrayList<>(); |
| for (File f: iter) |
| files.add(f); |
| return files; |
| } |
| |
| void setLocation(StandardLocation l, File... files) throws IOException { |
| fileManager.setLocation(l, Arrays.asList(files)); |
| } |
| |
| void setLocation(StandardLocation l, List<File> files) throws IOException { |
| fileManager.setLocation(l, files); |
| } |
| |
| void writeFile(File dir, String path, String body) throws IOException { |
| try (FileWriter w = new FileWriter(new File(dir, path))) { |
| w.write(body); |
| } |
| } |
| |
| void writeJar(File jar, File dir, String... entries) throws IOException { |
| try (JarOutputStream j = new JarOutputStream(Files.newOutputStream(jar.toPath()))) { |
| for (String entry: entries) { |
| j.putNextEntry(new JarEntry(entry)); |
| j.write(Files.readAllBytes(dir.toPath().resolve(entry))); |
| } |
| } |
| } |
| |
| private static final Pattern packagePattern |
| = Pattern.compile("package\\s+(((?:\\w+\\.)*)(?:\\w+))"); |
| private static final Pattern classPattern |
| = Pattern.compile("(?:public\\s+)?(?:class|enum|interface)\\s+(\\w+)"); |
| |
| |
| private static URI getURIFromSource(String source) { |
| String packageName = null; |
| |
| Matcher matcher = packagePattern.matcher(source); |
| if (matcher.find()) { |
| packageName = matcher.group(1).replace(".", "/"); |
| } |
| |
| matcher = classPattern.matcher(source); |
| if (matcher.find()) { |
| String className = matcher.group(1); |
| String path = ((packageName == null) ? "" : packageName + "/") + className + ".java"; |
| return URI.create("myfo:///" + path); |
| } else { |
| throw new Error("Could not extract the java class " |
| + "name from the provided source"); |
| } |
| } |
| |
| File createDir(String path) { |
| File dir = new File(path); |
| dir.mkdirs(); |
| return dir; |
| } |
| |
| JavaCompiler compiler; |
| StandardJavaFileManager fileManager; |
| |
| /** |
| * Map for recording which standard locations have been tested. |
| */ |
| EnumSet<StandardLocation> tested = EnumSet.noneOf(StandardLocation.class); |
| |
| /** |
| * Logging stream. Used directly with test and for getTask calls. |
| */ |
| final PrintWriter out = new PrintWriter(System.err, true); |
| |
| /** |
| * Count of errors so far. |
| */ |
| int errors; |
| |
| void error(String message) { |
| errors++; |
| out.println("Error: " + message); |
| } |
| } |