Select Git revision
CodeCacheFullCountTest.java
Basic.java 11.55 KiB
/*
* Copyright (c) 2015, 2017, 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.
*/
import java.io.File;
import java.io.FileWriter;
import java.io.Reader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.SequenceInputStream;
import java.io.StringWriter;
import java.io.Writer;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.StandardLocation;
import javax.tools.ToolProvider;
import jdk.test.lib.util.FileUtils;
import jdk.testlibrary.JDKToolFinder;
import static java.lang.String.format;
import static java.util.Arrays.asList;
/*
* @test
* @bug 8064924
* @modules jdk.compiler
* @summary Basic test for URLStreamHandlerProvider
* @library /lib/testlibrary /test/lib
* @build jdk.test.lib.Platform
* jdk.test.lib.util.FileUtils
* jdk.testlibrary.JDKToolFinder
* @compile Basic.java Child.java
* @run main Basic
*/
public class Basic {
static final Path TEST_SRC = Paths.get(System.getProperty("test.src", "."));
static final Path TEST_CLASSES = Paths.get(System.getProperty("test.classes", "."));
public static void main(String[] args) throws Throwable {
unknownProtocol("foo", UNKNOWN);
unknownProtocol("bar", UNKNOWN);
viaProvider("baz", KNOWN);
viaProvider("bert", KNOWN);
viaProvider("ernie", UNKNOWN, "-Djava.security.manager");
viaProvider("curly", UNKNOWN, "-Djava.security.manager");
viaProvider("larry", KNOWN, "-Djava.security.manager",
"-Djava.security.policy=" + TEST_SRC + File.separator + "basic.policy");
viaProvider("moe", KNOWN, "-Djava.security.manager",
"-Djava.security.policy=" + TEST_SRC + File.separator + "basic.policy");
viaBadProvider("tom", SCE);
viaBadProvider("jerry", SCE);
}
static final Consumer<Result> KNOWN = r -> {
if (r.exitValue != 0 || !r.output.isEmpty())
throw new RuntimeException(r.output);
};
static final Consumer<Result> UNKNOWN = r -> {
if (r.exitValue == 0 ||
!r.output.contains("java.net.MalformedURLException: unknown protocol")) {
throw new RuntimeException("exitValue: "+ r.exitValue + ", output:[" +r.output +"]");
}
};
static final Consumer<Result> SCE = r -> {
if (r.exitValue == 0 ||
!r.output.contains("java.util.ServiceConfigurationError")) {
throw new RuntimeException("exitValue: "+ r.exitValue + ", output:[" +r.output +"]");
}
};
static void unknownProtocol(String protocol, Consumer<Result> resultChecker) {
System.out.println("\nTesting " + protocol);
Result r = java(Collections.emptyList(), asList(TEST_CLASSES),
"Child", protocol);
resultChecker.accept(r);
}
static void viaProvider(String protocol, Consumer<Result> resultChecker,
String... sysProps)
throws Exception
{
viaProviderWithTemplate(protocol, resultChecker,
TEST_SRC.resolve("provider.template"),
sysProps);
}
static void viaBadProvider(String protocol, Consumer<Result> resultChecker,
String... sysProps)
throws Exception
{
viaProviderWithTemplate(protocol, resultChecker,
TEST_SRC.resolve("bad.provider.template"),
sysProps);
}
static void viaProviderWithTemplate(String protocol,
Consumer<Result> resultChecker,
Path template, String... sysProps)
throws Exception
{
System.out.println("\nTesting " + protocol);
Path testRoot = Paths.get("URLStreamHandlerProvider-" + protocol);
if (Files.exists(testRoot))
FileUtils.deleteFileTreeWithRetry(testRoot);
Files.createDirectory(testRoot);
Path srcPath = Files.createDirectory(testRoot.resolve("src"));
Path srcClass = createProvider(protocol, template, srcPath);
Path build = Files.createDirectory(testRoot.resolve("build"));
javac(build, srcClass);
createServices(build, protocol);
Path testJar = testRoot.resolve("test.jar");
jar(testJar, build);
List<String> props = new ArrayList<>();
for (String p : sysProps)
props.add(p);
Result r = java(props, asList(testJar, TEST_CLASSES),
"Child", protocol);
resultChecker.accept(r);
}
static String platformPath(String p) { return p.replace("/", File.separator); }
static String binaryName(String name) { return name.replace(".", "/"); }
static final String SERVICE_IMPL_PREFIX = "net.java.openjdk.test";
static void createServices(Path dst, String protocol) throws IOException {
Path services = Files.createDirectories(dst.resolve("META-INF")
.resolve("services"));
final String implName = SERVICE_IMPL_PREFIX + "." + protocol + ".Provider";
Path s = services.resolve("java.net.spi.URLStreamHandlerProvider");
FileWriter fw = new FileWriter(s.toFile());
try {
fw.write(implName);
} finally {
fw.close();
}
}
static Path createProvider(String protocol, Path srcTemplate, Path dst)
throws IOException
{
String pkg = SERVICE_IMPL_PREFIX + "." + protocol;
Path classDst = dst.resolve(platformPath(binaryName(pkg)));
Files.createDirectories(classDst);
Path classPath = classDst.resolve("Provider.java");
List<String> lines = Files.lines(srcTemplate)
.map(s -> s.replaceAll("\\$package", pkg))
.map(s -> s.replaceAll("\\$protocol", protocol))
.collect(Collectors.toList());
Files.write(classPath, lines);
return classPath;
}
static void jar(Path jarName, Path jarRoot) { String jar = getJDKTool("jar");
ProcessBuilder p = new ProcessBuilder(jar, "cf", jarName.toString(),
"-C", jarRoot.toString(), ".");
quickFail(run(p));
}
static void javac(Path dest, Path... sourceFiles) throws IOException {
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
try (StandardJavaFileManager fileManager =
compiler.getStandardFileManager(null, null, null)) {
List<File> files = Stream.of(sourceFiles)
.map(p -> p.toFile())
.collect(Collectors.toList());
List<File> dests = Stream.of(dest)
.map(p -> p.toFile())
.collect(Collectors.toList()); Iterable<? extends JavaFileObject> compilationUnits =
fileManager.getJavaFileObjectsFromFiles(files);
fileManager.setLocation(StandardLocation.CLASS_OUTPUT, dests);
JavaCompiler.CompilationTask task =
compiler.getTask(null, fileManager, null, null, null, compilationUnits);
boolean passed = task.call();
if (!passed)
throw new RuntimeException("Error compiling " + files);
}
}
static void quickFail(Result r) {
if (r.exitValue != 0)
throw new RuntimeException(r.output);
}
static Result java(List<String> sysProps, Collection<Path> classpath,
String classname, String arg) {
String java = getJDKTool("java");
List<String> commands = new ArrayList<>();
commands.add(java);
for (String prop : sysProps)
commands.add(prop);
String cp = classpath.stream()
.map(Path::toString)
.collect(Collectors.joining(File.pathSeparator));
commands.add("-cp");
commands.add(cp);
commands.add(classname);
commands.add(arg);
return run(new ProcessBuilder(commands));
}
static Result run(ProcessBuilder pb) {
Process p = null;
System.out.println("running: " + pb.command());
try {
p = pb.start();
} catch (IOException e) {
throw new RuntimeException(
format("Couldn't start process '%s'", pb.command()), e);
}
String output;
try {
output = toString(p.getInputStream(), p.getErrorStream());
} catch (IOException e) {
throw new RuntimeException(
format("Couldn't read process output '%s'", pb.command()), e);
}
try {
p.waitFor();
} catch (InterruptedException e) {
throw new RuntimeException(
format("Process hasn't finished '%s'", pb.command()), e);
}
return new Result(p.exitValue(), output);
}
static final String DEFAULT_IMAGE_BIN = System.getProperty("java.home")
+ File.separator + "bin" + File.separator;
static String getJDKTool(String name) {
try {
return JDKToolFinder.getJDKTool(name); } catch (Exception x) {
return DEFAULT_IMAGE_BIN + name;
}
}
static String toString(InputStream... src) throws IOException {
StringWriter dst = new StringWriter();
Reader concatenated =
new InputStreamReader(
new SequenceInputStream(
Collections.enumeration(asList(src))));
copy(concatenated, dst);
return dst.toString();
}
static void copy(Reader src, Writer dst) throws IOException {
int len;
char[] buf = new char[1024];
try {
while ((len = src.read(buf)) != -1)
dst.write(buf, 0, len);
} finally {
try {
src.close();
} catch (IOException ignored1) {
} finally {
try {
dst.close();
} catch (IOException ignored2) {
}
}
}
}
static class Result {
final int exitValue;
final String output;
private Result(int exitValue, String output) {
this.exitValue = exitValue;
this.output = output;
}
}
}