private final Action<ExecutionResult> resultAssertion;
    private final PipedOutputStream stdinPipe;
    private final boolean isDaemon;

    private final DurationMeasurement durationMeasurement;
    private final AtomicReference<ExecHandle> execHandleRef = new AtomicReference<>();

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

import java.io.PipedOutputStream;

public interface GradleHandle {
    /**
     * Returns the stream for writing to stdin.
     */
    PipedOutputStream getStdinPipe();

    /**
     * Returns the stdout output currently received from the build. This is live.
     */
    String getStandardOutput();

            if (!line) {
                break
            }
            print "[$line]"
        }
    }
}
'''
        executer.withStdinPipe(new PipedOutputStream() {
            @Override
            void connect(PipedInputStream snk) throws IOException {
                super.connect(snk)
                write(TextUtil.toPlatformLineSeparators("abc\n123").bytes)

import org.gradle.process.internal.AbstractExecHandleBuilder;
import org.gradle.util.internal.IncubationLogger;

import java.io.PipedOutputStream;

import static java.lang.String.format;

public class ParallelForkingGradleHandle extends ForkingGradleHandle {

    def "does not cancel on EOT or by closing System.in when not interactive"() {
        when:
        executer.beforeExecute {
            it.withForceInteractive(false).withStdinPipe(new PipedOutputStream() {
                @Override
                void connect(PipedInputStream snk) throws IOException {
                    super.connect(snk)
                    close()
                }
            })
        }

import spock.lang.AutoCleanup

import java.util.concurrent.Executors

class DefaultCancellableOperationManagerTest extends ConcurrentSpec {

    @AutoCleanup
    def writeEnd = new PipedOutputStream()
    @AutoCleanup("shutdownNow")
    def executorService = Executors.newCachedThreadPool()
    def cancellationToken = new DefaultBuildCancellationToken()

            }
        }

        private void initPipe() {
            if (stdinPipe == null) {
                emulatedSystemIn = new PipedInputStream();
                try {
                    stdinPipe = new PipedOutputStream(emulatedSystemIn);
                } catch (IOException e) {
                    throw UncheckedException.throwAsUncheckedException(e);
                }
            }
        }

     */
    GradleExecuter withStdinPipe();

    /**
     * Sets a stream to use for writing to stdin.
     */
    GradleExecuter withStdinPipe(PipedOutputStream stdInPipe);

    default GradleExecuter withStdIn(String input) {
        return withStdinPipe(new PipedOutputStream() {
            @Override
            public void connect(PipedInputStream snk) throws IOException {
                super.connect(snk);

    }

    private void runBuildWithStandardInput(ProjectConnection connection) {
        def build = basicBuildConfiguration(connection)

        def stdin = new PipedInputStream()
        def stdinWriter = new PipedOutputStream(stdin)

        build.standardInput = stdin

        def resultHandler = new TestResultHandler()
        build.run(resultHandler)

        poll(60) {
            assert getOutput().contains(PROMPT)

        return executable;
    }

    @Override
    public GradleExecuter withStdinPipe() {
        return withStdinPipe(new PipedOutputStream());
    }

    @Override
    public GradleExecuter withStdinPipe(PipedOutputStream stdInPipe) {
        this.stdinPipe = stdInPipe;
        return this;
    }

    public InputStream connectStdIn() {
        try {