912 lines
30 KiB
Java
912 lines
30 KiB
Java
|
/*
|
||
|
|
* Copyright (c) 2013, 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.BufferedReader;
|
||
|
|
import java.io.File;
|
||
|
|
import java.io.FileNotFoundException;
|
||
|
|
import java.io.FileWriter;
|
||
|
|
import java.io.IOException;
|
||
|
|
import java.io.InputStreamReader;
|
||
|
|
import java.io.PrintWriter;
|
||
|
|
import java.io.StringWriter;
|
||
|
|
import java.net.URI;
|
||
|
|
import java.nio.charset.Charset;
|
||
|
|
import java.nio.file.Files;
|
||
|
|
import java.nio.file.Path;
|
||
|
|
import java.nio.file.Paths;
|
||
|
|
import java.nio.file.StandardOpenOption;
|
||
|
|
import java.util.ArrayList;
|
||
|
|
import java.util.Arrays;
|
||
|
|
import java.util.Collection;
|
||
|
|
import java.util.EnumSet;
|
||
|
|
import java.util.List;
|
||
|
|
import java.util.Map;
|
||
|
|
import java.util.Set;
|
||
|
|
import java.util.regex.Matcher;
|
||
|
|
import java.util.regex.Pattern;
|
||
|
|
|
||
|
|
import javax.tools.JavaCompiler;
|
||
|
|
import javax.tools.JavaFileObject;
|
||
|
|
import javax.tools.SimpleJavaFileObject;
|
||
|
|
import javax.tools.ToolProvider;
|
||
|
|
|
||
|
|
import com.sun.source.util.JavacTask;
|
||
|
|
import com.sun.tools.javac.api.JavacTaskImpl;
|
||
|
|
|
||
|
|
import sun.tools.jar.Main;
|
||
|
|
|
||
|
|
import static java.nio.file.StandardCopyOption.*;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Toolbox for jtreg tests.
|
||
|
|
*/
|
||
|
|
|
||
|
|
public class ToolBox {
|
||
|
|
|
||
|
|
public static final String lineSeparator = System.getProperty("line.separator");
|
||
|
|
public static final String jdkUnderTest = System.getProperty("test.jdk");
|
||
|
|
public static final String testVMOpts = System.getProperty("test.tool.vm.opts");
|
||
|
|
public static final String javaBinary = Paths.get(jdkUnderTest, "bin", "java").toString();
|
||
|
|
//why this one private. Because the function which provide also the test options should be used
|
||
|
|
private static final String javacBinary = Paths.get(jdkUnderTest, "bin", "javac").toString();
|
||
|
|
|
||
|
|
private static final Charset defaultCharset = Charset.defaultCharset();
|
||
|
|
|
||
|
|
static final JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The expected result of command-like method execution.
|
||
|
|
*/
|
||
|
|
public enum Expect {SUCCESS, FAIL}
|
||
|
|
|
||
|
|
enum AcceptedParams {
|
||
|
|
EXPECT,
|
||
|
|
SOURCES,
|
||
|
|
OPTIONS,
|
||
|
|
STD_OUTPUT,
|
||
|
|
ERR_OUTPUT,
|
||
|
|
EXTRA_ENV,
|
||
|
|
}
|
||
|
|
|
||
|
|
enum OutputKind {STD, ERR}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Helper class to abstract the processing of command's output.
|
||
|
|
*/
|
||
|
|
static abstract class WriterHelper {
|
||
|
|
OutputKind kind;
|
||
|
|
public abstract void pipeOutput(ProcessBuilder pb);
|
||
|
|
public abstract void readFromStream(Process p) throws IOException;
|
||
|
|
public abstract void addAll(Collection<? extends String> c) throws IOException;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Helper class for redirecting command's output to a file.
|
||
|
|
*/
|
||
|
|
static class FileWriterHelper extends WriterHelper {
|
||
|
|
File file;
|
||
|
|
|
||
|
|
FileWriterHelper(File file, OutputKind kind) {
|
||
|
|
this.file = file;
|
||
|
|
this.kind = kind;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void pipeOutput(ProcessBuilder pb) {
|
||
|
|
if (file != null) {
|
||
|
|
switch (kind) {
|
||
|
|
case STD:
|
||
|
|
pb.redirectInput(file);
|
||
|
|
break;
|
||
|
|
case ERR:
|
||
|
|
pb.redirectError(file);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void readFromStream(Process p) throws IOException {}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void addAll(Collection<? extends String> c) throws IOException {
|
||
|
|
if (file.exists())
|
||
|
|
Files.write(file.toPath(), c, defaultCharset,
|
||
|
|
StandardOpenOption.WRITE, StandardOpenOption.APPEND);
|
||
|
|
else
|
||
|
|
Files.write(file.toPath(), c, defaultCharset);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Helper class for redirecting command's output to a String list.
|
||
|
|
*/
|
||
|
|
static class ListWriterHelper extends WriterHelper {
|
||
|
|
List<String> list;
|
||
|
|
|
||
|
|
public ListWriterHelper(List<String> list, OutputKind kind) {
|
||
|
|
this.kind = kind;
|
||
|
|
this.list = list;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void pipeOutput(ProcessBuilder pb) {}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void readFromStream(Process p) throws IOException {
|
||
|
|
BufferedReader br = null;
|
||
|
|
switch (kind) {
|
||
|
|
case STD:
|
||
|
|
br = new BufferedReader(new InputStreamReader(p.getInputStream()));
|
||
|
|
break;
|
||
|
|
case ERR:
|
||
|
|
br = new BufferedReader(new InputStreamReader(p.getErrorStream()));
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
String line;
|
||
|
|
while ((line = br.readLine()) != null) {
|
||
|
|
list.add(line);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public void addAll(Collection<? extends String> c) {
|
||
|
|
list.addAll(c);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Simple factory class for creating a WriterHelper instance.
|
||
|
|
*/
|
||
|
|
static class WriterHelperFactory {
|
||
|
|
static WriterHelper make(File file, OutputKind kind) {
|
||
|
|
return new FileWriterHelper(file, kind);
|
||
|
|
}
|
||
|
|
|
||
|
|
static WriterHelper make(List<String> list, OutputKind kind) {
|
||
|
|
return new ListWriterHelper(list, kind);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A generic class for holding command's arguments.
|
||
|
|
*/
|
||
|
|
public static abstract class GenericArgs <T extends GenericArgs> {
|
||
|
|
protected static List<Set<AcceptedParams>> minAcceptedParams;
|
||
|
|
|
||
|
|
protected Set<AcceptedParams> currentParams =
|
||
|
|
EnumSet.<AcceptedParams>noneOf(AcceptedParams.class);
|
||
|
|
|
||
|
|
protected Expect whatToExpect;
|
||
|
|
protected WriterHelper stdOutput;
|
||
|
|
protected WriterHelper errOutput;
|
||
|
|
protected List<String> options;
|
||
|
|
protected String[] optionsArr;
|
||
|
|
|
||
|
|
protected GenericArgs() {
|
||
|
|
set(Expect.SUCCESS);
|
||
|
|
}
|
||
|
|
|
||
|
|
public T set(Expect whatToExpt) {
|
||
|
|
currentParams.add(AcceptedParams.EXPECT);
|
||
|
|
this.whatToExpect = whatToExpt;
|
||
|
|
return (T)this;
|
||
|
|
}
|
||
|
|
|
||
|
|
public T setStdOutput(List<String> stdOutput) {
|
||
|
|
currentParams.add(AcceptedParams.STD_OUTPUT);
|
||
|
|
this.stdOutput = WriterHelperFactory.make(stdOutput, OutputKind.STD);
|
||
|
|
return (T)this;
|
||
|
|
}
|
||
|
|
|
||
|
|
public T setStdOutput(File output) {
|
||
|
|
currentParams.add(AcceptedParams.STD_OUTPUT);
|
||
|
|
this.stdOutput = WriterHelperFactory.make(output, OutputKind.STD);
|
||
|
|
return (T)this;
|
||
|
|
}
|
||
|
|
|
||
|
|
public T setErrOutput(List<String> errOutput) {
|
||
|
|
currentParams.add(AcceptedParams.ERR_OUTPUT);
|
||
|
|
this.errOutput = WriterHelperFactory.make(errOutput, OutputKind.ERR);
|
||
|
|
return (T)this;
|
||
|
|
}
|
||
|
|
|
||
|
|
public T setErrOutput(File errOutput) {
|
||
|
|
currentParams.add(AcceptedParams.ERR_OUTPUT);
|
||
|
|
this.errOutput = WriterHelperFactory.make(errOutput, OutputKind.ERR);
|
||
|
|
return (T)this;
|
||
|
|
}
|
||
|
|
|
||
|
|
public T setAllArgs(String... args) {
|
||
|
|
currentParams.add(AcceptedParams.OPTIONS);
|
||
|
|
this.optionsArr = args;
|
||
|
|
return (T)this;
|
||
|
|
}
|
||
|
|
|
||
|
|
public T setOptions(List<String> options) {
|
||
|
|
currentParams.add(AcceptedParams.OPTIONS);
|
||
|
|
this.options = options;
|
||
|
|
return (T)this;
|
||
|
|
}
|
||
|
|
|
||
|
|
public T setOptions(String... options) {
|
||
|
|
currentParams.add(AcceptedParams.OPTIONS);
|
||
|
|
this.options = Arrays.asList(options);
|
||
|
|
return (T)this;
|
||
|
|
}
|
||
|
|
|
||
|
|
public boolean hasMinParams() {
|
||
|
|
for (Set<AcceptedParams> minSet : minAcceptedParams) {
|
||
|
|
if (currentParams.containsAll(minSet)) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A more specific class for holding javac-like command's arguments.
|
||
|
|
*/
|
||
|
|
public static class JavaToolArgs extends GenericArgs<JavaToolArgs> {
|
||
|
|
|
||
|
|
static {
|
||
|
|
minAcceptedParams = new ArrayList<>();
|
||
|
|
minAcceptedParams.add(EnumSet.<AcceptedParams>of(
|
||
|
|
AcceptedParams.EXPECT, AcceptedParams.OPTIONS));
|
||
|
|
minAcceptedParams.add(EnumSet.<AcceptedParams>of(
|
||
|
|
AcceptedParams.EXPECT, AcceptedParams.SOURCES));
|
||
|
|
}
|
||
|
|
|
||
|
|
protected List<? extends JavaFileObject> sources;
|
||
|
|
|
||
|
|
public JavaToolArgs() {
|
||
|
|
super();
|
||
|
|
}
|
||
|
|
|
||
|
|
public JavaToolArgs(Expect whatToExpt) {
|
||
|
|
super.set(whatToExpt);
|
||
|
|
}
|
||
|
|
|
||
|
|
public JavaToolArgs setSources(List<? extends JavaFileObject> sources) {
|
||
|
|
currentParams.add(AcceptedParams.SOURCES);
|
||
|
|
this.sources = sources;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
public JavaToolArgs setSources(JavaSource... sources) {
|
||
|
|
return setSources(Arrays.asList(sources));
|
||
|
|
}
|
||
|
|
|
||
|
|
public JavaToolArgs setSources(String... sources) {
|
||
|
|
List<JavaSource> javaSrcs = new ArrayList<>();
|
||
|
|
for (String source : sources) {
|
||
|
|
javaSrcs.add(new JavaSource(source));
|
||
|
|
}
|
||
|
|
return setSources(javaSrcs);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A more specific class for holding any command's arguments.
|
||
|
|
*/
|
||
|
|
public static class AnyToolArgs extends GenericArgs<AnyToolArgs> {
|
||
|
|
|
||
|
|
static {
|
||
|
|
minAcceptedParams = new ArrayList<>();
|
||
|
|
minAcceptedParams.add(EnumSet.<AcceptedParams>of(
|
||
|
|
AcceptedParams.EXPECT, AcceptedParams.OPTIONS));
|
||
|
|
}
|
||
|
|
|
||
|
|
Map<String, String> extraEnv;
|
||
|
|
|
||
|
|
public AnyToolArgs() {
|
||
|
|
super();
|
||
|
|
}
|
||
|
|
|
||
|
|
public AnyToolArgs(Expect whatToExpt) {
|
||
|
|
set(whatToExpt);
|
||
|
|
}
|
||
|
|
|
||
|
|
public AnyToolArgs set(Map<String, String> extraEnv) {
|
||
|
|
currentParams.add(AcceptedParams.EXTRA_ENV);
|
||
|
|
this.extraEnv = extraEnv;
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Custom exception for bad command execution.
|
||
|
|
*/
|
||
|
|
public static class CommandExecutionException extends Exception {
|
||
|
|
CommandExecutionException(List<String> command, Expect whatToExpt) {
|
||
|
|
super(createMessage(command, whatToExpt));
|
||
|
|
}
|
||
|
|
|
||
|
|
CommandExecutionException(Expect whatToExpt, String... command) {
|
||
|
|
this(Arrays.asList(command), whatToExpt);
|
||
|
|
}
|
||
|
|
|
||
|
|
private static String createMessage(List<String> command, Expect whatToExpt) {
|
||
|
|
StringBuilder sb = new StringBuilder().append("Command : ");
|
||
|
|
sb.append(command.toString()).append(lineSeparator);
|
||
|
|
switch (whatToExpt) {
|
||
|
|
case SUCCESS:
|
||
|
|
sb.append(" has unexpectedly failed");
|
||
|
|
break;
|
||
|
|
case FAIL:
|
||
|
|
sb.append(" has been unexpectedly successful");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
return sb.toString();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Custom exception for not equal resources.
|
||
|
|
*/
|
||
|
|
public static class ResourcesNotEqualException extends Exception {
|
||
|
|
public ResourcesNotEqualException() {
|
||
|
|
super("The resources provided for comparison are different");
|
||
|
|
}
|
||
|
|
|
||
|
|
public ResourcesNotEqualException(Path path1, Path path2) {
|
||
|
|
super(createMessage(path1, path2));
|
||
|
|
}
|
||
|
|
|
||
|
|
private static String createMessage(Path path1, Path path2) {
|
||
|
|
return new StringBuilder()
|
||
|
|
.append("The resources provided for comparison in paths \n")
|
||
|
|
.append(path1.toString()).append(" and \n")
|
||
|
|
.append(path2.toString()).append("are different").toString();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Method to get the a path to the javac command available at the jdk being
|
||
|
|
* tested along with the test vm options.
|
||
|
|
* @return a String[] with the two components mentioned.
|
||
|
|
*/
|
||
|
|
public static String[] getJavacBin() {
|
||
|
|
return new String[]{javacBinary, testVMOpts};
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A javac compiler caller method.
|
||
|
|
*/
|
||
|
|
public static int javac(JavaToolArgs params)
|
||
|
|
throws CommandExecutionException, IOException {
|
||
|
|
if (params.hasMinParams()) {
|
||
|
|
if (params.optionsArr != null) {
|
||
|
|
return genericJavaCMD(JavaCMD.JAVAC, params);
|
||
|
|
} else {
|
||
|
|
return genericJavaCMD(JavaCMD.JAVAC_API, params);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
throw new AssertionError("javac command has been invoked with less parameters than needed");
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A javap calling method.
|
||
|
|
*/
|
||
|
|
public static String javap(JavaToolArgs params)
|
||
|
|
throws CommandExecutionException, IOException {
|
||
|
|
if (params.hasMinParams()) {
|
||
|
|
List<String> list = new ArrayList<>();
|
||
|
|
params.setErrOutput(list);
|
||
|
|
genericJavaCMD(JavaCMD.JAVAP, params);
|
||
|
|
return listToString(list);
|
||
|
|
}
|
||
|
|
throw new AssertionError("javap command has been invoked with less parameters than needed");
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A javah calling method.
|
||
|
|
*/
|
||
|
|
public static int javah(JavaToolArgs params)
|
||
|
|
throws CommandExecutionException, IOException {
|
||
|
|
if (params.hasMinParams()) {
|
||
|
|
return genericJavaCMD(JavaCMD.JAVAH, params);
|
||
|
|
}
|
||
|
|
throw new AssertionError("javah command has been invoked with less parameters than needed");
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A enum class for langtools commands.
|
||
|
|
*/
|
||
|
|
enum JavaCMD {
|
||
|
|
JAVAC {
|
||
|
|
@Override
|
||
|
|
int run(JavaToolArgs params, PrintWriter pw) {
|
||
|
|
return com.sun.tools.javac.Main.compile(params.optionsArr, pw);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
JAVAC_API {
|
||
|
|
@Override
|
||
|
|
int run(JavaToolArgs params, PrintWriter pw) {
|
||
|
|
JavacTask ct = (JavacTask)comp.getTask(pw, null, null,
|
||
|
|
params.options, null, params.sources);
|
||
|
|
return ((JavacTaskImpl)ct).doCall().exitCode;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
String getName() {
|
||
|
|
return "javac";
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
List<String> getExceptionMsgContent(JavaToolArgs params) {
|
||
|
|
List<String> result = super.getExceptionMsgContent(params);
|
||
|
|
for (JavaFileObject source : params.sources) {
|
||
|
|
if (source instanceof JavaSource) {
|
||
|
|
result.add(((JavaSource)source).name);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
JAVAH {
|
||
|
|
@Override
|
||
|
|
int run(JavaToolArgs params, PrintWriter pw) {
|
||
|
|
return com.sun.tools.javah.Main.run(params.optionsArr, pw);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
JAVAP {
|
||
|
|
@Override
|
||
|
|
int run(JavaToolArgs params, PrintWriter pw) {
|
||
|
|
return com.sun.tools.javap.Main.run(params.optionsArr, pw);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
abstract int run(JavaToolArgs params, PrintWriter pw);
|
||
|
|
|
||
|
|
String getName() {
|
||
|
|
return this.name().toLowerCase();
|
||
|
|
}
|
||
|
|
|
||
|
|
List<String> getExceptionMsgContent(JavaToolArgs params) {
|
||
|
|
List<String> result = new ArrayList<>();
|
||
|
|
result.add(getName());
|
||
|
|
result.addAll(params.optionsArr != null ?
|
||
|
|
Arrays.asList(params.optionsArr) :
|
||
|
|
params.options);
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A helper method for executing langtools commands.
|
||
|
|
*/
|
||
|
|
private static int genericJavaCMD(
|
||
|
|
JavaCMD cmd,
|
||
|
|
JavaToolArgs params)
|
||
|
|
throws CommandExecutionException, IOException {
|
||
|
|
int rc = 0;
|
||
|
|
StringWriter sw = null;
|
||
|
|
try (PrintWriter pw = (params.errOutput == null) ?
|
||
|
|
null : new PrintWriter(sw = new StringWriter())) {
|
||
|
|
rc = cmd.run(params, pw);
|
||
|
|
}
|
||
|
|
String out = (sw == null) ? null : sw.toString();
|
||
|
|
|
||
|
|
if (params.errOutput != null && (out != null) && !out.isEmpty()) {
|
||
|
|
params.errOutput.addAll(splitLines(out));
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( (rc == 0 && params.whatToExpect == Expect.SUCCESS) ||
|
||
|
|
(rc != 0 && params.whatToExpect == Expect.FAIL) ) {
|
||
|
|
return rc;
|
||
|
|
}
|
||
|
|
|
||
|
|
throw new CommandExecutionException(cmd.getExceptionMsgContent(params),
|
||
|
|
params.whatToExpect);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A jar calling method.
|
||
|
|
*/
|
||
|
|
public static boolean jar(String... params) throws CommandExecutionException {
|
||
|
|
Main jarGenerator = new Main(System.out, System.err, "jar");
|
||
|
|
boolean result = jarGenerator.run(params);
|
||
|
|
if (!result) {
|
||
|
|
List<String> command = new ArrayList<>();
|
||
|
|
command.add("jar");
|
||
|
|
command.addAll(Arrays.asList(params));
|
||
|
|
throw new CommandExecutionException(command, Expect.SUCCESS);
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A general command calling method.
|
||
|
|
*/
|
||
|
|
public static int executeCommand(AnyToolArgs params)
|
||
|
|
throws CommandExecutionException, IOException, InterruptedException {
|
||
|
|
if (params.hasMinParams()) {
|
||
|
|
List<String> cmd = (params.options != null) ?
|
||
|
|
params.options :
|
||
|
|
Arrays.asList(params.optionsArr);
|
||
|
|
return executeCommand(cmd, params.extraEnv, params.stdOutput,
|
||
|
|
params.errOutput, params.whatToExpect);
|
||
|
|
}
|
||
|
|
throw new AssertionError("command has been invoked with less parameters than needed");
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A helper method for calling a general command.
|
||
|
|
*/
|
||
|
|
private static int executeCommand(
|
||
|
|
List<String> command,
|
||
|
|
Map<String, String> extraEnv,
|
||
|
|
WriterHelper stdOutput,
|
||
|
|
WriterHelper errOutput,
|
||
|
|
Expect whatToExpt)
|
||
|
|
throws IOException, InterruptedException, CommandExecutionException {
|
||
|
|
ProcessBuilder pb = new ProcessBuilder(command);
|
||
|
|
|
||
|
|
if (stdOutput != null) stdOutput.pipeOutput(pb);
|
||
|
|
if (errOutput != null) errOutput.pipeOutput(pb);
|
||
|
|
|
||
|
|
if (extraEnv != null) {
|
||
|
|
pb.environment().putAll(extraEnv);
|
||
|
|
}
|
||
|
|
|
||
|
|
Process p = pb.start();
|
||
|
|
|
||
|
|
if (stdOutput != null) stdOutput.readFromStream(p);
|
||
|
|
if (errOutput != null) errOutput.readFromStream(p);
|
||
|
|
|
||
|
|
int result = p.waitFor();
|
||
|
|
if ( (result == 0 && whatToExpt == Expect.SUCCESS) ||
|
||
|
|
(result != 0 && whatToExpt == Expect.FAIL) ) {
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
throw new CommandExecutionException(command, whatToExpt);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This set of methods can be used instead of diff when the only needed
|
||
|
|
* result is the equality or inequality of the two given resources.
|
||
|
|
*
|
||
|
|
* A resource can be a file or a String list.
|
||
|
|
*/
|
||
|
|
public static void compareLines(Path aPath, Path otherPath, String encoding)
|
||
|
|
throws FileNotFoundException, IOException, ResourcesNotEqualException {
|
||
|
|
compareLines(aPath, otherPath, encoding, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static void compareLines(
|
||
|
|
Path aPath, Path otherPath, String encoding, boolean trim)
|
||
|
|
throws FileNotFoundException, IOException, ResourcesNotEqualException {
|
||
|
|
Charset charset = encoding != null ?
|
||
|
|
Charset.forName(encoding) :
|
||
|
|
defaultCharset;
|
||
|
|
List<String> list1 = Files.readAllLines(aPath, charset);
|
||
|
|
List<String> list2 = Files.readAllLines(otherPath, charset);
|
||
|
|
compareLines(list1, list2, trim);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static void compareLines(Path path, List<String> strings, String encoding)
|
||
|
|
throws FileNotFoundException, IOException, ResourcesNotEqualException {
|
||
|
|
compareLines(path, strings, encoding, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static void compareLines(Path path, List<String> strings,
|
||
|
|
String encoding, boolean trim)
|
||
|
|
throws FileNotFoundException, IOException, ResourcesNotEqualException {
|
||
|
|
Charset charset = encoding != null ?
|
||
|
|
Charset.forName(encoding) :
|
||
|
|
defaultCharset;
|
||
|
|
List<String> list = Files.readAllLines(path, charset);
|
||
|
|
compareLines(list, strings, trim);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static void compareLines(List<String> list1, List<String> list2)
|
||
|
|
throws ResourcesNotEqualException {
|
||
|
|
compareLines(list1, list2, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static void compareLines(List<String> list1,
|
||
|
|
List<String> list2, boolean trim) throws ResourcesNotEqualException {
|
||
|
|
if ((list1 == list2) || (list1 == null && list2 == null)) return;
|
||
|
|
if (list1.size() != list2.size())
|
||
|
|
throw new ResourcesNotEqualException();
|
||
|
|
int i = 0;
|
||
|
|
int j = 0;
|
||
|
|
while (i < list1.size() &&
|
||
|
|
j < list2.size() &&
|
||
|
|
equals(list1.get(i), list2.get(j), trim)) {
|
||
|
|
i++; j++;
|
||
|
|
}
|
||
|
|
if (!(i == list1.size() && j == list2.size()))
|
||
|
|
throw new ResourcesNotEqualException();
|
||
|
|
}
|
||
|
|
|
||
|
|
private static boolean equals(String s1, String s2, boolean trim) {
|
||
|
|
return (trim ? s1.trim().equals(s2.trim()) : s1.equals(s2));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A set of simple grep-like methods, looks for regExpr in text.
|
||
|
|
* The content of text is split using the new line character as a pattern
|
||
|
|
* and later the regExpr is seek in every split line. If a match is found,
|
||
|
|
* the whole line is added to the result.
|
||
|
|
*/
|
||
|
|
public static List<String> grep(String regExpr, String text) {
|
||
|
|
return grep(regExpr, splitLines(text));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static List<String> grep(String regExpr, List<String> text) {
|
||
|
|
List<String> result = new ArrayList<>();
|
||
|
|
Pattern pattern = Pattern.compile(regExpr);
|
||
|
|
for (String s : text) {
|
||
|
|
if (pattern.matcher(s).find()) {
|
||
|
|
result.add(s);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
public static List<String> grep(String regExpr, File f)
|
||
|
|
throws IOException {
|
||
|
|
List<String> lines = Files.readAllLines(f.toPath(), defaultCharset);
|
||
|
|
return grep(regExpr, lines);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A touch-like method.
|
||
|
|
*/
|
||
|
|
public static boolean touch(String fileName) {
|
||
|
|
File file = new File(fileName);
|
||
|
|
return touch(file);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static boolean touch(File file) {
|
||
|
|
if (file.exists()) {
|
||
|
|
file.setLastModified(System.currentTimeMillis());
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
public static void createJavaFile(File outFile) throws IOException {
|
||
|
|
createJavaFile(outFile, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A method for creating a valid but very simple java file.
|
||
|
|
*/
|
||
|
|
public static void createJavaFile(File outFile, File superClass)
|
||
|
|
throws IOException {
|
||
|
|
String srcStr = "public class " + getSimpleName(outFile) + " ";
|
||
|
|
if (superClass != null) {
|
||
|
|
srcStr = srcStr.concat("extends " + getSimpleName(superClass) + " ");
|
||
|
|
}
|
||
|
|
srcStr = srcStr.concat("{}");
|
||
|
|
try (PrintWriter ps = new PrintWriter(new FileWriter(outFile))) {
|
||
|
|
ps.println(srcStr);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates a java file name given its source.
|
||
|
|
* The file is created in the working directory, creating a directory
|
||
|
|
* tree if there is a package declaration.
|
||
|
|
*/
|
||
|
|
public static void createJavaFileFromSource(String source) throws IOException {
|
||
|
|
createJavaFileFromSource(null, source);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Creates a java file name given its source.
|
||
|
|
* The file is created in the working directory, creating a directory
|
||
|
|
* tree if there is a package declaration or the argument initialPath
|
||
|
|
* has a valid path.
|
||
|
|
*
|
||
|
|
* e.i. if initialPath is foo/ and the source is:
|
||
|
|
* package bar;
|
||
|
|
*
|
||
|
|
* public class bazz {}
|
||
|
|
*
|
||
|
|
* this method will create the file foo/bar/bazz.java in the working
|
||
|
|
* directory.
|
||
|
|
*/
|
||
|
|
public static void createJavaFileFromSource(Path initialPath,
|
||
|
|
String source) throws IOException {
|
||
|
|
String fileName = getJavaFileNameFromSource(source);
|
||
|
|
String dirTree = getDirTreeFromSource(source);
|
||
|
|
Path path = (dirTree != null) ?
|
||
|
|
Paths.get(dirTree, fileName) :
|
||
|
|
Paths.get(fileName);
|
||
|
|
path = (initialPath != null) ?
|
||
|
|
initialPath.resolve(path):
|
||
|
|
path;
|
||
|
|
writeFile(path, source);
|
||
|
|
}
|
||
|
|
|
||
|
|
static Pattern publicClassPattern =
|
||
|
|
Pattern.compile("public\\s+(?:class|enum|interface){1}\\s+(\\w+)");
|
||
|
|
static Pattern packageClassPattern =
|
||
|
|
Pattern.compile("(?:class|enum|interface){1}\\s+(\\w+)");
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Extracts the java file name from the class declaration.
|
||
|
|
* This method is intended for simple files and uses regular expressions,
|
||
|
|
* so comments matching the pattern can make the method fail.
|
||
|
|
*/
|
||
|
|
private static String getJavaFileNameFromSource(String source) {
|
||
|
|
String className = null;
|
||
|
|
Matcher matcher = publicClassPattern.matcher(source);
|
||
|
|
if (matcher.find()) {
|
||
|
|
className = matcher.group(1) + ".java";
|
||
|
|
} else {
|
||
|
|
matcher = packageClassPattern.matcher(source);
|
||
|
|
if (matcher.find()) {
|
||
|
|
className = matcher.group(1) + ".java";
|
||
|
|
} else {
|
||
|
|
throw new AssertionError("Could not extract the java class " +
|
||
|
|
"name from the provided source");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return className;
|
||
|
|
}
|
||
|
|
|
||
|
|
static Pattern packagePattern =
|
||
|
|
Pattern.compile("package\\s+(((?:\\w+\\.)*)(?:\\w+))");
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Extracts the path from the package declaration if present.
|
||
|
|
* This method is intended for simple files and uses regular expressions,
|
||
|
|
* so comments matching the pattern can make the method fail.
|
||
|
|
*/
|
||
|
|
private static String getDirTreeFromSource(String source) {
|
||
|
|
Matcher matcher = packagePattern.matcher(source);
|
||
|
|
return matcher.find() ?
|
||
|
|
matcher.group(1).replace(".", File.separator) :
|
||
|
|
null;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A method for creating a jar's manifest file with supplied data.
|
||
|
|
*/
|
||
|
|
public static void mkManifestWithClassPath(String mainClass,
|
||
|
|
String... classes) throws IOException {
|
||
|
|
List <String> lines = new ArrayList<>();
|
||
|
|
|
||
|
|
StringBuilder sb = new StringBuilder("Class-Path: ".length() +
|
||
|
|
classes[0].length()).append("Class-Path: ").append(classes[0]);
|
||
|
|
for (int i = 1; i < classes.length; i++) {
|
||
|
|
sb.append(" ").append(classes[i]);
|
||
|
|
}
|
||
|
|
lines.add(sb.toString());
|
||
|
|
if (mainClass != null) {
|
||
|
|
lines.add(new StringBuilder("Main-Class: ".length() +
|
||
|
|
mainClass.length())
|
||
|
|
.append("Main-Class: ")
|
||
|
|
.append(mainClass).toString());
|
||
|
|
}
|
||
|
|
Files.write(Paths.get("MANIFEST.MF"), lines, null);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A utility method to obtain the file name.
|
||
|
|
*/
|
||
|
|
static String getSimpleName(File inFile) {
|
||
|
|
return inFile.toPath().getFileName().toString();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A method to write to a file, the directory tree is created if needed.
|
||
|
|
*/
|
||
|
|
public static File writeFile(Path path, String body) throws IOException {
|
||
|
|
File result;
|
||
|
|
if (path.getParent() != null) {
|
||
|
|
Files.createDirectories(path.getParent());
|
||
|
|
}
|
||
|
|
try (FileWriter out = new FileWriter(result = path.toAbsolutePath().toFile())) {
|
||
|
|
out.write(body);
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
public static File writeFile(String path, String body) throws IOException {
|
||
|
|
return writeFile(Paths.get(path), body);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* A rm-like method, the file is deleted only if it exists.
|
||
|
|
*/
|
||
|
|
public static void rm(Path path) throws Exception {
|
||
|
|
Files.deleteIfExists(path);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static void rm(String filename) throws Exception {
|
||
|
|
rm(Paths.get(filename));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static void rm(File f) throws Exception {
|
||
|
|
rm(f.toPath());
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Copy source file to destination file.
|
||
|
|
*/
|
||
|
|
public static void copyFile(File destfile, File srcfile)
|
||
|
|
throws IOException {
|
||
|
|
copyFile(destfile.toPath(), srcfile.toPath());
|
||
|
|
}
|
||
|
|
|
||
|
|
public static void copyFile(Path destPath, Path srcPath)
|
||
|
|
throws IOException {
|
||
|
|
Files.createDirectories(destPath);
|
||
|
|
Files.copy(srcPath, destPath, REPLACE_EXISTING);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Splits a String using the System's line separator character as splitting point.
|
||
|
|
*/
|
||
|
|
public static List<String> splitLines(String lines) {
|
||
|
|
return Arrays.asList(lines.split(lineSeparator));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Converts a String list into one String by appending the System's line separator
|
||
|
|
* character after each component.
|
||
|
|
*/
|
||
|
|
private static String listToString(List<String> lines) {
|
||
|
|
StringBuilder sb = new StringBuilder();
|
||
|
|
for (String s : lines) {
|
||
|
|
sb.append(s).append(lineSeparator);
|
||
|
|
}
|
||
|
|
return sb.toString();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Class representing an in-memory java source file. It is able to extract
|
||
|
|
* the file name from simple source codes using regular expressions.
|
||
|
|
*/
|
||
|
|
public static class JavaSource extends SimpleJavaFileObject {
|
||
|
|
String source;
|
||
|
|
String name;
|
||
|
|
|
||
|
|
public JavaSource(String className, String source) {
|
||
|
|
super(URI.create(className),
|
||
|
|
JavaFileObject.Kind.SOURCE);
|
||
|
|
this.name = className;
|
||
|
|
this.source = source;
|
||
|
|
}
|
||
|
|
|
||
|
|
public JavaSource(String source) {
|
||
|
|
super(URI.create(getJavaFileNameFromSource(source)),
|
||
|
|
JavaFileObject.Kind.SOURCE);
|
||
|
|
this.name = getJavaFileNameFromSource(source);
|
||
|
|
this.source = source;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public CharSequence getCharContent(boolean ignoreEncodingErrors) {
|
||
|
|
return source;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|