private static final class LineForwarder extends StreamPumper.LinePump {

private final PrintStream ps;

private final String prefix;

LineForwarder(String prefix, PrintStream os) {

this.ps = os;

this.prefix = prefix;

}

@Override

protected void processLine(String line) {

ps.println("[" + prefix + "] " + line);

}

}

private ProcessTools() {

}

/**

public static Process startProcess(String name,

ProcessBuilder processBuilder)

throws IOException {

return startProcess(name, processBuilder, (Consumer<String>) null);

}

/**

@SuppressWarnings("overloads")

public static Process startProcess(String name,

ProcessBuilder processBuilder,

Consumer<String> consumer)

throws IOException {

try {

return startProcess(name, processBuilder, consumer, null, -1, TimeUnit.NANOSECONDS);

} catch (InterruptedException | TimeoutException | CancellationException e) {

// will never happen

throw new RuntimeException(e);

}

}

/**

public static Process startProcess(String name,

ProcessBuilder processBuilder,

final Predicate<String> linePredicate,

long timeout,

TimeUnit unit)

throws IOException, InterruptedException, TimeoutException {

return startProcess(name, processBuilder, null, linePredicate, timeout, unit);

}

/*

private static class BufferOutputStream extends ByteArrayOutputStream {

private int current = 0;

final private Process p;

private Future<Void> task;

public BufferOutputStream(Process p) {

this.p = p;

}

synchronized void setTask(Future<Void> task) {

this.task = task;

}

synchronized int readNext() {

if (current > count) {

throw new RuntimeException("Shouldn't ever happen. start: "

+ current + " count: " + count + " buffer: " + this);

}

while (current == count) {

if (!p.isAlive() && (task != null)) {

try {

task.get(10, TimeUnit.MILLISECONDS);

if (current == count) {

return -1;

}

} catch (TimeoutException e) {

// continue execution, so wait() give a chance to write

} catch (InterruptedException | ExecutionException e) {

return -1;

}

}

try {

wait(1);

} catch (InterruptedException ie) {

return -1;

}

}

return this.buf[current++];

}

}

private static class BufferInputStream extends InputStream {

private final BufferOutputStream buffer;

public BufferInputStream(Process p) {

buffer = new BufferOutputStream(p);

}

BufferOutputStream getOutputStream() {

return buffer;

}

@Override

public int read() throws IOException {

return buffer.readNext();

}

}

/**

public static Process startProcess(String name,

ProcessBuilder processBuilder,

final Consumer<String> lineConsumer,

final Predicate<String> linePredicate,

long timeout,

TimeUnit unit)

throws IOException, InterruptedException, TimeoutException {

System.out.println("[" + name + "]:" + String.join(" ", processBuilder.command()));

Process p = privilegedStart(processBuilder);

StreamPumper stdout = new StreamPumper(p.getInputStream());

StreamPumper stderr = new StreamPumper(p.getErrorStream());

stdout.addPump(new LineForwarder(name, System.out));

stderr.addPump(new LineForwarder(name, System.err));

BufferInputStream stdOut = new BufferInputStream(p);

BufferInputStream stdErr = new BufferInputStream(p);

stdout.addOutputStream(stdOut.getOutputStream());

stderr.addOutputStream(stdErr.getOutputStream());

if (lineConsumer != null) {

StreamPumper.LinePump pump = new StreamPumper.LinePump() {

@Override

protected void processLine(String line) {

lineConsumer.accept(line);

}

};

stdout.addPump(pump);

stderr.addPump(pump);

}

CountDownLatch latch = new CountDownLatch(1);

if (linePredicate != null) {

StreamPumper.LinePump pump = new StreamPumper.LinePump() {

// synchronization between stdout and stderr pumps

private final Object sync = new Object();

@Override

protected void processLine(String line) {

synchronized (sync) {

if (latch.getCount() > 0 && linePredicate.test(line)) {

latch.countDown();

}

}

}

};

stdout.addPump(pump);

stderr.addPump(pump);

} else {

latch.countDown();

}

final Future<Void> stdoutTask = stdout.process();

final Future<Void> stderrTask = stderr.process();

stdOut.getOutputStream().setTask(stdoutTask);

stdErr.getOutputStream().setTask(stderrTask);

try {

if (timeout > -1) {

long timeoutMs = timeout == 0 ? -1: unit.toMillis(Utils.adjustTimeout(timeout));

// Every second check if line is printed and if process is still alive

Utils.waitForCondition(() -> latch.getCount() == 0 || !p.isAlive(),

timeoutMs , 1000);

if (latch.getCount() > 0) {

if (!p.isAlive()) {

// Give some extra time for the StreamPumper to run after the process completed

Thread.sleep(1000);

if (latch.getCount() > 0) {

throw new RuntimeException("Started process " + name + " terminated before producing the expected output.");

}

} else {

throw new TimeoutException();

}

}

}

} catch (TimeoutException | RuntimeException | InterruptedException e) {

System.err.println("Failed to start a process (thread dump follows)");

for (Map.Entry<Thread, StackTraceElement[]> s : Thread.getAllStackTraces().entrySet()) {

printStack(s.getKey(), s.getValue());

}

if (p.isAlive()) {

p.destroyForcibly();

}

stdoutTask.cancel(true);

stderrTask.cancel(true);

throw e;

}

return new ProcessImpl(p, stdoutTask, stderrTask, stdOut, stdErr);

}

/**

@SuppressWarnings("overloads")

public static Process startProcess(String name,

ProcessBuilder processBuilder,

final Predicate<String> linePredicate)

throws IOException, InterruptedException, TimeoutException {

return startProcess(name, processBuilder, linePredicate, 0, TimeUnit.SECONDS);

}

/**

public static long getProcessId() throws Exception {

return ProcessHandle.current().pid();

}

/**

public static ProcessBuilder createJavaProcessBuilder(List<String> command) {

return createJavaProcessBuilder(command.toArray(String[]::new));

}

/*

private static List<String> addMainWrapperArgs(String mainWrapper, List<String> command) {

final List<String> unsupportedArgs = List.of(

"-jar", "-cp", "-classpath", "--class-path", "--describe-module", "-d",

"--dry-run", "--list-modules","--validate-modules", "-m", "--module", "-version");

final List<String> doubleWordArgs = List.of(

"--add-opens", "--upgrade-module-path", "--add-modules", "--add-exports",

"--limit-modules", "--add-reads", "--patch-module", "--module-path", "-p");

ArrayList<String> args = new ArrayList<>();

boolean expectSecondArg = false;

boolean isWrapperClassAdded = false;

for (String cmd : command) {

if (isWrapperClassAdded) {

args.add(cmd);

continue;

}

if (expectSecondArg) {

expectSecondArg = false;

args.add(cmd);

continue;

}

if (unsupportedArgs.contains(cmd)) {

return command;

}

if (doubleWordArgs.contains(cmd)) {

expectSecondArg = true;

args.add(cmd);

continue;

}

if (expectSecondArg) {

continue;

}

// command-line or name command-line file

if (cmd.startsWith("-") || cmd.startsWith("@")) {

args.add(cmd);

continue;

}

// if command is like 'java source.java' then return

if (cmd.endsWith(".java")) {

return command;

}

// Some tests might check property to understand

// if virtual threads are tested

args.add("-Dmain.wrapper=" + mainWrapper);

args.add("jdk.test.lib.process.ProcessTools");

args.add(mainWrapper);

isWrapperClassAdded = true;

args.add(cmd);

}

return args;

}

/**

public static ProcessBuilder createJavaProcessBuilder(String... command) {

String javapath = JDKToolFinder.getJDKTool("java");

ArrayList<String> args = new ArrayList<>();

args.add(javapath);

String noCPString = System.getProperty("test.noclasspath", "false");

boolean noCP = Boolean.valueOf(noCPString);

if (!noCP) {

args.add("-cp");

args.add(System.getProperty("java.class.path"));

}

String mainWrapper = System.getProperty("main.wrapper");

if (mainWrapper != null) {

args.addAll(addMainWrapperArgs(mainWrapper, Arrays.asList(command)));

} else {

Collections.addAll(args, command);

}

// Reporting

StringBuilder cmdLine = new StringBuilder();

for (String cmd : args)

cmdLine.append(cmd).append(' ');

System.out.println("Command line: [" + cmdLine.toString() + "]");

ProcessBuilder pb = new ProcessBuilder(args);

if (noCP) {

// clear CLASSPATH from the env

pb.environment().remove("CLASSPATH");

}

return pb;

}

private static void printStack(Thread t, StackTraceElement[] stack) {

System.out.println("\t" + t + " stack: (length = " + stack.length + ")");

if (t != null) {

for (StackTraceElement stack1 : stack) {

System.out.println("\t" + stack1);

}

System.out.println();

}

}

/**

public static ProcessBuilder createTestJvm(List<String> command) {

return createTestJvm(command.toArray(String[]::new));

}

/**

public static ProcessBuilder createTestJvm(String... command) {

return createJavaProcessBuilder(Utils.prependTestJavaOpts(command));

}

/**

public static OutputAnalyzer executeTestJvm(List<String> cmds) throws Exception {

return executeTestJvm(cmds.toArray(String[]::new));

}

/**

public static OutputAnalyzer executeTestJvm(String... cmds) throws Exception {

ProcessBuilder pb = createTestJvm(cmds);

return executeProcess(pb);

}

/**

public static OutputAnalyzer executeTestJava(String... cmds) throws Exception {

return executeTestJvm(cmds);

}

/**

public static OutputAnalyzer executeProcess(ProcessBuilder pb) throws Exception {

return executeProcess(pb, null);

}

/**

public static OutputAnalyzer executeProcess(ProcessBuilder pb, String input) throws Exception {

return executeProcess(pb, input, null);

}

/**

@SuppressWarnings("removal")

public static OutputAnalyzer executeProcess(ProcessBuilder pb, String input,

Charset cs) throws Exception {

OutputAnalyzer output = null;

Process p = null;

boolean failed = false;

try {

p = privilegedStart(pb);

if (input != null) {

try (PrintStream ps = new PrintStream(p.getOutputStream())) {

ps.print(input);

}

}

output = new OutputAnalyzer(p, cs);

p.waitFor();

{ // Dumping the process output to a separate file

var fileName = String.format("pid-%d-output.log", p.pid());

var processOutput = getProcessLog(pb, output);

AccessController.doPrivileged((PrivilegedExceptionAction<Void>) () -> {

Files.writeString(Path.of(fileName), processOutput);

return null;

});

System.out.printf(

"Output and diagnostic info for process %d " +

"was saved into '%s'%n", p.pid(), fileName);

}

return output;

} catch (Throwable t) {

if (p != null) {

p.destroyForcibly().waitFor();

}

failed = true;

System.out.println("executeProcess() failed: " + t);

throw t;

} finally {

if (failed) {

System.err.println(getProcessLog(pb, output));

}

}

}

/**

public static OutputAnalyzer executeProcess(String... cmds) throws Throwable {

return executeProcess(new ProcessBuilder(cmds));

}

/**

public static String getProcessLog(ProcessBuilder pb, OutputAnalyzer output) {

String stderr = output == null ? "null" : output.getStderr();

String stdout = output == null ? "null" : output.getStdout();

String exitValue = output == null ? "null" : Integer.toString(output.getExitValue());

return String.format("--- ProcessLog ---%n" +

"cmd: %s%n" +

"exitvalue: %s%n" +

"stderr: %s%n" +

"stdout: %s%n",

getCommandLine(pb), exitValue, stderr, stdout);

}

/**

public static String getCommandLine(ProcessBuilder pb) {

if (pb == null) {

return "null";

}

StringBuilder cmd = new StringBuilder();

for (String s : pb.command()) {

cmd.append(s).append(" ");

}

return cmd.toString().trim();

}

/**

public static OutputAnalyzer executeCommand(String... cmds)

throws Throwable {

String cmdLine = String.join(" ", cmds);

System.out.println("Command line: [" + cmdLine + "]");

OutputAnalyzer analyzer = ProcessTools.executeProcess(cmds);

System.out.println(analyzer.getOutput());

return analyzer;

}

/**

public static OutputAnalyzer executeCommand(ProcessBuilder pb)

throws Throwable {

String cmdLine = pb.command().stream()

.map(x -> (x.contains(" ") || x.contains("$"))

? ("'" + x + "'") : x)

.collect(Collectors.joining(" "));

System.out.println("Command line: [" + cmdLine + "]");

OutputAnalyzer analyzer = ProcessTools.executeProcess(pb);

System.out.println(analyzer.getOutput());

return analyzer;

}

/**

public static ProcessBuilder createNativeTestProcessBuilder(String executableName,

String... args) throws Exception {

executableName = Platform.isWindows() ? executableName + ".exe" : executableName;

String executable = Paths.get(Utils.TEST_NATIVE_PATH, executableName)

.toAbsolutePath()

.toString();

ProcessBuilder pb = new ProcessBuilder(executable);

pb.command().addAll(Arrays.asList(args));

return addJvmLib(pb);

}

/**

public static ProcessBuilder addJvmLib(ProcessBuilder pb) throws Exception {

String jvmLibDir = Platform.jvmLibDir().toString();

String libPathVar = Platform.sharedLibraryPathVariableName();

String currentLibPath = pb.environment().get(libPathVar);

String newLibPath = jvmLibDir;

if (Platform.isWindows()) {

String libDir = Platform.libDir().toString();

newLibPath = newLibPath + File.pathSeparator + libDir;

}

if ((currentLibPath != null) && !currentLibPath.isEmpty()) {

newLibPath = newLibPath + File.pathSeparator + currentLibPath;

}

pb.environment().put(libPathVar, newLibPath);

return pb;

}

@SuppressWarnings("removal")

private static Process privilegedStart(ProcessBuilder pb) throws IOException {

try {

return AccessController.doPrivileged(

(PrivilegedExceptionAction<Process>) pb::start);

} catch (PrivilegedActionException e) {

throw (IOException) e.getException();

}

}

private static class ProcessImpl extends Process {

private final InputStream stdOut;

private final InputStream stdErr;

private final Process p;

private final Future<Void> stdoutTask;

private final Future<Void> stderrTask;

public ProcessImpl(Process p, Future<Void> stdoutTask, Future<Void> stderrTask,

InputStream stdOut, InputStream etdErr) {

this.p = p;

this.stdoutTask = stdoutTask;

this.stderrTask = stderrTask;

this.stdOut = stdOut;

this.stdErr = etdErr;

}

@Override

public OutputStream getOutputStream() {

return p.getOutputStream();

}

@Override

public InputStream getInputStream() {

return stdOut;

}

@Override

public InputStream getErrorStream() {

return stdErr;

}

@Override

public int waitFor() throws InterruptedException {

int rslt = p.waitFor();

waitForStreams();

return rslt;

}

@Override

public int exitValue() {

return p.exitValue();

}

@Override

public void destroy() {

p.destroy();

}

@Override

public long pid() {

return p.pid();

}

@Override

public boolean isAlive() {

return p.isAlive();

}

@Override

public Process destroyForcibly() {

return p.destroyForcibly();

}

@Override

public boolean waitFor(long timeout, TimeUnit unit) throws InterruptedException {

boolean rslt = p.waitFor(timeout, unit);

if (rslt) {

waitForStreams();

}

return rslt;

}

private void waitForStreams() throws InterruptedException {

try {

stdoutTask.get();

} catch (ExecutionException e) {

}

try {

stderrTask.get();

} catch (ExecutionException e) {

}

}

}

public static final String OLD_MAIN_THREAD_NAME = "old-m-a-i-n";

// ProcessTools as a wrapper

// It executes method main in a separate virtual or platform thread

public static void main(String[] args) throws Throwable {

String wrapper = args[0];

String className = args[1];

String[] classArgs = new String[args.length - 2];

System.arraycopy(args, 2, classArgs, 0, args.length - 2);

Class c = Class.forName(className);

Method mainMethod = c.getMethod("main", new Class[] { String[].class });

mainMethod.setAccessible(true);

if (wrapper.equals("Virtual")) {

// MainThreadGroup used just as a container for exceptions

// when main is executed in virtual thread

MainThreadGroup tg = new MainThreadGroup();

Thread vthread = Thread.ofVirtual().unstarted(() -> {

try {

mainMethod.invoke(null, new Object[] { classArgs });

} catch (InvocationTargetException e) {

tg.uncaughtThrowable = e.getCause();

} catch (Throwable error) {

tg.uncaughtThrowable = error;

}

});

Thread.currentThread().setName(OLD_MAIN_THREAD_NAME);

vthread.setName("main");

vthread.start();

vthread.join();

if (tg.uncaughtThrowable != null) {

throw tg.uncaughtThrowable;

}

} else if (wrapper.equals("Kernel")) {

MainThreadGroup tg = new MainThreadGroup();

Thread t = new Thread(tg, () -> {

try {

mainMethod.invoke(null, new Object[] { classArgs });

} catch (InvocationTargetException e) {

tg.uncaughtThrowable = e.getCause();

} catch (Throwable error) {

tg.uncaughtThrowable = error;

}

});

t.start();

t.join();

if (tg.uncaughtThrowable != null) {

throw tg.uncaughtThrowable;

}

} else {

mainMethod.invoke(null, new Object[] { classArgs });

}

}

static class MainThreadGroup extends ThreadGroup {

MainThreadGroup() {

super("MainThreadGroup");

}

public void uncaughtException(Thread t, Throwable e) {

e.printStackTrace(System.err);

uncaughtThrowable = e;

}

Throwable uncaughtThrowable = null;

}