*
     * @return result
     */
    ExecResult waitForFinish();

    /**
     * Returns the result of the process execution, if it has finished.  If the process has not finished, returns null.
     */
    @Nullable
    ExecResult getExecResult();

    void addListener(ExecHandleListener listener);

    void removeListener(ExecHandleListener listener);

     */
    ObjectConnection getConnection();

    ExecResult waitForStop();

    /**
     * Returns the result of the process, if it has exited.  If the process has not exited yet, returns {@link Optional#empty()}.
     */
    Optional<ExecResult> getExecResult();

    JvmMemoryStatus getJvmMemoryStatus();

    /**

import org.gradle.api.internal.provider.sources.process.ProcessOutputValueSource.ExecOutputData;
import org.gradle.api.provider.Provider;
import org.gradle.process.ExecOutput;
import org.gradle.process.ExecResult;

import java.nio.charset.Charset;

import static org.gradle.api.internal.lambdas.SerializableLambdas.transformer;

public class DefaultExecOutput implements ExecOutput {

package org.gradle.api.internal.tasks.compile;

import org.gradle.api.tasks.WorkResult;
import org.gradle.api.tasks.WorkResults;
import org.gradle.language.base.internal.compile.Compiler;
import org.gradle.process.ExecResult;
import org.gradle.process.internal.ExecHandle;
import org.gradle.process.internal.ExecHandleBuilder;
import org.gradle.process.internal.ExecHandleFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

 * limitations under the License.
 */
package org.gradle.integtests.fixtures

import org.gradle.api.internal.file.TestFiles
import org.gradle.internal.os.OperatingSystem
import org.gradle.process.ExecResult
import org.gradle.process.internal.ExecHandle
import org.gradle.process.internal.ExecHandleBuilder

class ScriptExecuter {
    @Delegate
    ExecHandleBuilder builder = TestFiles.execHandleFactory().newExec()

    }

    @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;
        }

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

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

@NonExtensible
public interface JavaExecAction extends JavaExecSpec {
    ExecResult execute();

    }

    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