import org.gradle.process.ExecResult; //导入依赖的package包/类
protected ExecutionResult waitForStop(boolean expectFailure) {
    ExecHandle execHandle = getExecHandle();
    ExecResult execResult = execHandle.waitForFinish();
    if (durationMeasurement != null) {
        durationMeasurement.stop();
    }
    execResult.rethrowFailure(); // nop if all ok

    String output = getStandardOutput();
    String error = getErrorOutput();

    boolean didFail = execResult.getExitValue() != 0;
    if (didFail != expectFailure) {
        String message = String.format("Gradle execution %s in %s with: %s %s%nOutput:%n%s%n-----%nError:%n%s%n-----%n",
            expectFailure ? "did not fail" : "failed", execHandle.getDirectory(), execHandle.getCommand(), execHandle.getArguments(), output, error);
        throw new UnexpectedBuildFailure(message);
    }

    ExecutionResult executionResult = expectFailure ? toExecutionFailure(output, error) : toExecutionResult(output, error);
    resultAssertion.execute(executionResult);
    return executionResult;
}
 

import org.gradle.process.ExecResult; //导入依赖的package包/类
private String transform(File gccBinary, List<String> args) {
    ExecAction exec = execActionFactory.newExecAction();
    exec.executable(gccBinary.getAbsolutePath());
    exec.setWorkingDir(gccBinary.getParentFile());
    exec.args(args);
    StreamByteBuffer buffer = new StreamByteBuffer();
    exec.setStandardOutput(buffer.getOutputStream());
    exec.setErrorOutput(NullOutputStream.INSTANCE);
    exec.setIgnoreExitValue(true);
    ExecResult result = exec.execute();

    int exitValue = result.getExitValue();
    if (exitValue == 0) {
        return buffer.readAsString();
    } else {
        return null;
    }
}
 

import org.gradle.process.ExecResult; //导入依赖的package包/类
public ExecResult waitForFinish() {
    lock.lock();
    try {
        while (!stateIn(ExecHandleState.SUCCEEDED, ExecHandleState.ABORTED, ExecHandleState.FAILED, ExecHandleState.DETACHED)) {
            try {
                condition.await();
            } catch (InterruptedException e) {
                //ok, wrapping up...
                throw UncheckedException.throwAsUncheckedException(e);
            }
        }
    } finally {
        lock.unlock();
    }

    executor.stop();

    return result();
}
 

import org.gradle.process.ExecResult; //导入依赖的package包/类
static Integer getGitTags(final Project project) {
    final ByteArrayOutputStream baos = new ByteArrayOutputStream();
    final ExecResult res = project.exec(new Action<ExecSpec>() {
        @Override
        public void execute(final ExecSpec execSpec) {
            execSpec.commandLine("git", "tag");
            execSpec.setStandardOutput(baos);
        }
    });
    System.out.println(String.format("getGitTags:exit '%d'", res.getExitValue()));
    if (res.getExitValue() == 0) {
        final String str = baos.toString().trim();
        final int numTags = (str == null || str.length() == 0) ? 1 : str.split("\n").length;
        System.out.println(String.format("getGitTags 'num=%d'", numTags));
        return numTags;
    } else {
        return 1;
    }
}
 

import org.gradle.process.ExecResult; //导入依赖的package包/类
public ExecResult waitForFinish() {
    lock.lock();
    try {
        while (!stateIn(ExecHandleState.SUCCEEDED, ExecHandleState.ABORTED, ExecHandleState.FAILED, ExecHandleState.DETACHED)) {
            try {
                stateChanged.await();
            } catch (InterruptedException e) {
                //ok, wrapping up...
                throw UncheckedException.throwAsUncheckedException(e);
            }
        }
    } finally {
        lock.unlock();
    }

    executor.stop();

    return result();
}
 

import org.gradle.process.ExecResult; //导入依赖的package包/类
/** Calls javaExec() in a way which is friendly with windows classpath limitations. */
public static ExecResult javaExec(Project project, Action<JavaExecSpec> spec) throws IOException {
	if (OS.getNative().isWindows()) {
		Box.Nullable<File> classpathJarBox = Box.Nullable.ofNull();
		ExecResult execResult = project.javaexec(execSpec -> {
			// handle the user
			spec.execute(execSpec);
			// create a jar which embeds the classpath
			File classpathJar = toJarWithClasspath(execSpec.getClasspath());
			classpathJar.deleteOnExit();
			// set the classpath to be just that one jar
			execSpec.setClasspath(project.files(classpathJar));
			// save the jar so it can be deleted later
			classpathJarBox.set(classpathJar);
		});
		// delete the jar after the task has finished
		Errors.suppress().run(() -> FileMisc.forceDelete(classpathJarBox.get()));
		return execResult;
	} else {
		return project.javaexec(spec);
	}
}
 

