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.integtests.fixtures.AbstractIntegrationSpec

abstract class AbstractUserInputHandlerIntegrationTest extends AbstractIntegrationSpec {

    protected void interactiveExecution() {
        executer.withStdinPipe().withForceInteractive(true)
    }

    protected void withRichConsole(boolean enabled) {
        if (enabled) {
            executer.withConsole(ConsoleOutput.Rich)
        }
    }

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

        sampleTest.results = [] // fields are null for some reason, perhaps Spock internally modifies constructors
        def gradleHandle = Stub(GradleHandle)
        gradleExecuter.withStdinPipe() >> gradleExecuter
        gradleExecuter.withTasks(_) >> gradleExecuter
        gradleExecuter.withForceInteractive(_) >> gradleExecuter
        gradleExecuter.withArgument(_) >> gradleExecuter

                    }
                    ${outputStream}.println("Hello, " + name);
                }
            }
        """
    }

    def withStdInContents(String message) {
        executer.withStdinPipe(new PipedOutputStream() {
            @Override
            synchronized void connect(PipedInputStream snk) throws IOException {
                super.connect(snk)
                write(message.bytes)

        then:
        output.contains("response: false")
    }

    private void runInteractive(String task, String answer) {
        executer.withForceInteractive(true)
        executer.withStdinPipe()
        executer.withTasks(task, "--configuration-cache")
        def handle = executer.start()
        ConcurrentTestUtil.poll(60) {
            assert handle.standardOutput.contains("there? [yes, no]")
        }

        return this;
    }

    private void requireStdinPipeFor(String method) {
        if (stdinPipe == null) {
            throw new UnsupportedOperationException("Handle must be started using GradleExecuter.withStdinPipe() to use " + method);
        }
    }

    @Override
    public GradleHandle abort() {
        getExecHandle().abort();
        return this;
    }

    @Override