test/tools/javac/api/TestSearchPaths.java - toolchain/jdk/jdk9_langtools - Git at Google

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