import org.gradle.process.ExecResult; //导入依赖的package包/类
protected ExecutionResult waitForStop(boolean expectFailure) {
    ExecHandle execHandle = getExecHandle();
    ExecResult execResult = execHandle.waitForFinish();
    execResult.rethrowFailure(); // nop if all ok

    String output = getStandardOutput();
    String error = getErrorOutput();

    boolean didFail = execResult.getExitValue() != 0;
    if (didFail != expectFailure) {
        String message = String.format("Gradle execution %s in %s with: %s %s%nOutput:%n%s%n-----%nError:%n%s%n-----%n",
                expectFailure ? "did not fail" : "failed", execHandle.getDirectory(), execHandle.getCommand(), execHandle.getArguments(), output, error);
        throw new UnexpectedBuildFailure(message);
    }

    ExecutionResult executionResult = expectFailure ? toExecutionFailure(output, error) : toExecutionResult(output, error);
    resultAssertion.execute(executionResult);
    return executionResult;
}
 

import org.gradle.process.ExecResult; //导入依赖的package包/类
private String transform(File gccBinary, List<String> args) {
    ExecAction exec = execActionFactory.newExecAction();
    exec.executable(gccBinary.getAbsolutePath());
    exec.setWorkingDir(gccBinary.getParentFile());
    exec.args(args);
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    exec.setStandardOutput(baos);
    exec.setErrorOutput(new ByteArrayOutputStream());
    exec.setIgnoreExitValue(true);
    ExecResult result = exec.execute();

    int exitValue = result.getExitValue();
    if (exitValue == 0) {
        return new String(baos.toByteArray());
    } else {
        return null;
    }
}
 

import org.gradle.process.ExecResult; //导入依赖的package包/类
public ExecResult waitForFinish() {
    lock.lock();
    try {
        while (!stateIn(ExecHandleState.SUCCEEDED, ExecHandleState.ABORTED, ExecHandleState.FAILED, ExecHandleState.DETACHED)) {
            try {
                condition.await();
            } catch (InterruptedException e) {
                //ok, wrapping up...
            }
        }
    } finally {
        lock.unlock();
    }

    executor.stop();

    return result();
}
 

import org.gradle.process.ExecResult; //导入依赖的package包/类
public String transform(File gccBinary) {
    ExecAction exec = execActionFactory.newExecAction();
    exec.executable(gccBinary.getAbsolutePath());
    exec.setWorkingDir(gccBinary.getParentFile());
    exec.args("-dM", "-E", "-");
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    exec.setStandardOutput(baos);
    exec.setIgnoreExitValue(true);
    ExecResult result = exec.execute();

    int exitValue = result.getExitValue();
    if (exitValue == 0) {
        return new String(baos.toByteArray());
    } else {
        return null;
    }
}
 

import org.gradle.process.ExecResult; //导入依赖的package包/类
private String prepareMessage(String output, ExecResult result) {
        StringBuilder sb = new StringBuilder();
        sb.append(DaemonMessages.UNABLE_TO_START_DAEMON);
        //TODO SF if possible, include the exit value.
//        if (result.getExitValue()) {
//            sb.append("\nThe process has exited with value: ");
//            sb.append(result.getExecResult().getExitValue()).append(".");
//        } else {
//            sb.append("\nThe process may still be running.");
//        }
        sb.append("\nThis problem might be caused by incorrect configuration of the daemon.");
        sb.append("\nFor example, an unrecognized jvm option is used.");
        sb.append("\nPlease refer to the user guide chapter on the daemon at ");
        sb.append(documentationRegistry.getDocumentationFor("gradle_daemon"));
        sb.append("\nPlease read below process output to find out more:");
        sb.append("\n-----------------------\n");
        sb.append(output);
        return sb.toString();
    }
 

import org.gradle.process.ExecResult; //导入依赖的package包/类
public ExecResult execute() {
    ExecHandle execHandle = build();
    ExecResult execResult = execHandle.start().waitForFinish();
    if (!isIgnoreExitValue()) {
        execResult.assertNormalExitValue();
    }
    return execResult;
}
 

