}
    }

    static void pkill(String pid) {
        ExecResult execResult = run(isWindows() ? new String[]{"taskkill.exe", "/F", "/T", "/PID", pid} : new String[]{"kill", "-9", pid});
        if (execResult.code != 0) {
            System.out.println("Failed to kill daemon process " + pid + ". Maybe already killed?\nStdout:\n" + execResult.stdout + "\nStderr:\n" + execResult.stderr);
        }
    }

        return result();
    }

    @Override
    public ExecResult getExecResult() {
        lock.lock();
        try {
            return execResult;
        } finally {
            lock.unlock();
        }
    }

    private ExecResult result() {
        lock.lock();
        try {
            return execResult.rethrowFailure();
        } finally {
            lock.unlock();
        }

    private final DefaultJavaExecSpec javaExecSpec;
    private final Property<String> mainModule;
    private final Property<String> mainClass;
    private final ModularitySpec modularity;
    private final Property<ExecResult> execResult;
    private final Property<JavaLauncher> javaLauncher;
    private final ListProperty<String> jvmArguments;

    public JavaExec() {
        ObjectFactory objectFactory = getObjectFactory();

        ExecResult result = run(command);
        output.printf("Run: %s", Arrays.toString(command));
        output.printf("Stdout: %s", result.stdout);
        output.printf("Stderr: %s", result.stderr);

        result.assertZeroExit();
        return new StdoutAndPatterns(result.stdout);
    }

    private static class ExecResult {
        String[] args;
        int code;

        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 {

        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)

        public ObjectConnection getConnection() {
            return delegate.getConnection();
        }

        @Override
        public ExecResult waitForStop() {
            return delegate.waitForStop();
        }

        @Override
        public Optional<ExecResult> getExecResult() {
            return delegate.getExecResult();
        }

        @Override

     * @return the result of the execution
     */
    ExecResult javaexec(@DelegatesTo(JavaExecSpec.class) Closure closure);

    /**
     * Executes a Java main class.
     *
     * @param action The action for configuring the execution.
     * @return the result of the execution
     */
    ExecResult javaexec(Action<? super JavaExecSpec> action);

    /**