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

    }

    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)

import java.util.concurrent.TimeUnit

import static org.gradle.util.internal.TextUtil.toPlatformLineSeparators

class DaemonClientInputForwarderTest extends ConcurrentSpecification {
    def source = new PipedOutputStream()
    def inputStream = new PipedInputStream(source)

    def received = new LinkedBlockingQueue()
    def dispatch = { received << it } as Dispatch
    def userInputReceiver = new DefaultUserInputReceiver()

        when:
        file("src/test/groovy/Test.groovy") << functionalTest("""
            // defer sending the answer until prompted
            def stdin = new PipedInputStream()
            def stdinSink = new PipedOutputStream(stdin)
            def stdout = new java.io.Writer() {
                def buffer = new StringBuilder()
                def written = false

                void write(char[] cbuf, int off, int len) {