import org.gradle.process.ExecResult; //导入依赖的package包/类
private EnumMap<SysProp, String> getMetadataInternal(File jdkPath) {
    JavaExecAction exec = factory.newJavaExecAction();
    exec.executable(javaExe(jdkPath, "java"));
    File workingDir = Files.createTempDir();
    exec.setWorkingDir(workingDir);
    exec.setClasspath(new SimpleFileCollection(workingDir));
    try {
        writeProbe(workingDir);
        exec.setMain(JavaProbe.CLASSNAME);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        exec.setStandardOutput(baos);
        ByteArrayOutputStream errorOutput = new ByteArrayOutputStream();
        exec.setErrorOutput(errorOutput);
        exec.setIgnoreExitValue(true);
        ExecResult result = exec.execute();
        int exitValue = result.getExitValue();
        if (exitValue == 0) {
            return parseExecOutput(baos.toString());
        }
        return error("Command returned unexpected result code: " + exitValue + "\nError output:\n" + errorOutput);
    } catch (ExecException ex) {
        return error(ex.getMessage());
    } finally {
        try {
            FileUtils.deleteDirectory(workingDir);
        } catch (IOException e) {
            throw new GradleException("Unable to delete temp directory", e);
        }
    }
}
 

import org.gradle.process.ExecResult; //导入依赖的package包/类
private void executeCompiler(ExecHandle handle) {
    handle.start();
    ExecResult result = handle.waitForFinish();
    if (result.getExitValue() != 0) {
        throw new CompilationFailedException(result.getExitValue());
    }
}
 

import org.gradle.process.ExecResult; //导入依赖的package包/类
private ExecResult result() {
    lock.lock();
    try {
        execResult.rethrowFailure();
        return execResult;
    } finally {
        lock.unlock();
    }
}
 

import org.gradle.process.ExecResult; //导入依赖的package包/类
private void onProcessStop(ExecResult execResult) {
    lock.lock();
    try {
        try {
            execResult.rethrowFailure().assertNormalExitValue();
        } catch (Throwable e) {
            processFailure = e;
        }
        running = false;
        condition.signalAll();
    } finally {
        lock.unlock();
    }
}
 

import org.gradle.process.ExecResult; //导入依赖的package包/类
public ExecResult waitForStop() {
    try {
        return execHandle.waitForFinish().assertNormalExitValue();
    } finally {
        cleanup();
    }
}
 

import org.gradle.process.ExecResult; //导入依赖的package包/类
public static Action<ExecResult> stopExecution() {
    return new Action<ExecResult>() {
        public void execute(ExecResult exec) {
            if (exec.getExitValue() != 0) {
                LOG.info("External process returned exit code: {}. Stopping the execution of the task.");
                //Cleanly stop executing the task, without making the task failed.
                throw new StopExecutionException();
            }
        }
    };
}
 

import org.gradle.process.ExecResult; //导入依赖的package包/类
private static Action<ExecResult> ensureSucceeded(final String prefix) {
    return new Action<ExecResult>() {
        public void execute(ExecResult result) {
            ensureSucceeded(result, prefix);
        }
    };
}
 

import org.gradle.process.ExecResult; //导入依赖的package包/类
public void mapJarFile(File input, File output, ModGradleExtension extension) {
    ExecResult result = getProject().javaexec(new Closure<JavaExecSpec>(this) {
        public JavaExecSpec call() {
            JavaExecSpec exec = (JavaExecSpec) getDelegate();
            exec.args(
                    Constants.SPECIALSOURCE_JAR.getAbsolutePath(),
                    "map",
                    "-i",
                    input.getAbsolutePath(),
                    "-m",
                    Constants.MAPPING_SRG.get(extension).getAbsolutePath(),
                    "-o",
                    output.getAbsolutePath()
            );
            exec.setMain("-jar");
            exec.setWorkingDir(Constants.CACHE_FILES);
            exec.classpath(Constants.getClassPath());
            //exec.setStandardOutput(System.out); // TODO: store the logs?
            exec.setMaxHeapSize("512M");

            return exec;
        }

        public JavaExecSpec call(Object obj) {
            return call();
        }
    });
    int exitValue = result.getExitValue();
    if (exitValue != 0) {
        this.getLogger().error(":SpecialSource exit value: " + exitValue);
        throw new RuntimeException("SpecialSource failed to decompile");
    }
}