}

    @Override
    public ExecResult execute() {
        ExecHandle execHandle = build();
        ExecResult execResult = execHandle.start().waitForFinish();
        if (!isIgnoreExitValue()) {
            execResult.assertNormalExitValue();
        }
        return execResult;
    }

            @Override
            public void executionStarted(ExecHandle execHandle) {
            }

            @Override
            public void executionFinished(ExecHandle execHandle, ExecResult execResult) {
                onProcessStop(execResult);
            }
        });
    }

    public void startAccepting(ConnectionAcceptor acceptor) {
        lock.lock();
        try {
            this.acceptor = acceptor;

        return logLevel;
    }

    public boolean isFailed() {
        return workerProcess.getExecResult().map(execResult -> execResult.getExitValue() != 0).orElse(false);
    }

    public Optional<Integer> getExitCode() {
        return workerProcess.getExecResult().map(ExecResult::getExitValue);
    }

    public boolean isNotExpirable() {
        return cannotBeExpired;
    }

    @Override

 * limitations under the License.
 */
package org.gradle.process.internal;

import org.gradle.api.NonExtensible;
import org.gradle.process.ExecResult;
import org.gradle.process.ExecSpec;

@NonExtensible
public interface ExecAction extends ExecSpec {
    ExecResult execute() throws ExecException;

 */
package org.gradle.api.internal;

import org.gradle.api.Action;
import org.gradle.process.ExecResult;
import org.gradle.process.ExecSpec;
import org.gradle.process.JavaExecSpec;

public interface ProcessOperations {

    ExecResult javaexec(Action<? super JavaExecSpec> action);

    ExecResult exec(Action<? super ExecSpec> action);

package org.gradle.process.internal.worker;

import org.gradle.process.ExecResult;

public interface WorkerControl {
    /**
     * Starts the worker process, blocking until successfully started.
     */
    WorkerProcess start();

    /**
     * Requests that the worker complete all work and stop. Blocks until the worker process has stopped.
     */
    ExecResult stop();

    /**

import org.gradle.process.ExecResult
import org.gradle.process.internal.ExecAction
import org.gradle.process.internal.ExecActionFactory
import spock.lang.Specification

class CompilerMetaDataProviderFactoryTest extends Specification {

    def execActionFactory = Mock(ExecActionFactory)
    def execAction = Mock(ExecAction)
    def execResult = Mock(ExecResult)

 */

package org.gradle.process.internal

import org.apache.commons.io.FileUtils
import org.gradle.api.internal.file.TestFiles
import org.gradle.internal.classloader.ClasspathUtil
import org.gradle.process.ExecResult
import org.gradle.test.fixtures.concurrent.ConcurrentSpec
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.gradle.test.precondition.Requires

     *
     * @param action Action to configure the ExecSpec
     * @return {@link ExecResult} that can be used to check if the execution worked
     */
    ExecResult exec(Action<? super ExecSpec> action);

    /**
     * Executes the specified external <code>java</code> process.

     *
     * @param execHandle the handle that is about to start
     */
    void executionStarted(ExecHandle execHandle);

    void executionFinished(ExecHandle execHandle, ExecResult execResult);