/*
* 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);
}
}