196 lines
8.2 KiB
Java
196 lines
8.2 KiB
Java
/*
|
|
* 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 8067138
|
|
* @summary Verify that compiling against the exploded JDK image works, and that Locations close
|
|
* the directory streams properly when working with exploded JDK image.
|
|
* @library /tools/lib
|
|
* @modules jdk.compiler/com.sun.tools.javac.api
|
|
* jdk.compiler/com.sun.tools.javac.code
|
|
* jdk.compiler/com.sun.tools.javac.main
|
|
* @build toolbox.ToolBox ExplodedImage
|
|
* @run main/othervm ExplodedImage modules/* testDirectoryStreamClosed
|
|
* @run main/othervm ExplodedImage modules/* testCanCompileAgainstExplodedImage
|
|
*/
|
|
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.net.URI;
|
|
import java.nio.file.DirectoryStream;
|
|
import java.nio.file.FileSystems;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.util.Arrays;
|
|
import java.util.EnumSet;
|
|
import java.util.List;
|
|
import javax.lang.model.element.TypeElement;
|
|
import javax.tools.Diagnostic;
|
|
import javax.tools.DiagnosticListener;
|
|
import javax.tools.JavaCompiler;
|
|
import javax.tools.JavaFileObject;
|
|
import javax.tools.StandardJavaFileManager;
|
|
import javax.tools.StandardLocation;
|
|
import javax.tools.ToolProvider;
|
|
|
|
import com.sun.source.util.JavacTask;
|
|
import com.sun.tools.javac.code.Symbol.ClassSymbol;
|
|
|
|
import toolbox.ToolBox;
|
|
|
|
public class ExplodedImage {
|
|
public static void main(String... args) throws IOException {
|
|
new ExplodedImage().run(args);
|
|
}
|
|
|
|
void run(String... args) throws IOException {
|
|
switch (args[0]) {
|
|
case "testDirectoryStreamClosed":
|
|
testDirectoryStreamClosed(args[1]);
|
|
break;
|
|
case "testCanCompileAgainstExplodedImage":
|
|
testCanCompileAgainstExplodedImage(args[1]);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void testDirectoryStreamClosed(String loc) throws IOException {
|
|
System.err.println("testDirectoryStreamClosed(" + loc + ")");
|
|
Path javaHome = prepareJavaHome();
|
|
Path targetPath = javaHome.resolve(loc.replace("*", "/java.base").replace("/", sep));
|
|
Path testClass = targetPath.resolve(("java/lang/" + TEST_FILE).replace("/", sep));
|
|
Files.createDirectories(testClass.getParent());
|
|
Files.createFile(testClass);
|
|
System.setProperty("java.home", javaHome.toString());
|
|
|
|
for (int i = 0; i < REPEATS; i++) {
|
|
try (StandardJavaFileManager fm = javaCompiler.getStandardFileManager(null, null, null)) {
|
|
Iterable<JavaFileObject> javaLangContent =
|
|
fm.list(StandardLocation.PLATFORM_CLASS_PATH,
|
|
"java.lang",
|
|
EnumSet.allOf(JavaFileObject.Kind.class),
|
|
false);
|
|
boolean found = false;
|
|
|
|
for (JavaFileObject fo : javaLangContent) {
|
|
if (!fo.getName().endsWith(TEST_FILE)) {
|
|
throw new IllegalStateException("Wrong file: " + fo);
|
|
}
|
|
found = true;
|
|
}
|
|
|
|
if (!found)
|
|
throw new IllegalStateException("Could not find the expected file!");
|
|
}
|
|
}
|
|
|
|
System.err.println("finished.");
|
|
}
|
|
//where:
|
|
static final String TEST_FILE = "ExplodedImageTestFile.class";
|
|
static final int REPEATS = 16 * 1024 + 1;
|
|
|
|
void testCanCompileAgainstExplodedImage(String loc) throws IOException {
|
|
System.err.println("testCanCompileAgainstExplodedImage(" + loc + ")");
|
|
Path javaHome = prepareJavaHome();
|
|
Path targetPath = javaHome.resolve(loc.replace("*", "/java.base").replace("/", sep));
|
|
try (StandardJavaFileManager fm = javaCompiler.getStandardFileManager(null, null, null)) {
|
|
for (String pack : REQUIRED_PACKAGES) {
|
|
Iterable<JavaFileObject> content = fm.list(StandardLocation.PLATFORM_CLASS_PATH,
|
|
pack,
|
|
EnumSet.allOf(JavaFileObject.Kind.class),
|
|
false);
|
|
|
|
for (JavaFileObject jfo : content) {
|
|
String name = jfo.getName();
|
|
int lastSlash = name.lastIndexOf('/');
|
|
name = lastSlash >= 0 ? name.substring(lastSlash + 1) : name;
|
|
Path target = targetPath.resolve(pack.replace(".", sep) + sep + name);
|
|
Files.createDirectories(target.getParent());
|
|
try (InputStream in = jfo.openInputStream()) {
|
|
Files.copy(in, target);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
System.setProperty("java.home", javaHome.toString());
|
|
|
|
try (StandardJavaFileManager fm = javaCompiler.getStandardFileManager(null, null, null)) {
|
|
DiagnosticListener<JavaFileObject> noErrors = d -> {
|
|
if (d.getKind() == Diagnostic.Kind.ERROR)
|
|
throw new IllegalStateException("Unexpected error: " + d);
|
|
};
|
|
ToolBox.JavaSource inputFile =
|
|
new ToolBox.JavaSource("import java.util.List; class Test { List l; }");
|
|
List<JavaFileObject> inputFiles = Arrays.asList(inputFile);
|
|
boolean result =
|
|
javaCompiler.getTask(null, fm, noErrors, null, null, inputFiles).call();
|
|
if (!result) {
|
|
throw new IllegalStateException("Could not compile correctly!");
|
|
}
|
|
JavacTask task =
|
|
(JavacTask) javaCompiler.getTask(null, fm, noErrors, null, null, inputFiles);
|
|
task.parse();
|
|
TypeElement juList = task.getElements().getTypeElement("java.util.List");
|
|
if (juList == null)
|
|
throw new IllegalStateException("Cannot resolve java.util.List!");
|
|
URI listSource = ((ClassSymbol) juList).classfile.toUri();
|
|
if (!listSource.toString().startsWith(javaHome.toUri().toString()))
|
|
throw new IllegalStateException( "Did not load java.util.List from correct place, " +
|
|
"actual location: " + listSource.toString() +
|
|
"; expected prefix: " + javaHome.toUri());
|
|
}
|
|
|
|
System.err.println("finished.");
|
|
}
|
|
//where:
|
|
static final String[] REQUIRED_PACKAGES = {"java.lang", "java.io", "java.util"};
|
|
|
|
Path prepareJavaHome() throws IOException {
|
|
Path javaHome = new File("javahome").getAbsoluteFile().toPath();
|
|
delete(javaHome);
|
|
Files.createDirectory(javaHome);
|
|
return javaHome;
|
|
}
|
|
|
|
String sep = FileSystems.getDefault().getSeparator();
|
|
JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
|
|
String originalJavaHome = System.getProperty("java.home");
|
|
|
|
void delete(Path p) throws IOException {
|
|
if (!Files.exists(p))
|
|
return ;
|
|
if (Files.isDirectory(p)) {
|
|
try (DirectoryStream<Path> dir = Files.newDirectoryStream(p)) {
|
|
for (Path child : dir) {
|
|
delete(child);
|
|
}
|
|
}
|
|
}
|
|
Files.delete(p);
|
|
}
|
|
}
|