}

    @Override
    public ExecResult javaexec(Closure closure) {
        return processOperations.javaexec(ConfigureUtil.configureUsing(closure));
    }

    @Override
    public ExecResult javaexec(Action<? super JavaExecSpec> action) {
        return processOperations.javaexec(action);
    }

    @Override
    public ExecResult exec(Closure closure) {

        fileOperations.delete(configuration)

    override fun exec(configuration: Action<ExecSpec>): ExecResult =
        processOperations.exec(configuration)

    override fun javaexec(configuration: Action<JavaExecSpec>): ExecResult =
        processOperations.javaexec(configuration)

    private
    val fileOperations by unsafeLazy(host::getFileOperations)

    private

    public static class ExecOutputData {
        private final ExecResult result;
        private final byte[] output;
        private final byte[] error;

        public ExecOutputData(ExecResult result, byte[] output, byte[] error) {
            this.result = result;
            this.output = output;
            this.error = error;
        }

        public ExecResult getResult() {
            return result;
        }

        def action = Mock(ExecAction)
        def execResult = Mock(ExecResult)
        1 * execActionFactory.newExecAction() >> action
        1 * action.commandLine(cygpath.absolutePath, '-w', from)
        1 * action.setStandardOutput(_) >> { OutputStream outputStream -> outputStream.write(to.bytes) }
        1 * action.execute() >> execResult
        _ * execResult.assertNormalExitValue()
    }

        ));

        resultVerification.execute(execResult);
        return createBuildResult(execResult);
    }

    private BuildResult createBuildResult(GradleExecutionResult execResult) {
        return new FeatureCheckBuildResult(
            execResult.getBuildOperationParameters(),
            execResult.getOutput(),
            execResult.getTasks()
        );
    }

import org.gradle.api.provider.ValueSourceParameters
import org.gradle.api.reflect.ObjectInstantiationException
import org.gradle.internal.state.Managed
import org.gradle.process.ExecOperations
import org.gradle.process.ExecResult

import javax.inject.Inject

import static org.gradle.api.internal.provider.ValueSourceProviderFactory.ValueListener.ObtainedValue

class DefaultValueSourceProviderFactoryTest extends ValueSourceBasedSpec {

    }

    protected abstract String getTaskNameUnderTest()

    protected abstract String getExecResultDsl()

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)
    def "returns null ExecResult when task haven't executed"() {
        makeExecProject()
        writeSucceedingExec()
        buildFile << """
            task verify {
                doLast {
                    assert ${execResultDsl} == null

import org.gradle.api.tasks.Input;
import org.gradle.api.tasks.OutputDirectory;
import org.gradle.api.tasks.TaskAction;
import org.gradle.api.tasks.UntrackedTask;
import org.gradle.process.ExecOperations;
import org.gradle.process.ExecResult;

import javax.inject.Inject;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;

// tag::git-clone[]
@UntrackedTask(because = "Git tracks the state") // <1>

        delegate.configure(objects, configureAction)

    override fun exec(closure: Closure<*>): ExecResult =
        delegate.exec(closure)

    override fun exec(action: Action<in ExecSpec>): ExecResult =
        delegate.exec(action)

    override fun sync(action: Action<in SyncSpec>): WorkResult =
        delegate.sync(action)

import org.gradle.launcher.daemon.client.DaemonGreeter
import org.gradle.launcher.daemon.logging.DaemonMessages
import org.gradle.internal.remote.internal.inet.MultiChoiceAddress
import org.gradle.process.ExecResult
import spock.lang.Specification

class DaemonGreeterTest extends Specification {

    def registry = Mock(DocumentationRegistry)
    def args = ["foo", "bar"]

    def "parses the process output"() {