}, nil
}

func (s *DependenciesStub) execute(quietly bool, cmd constants.IptablesCmd, iptVer *IptablesVersion, stdin io.ReadSeeker, args ...string) {
	// We are either getting iptables rules as a `stdin` blob in `iptables-save` format (if this is a restore)
	if stdin != nil {
		buf := bufio.NewScanner(stdin)
		for buf.Scan() {
			stdincmd := buf.Text()
			s.ExecutedAll = append(s.ExecutedAll, stdincmd)

	if err != nil {
		log.Fatalf("os.Open failed: %s", err)
	}
	defer f.Close()
	b, err := io.ReadAll(os.Stdin)
	if err != nil {
		log.Fatalf("io.ReadAll(os.Stdin) failed: %s", err)
	}
	if len(b) != 0 {
		log.Fatalf("io.ReadAll(os.Stdin) returned non-nil: %x", b)
	}
	fmt.Fprintf(os.Stdout, "stdout\n")
	fmt.Fprintf(os.Stderr, "stderr\n")

[short] skip 'runs a test that hangs until its WaitDelay expires'

! go test -v -timeout=1m .

	# After the test process itself prints PASS and exits,
	# the kernel closes its stdin pipe to to the orphaned subprocess.
	# At that point, we expect the subprocess to print 'stdin closed'
	# and periodically log to stderr until the WaitDelay expires.
	#
	# Once the WaitDelay expires, the copying goroutine for 'go test' stops and

		ctx, err := createSPDYServerStreams(w, req, Options{
			Stdin:  true,
			Stdout: true,
		})
		if err != nil {
			t.Errorf("error on createHTTPStreams: %v", err)
			return
		}
		defer ctx.conn.Close()
		// Loopback STDIN data onto STDOUT stream.
		_, err = io.Copy(ctx.stdoutStream, ctx.stdinStream)
		if err != nil {
			t.Fatalf("error copying STDIN to STDOUT: %v", err)
		}

	}))
	defer spdyServer.Close()

		},
		{
			TestName:        "in/out/err",
			Stdin:           "a",
			Stdout:          "b",
			Stderr:          "c",
			MessageCount:    100,
			ClientProtocols: []string{remotecommandconsts.StreamProtocolV2Name},
			ServerProtocols: []string{remotecommandconsts.StreamProtocolV2Name},
		},
		{
			TestName:        "oversized stdin",
			Stdin:           strings.Repeat("a", 20*1024*1024),
			Stdout:          "b",

	// parent has finished reading from the PTY, at which point we unblock the
	// child by closing its stdin pipe.
	stdin, err := cmd.StdinPipe()
	if err != nil {
		t.Fatal(err)
	}

	t.Logf("running %s", cmd)
	err = cmd.Start()
	if err != nil {
		t.Fatalf("starting subprocess: %s", err)
	}
	w.Close()
	t.Cleanup(func() {
		stdin.Close()
		if err := cmd.Wait(); err != nil {
			t.Errorf("suprocess failed with: %s", err)
		}

        public Builder setColorOutput(Boolean colorOutput) {
            this.colorOutput = colorOutput;
            return this;
        }

        public Builder setStdin(InputStream stdin) {
            this.stdin = stdin;
            return this;
        }

        public Builder setJavaHome(File javaHome) {
            validateJavaHome(javaHome);
            this.javaHome = javaHome;
            return this;

			stdin = flowrate.NewReader(stdin, h.MaxBytesPerSec)
		}
		opts.Stdin = stdin
	}
	if h.Options.Stdout {
		stdout := websocketStreams.stdoutStream
		if h.MaxBytesPerSec > 0 {
			stdout = flowrate.NewWriter(stdout, h.MaxBytesPerSec)
		}
		opts.Stdout = stdout
	}
	if h.Options.Stderr {
		stderr := websocketStreams.stderrStream
		if h.MaxBytesPerSec > 0 {
			stderr = flowrate.NewWriter(stderr, h.MaxBytesPerSec)

        // In fact, it would be much better to test this feature using shared daemons
        executer.requireIsolatedDaemons()
    }

    def "task can read stdin when stdin has bounded length"() {
        given:
        buildFile << '''
task echo {
    doLast {
        def reader = new BufferedReader(new InputStreamReader(System.in))
        while (true) {

		return string(line)
	}

	err = c.Start()
	check("Start", err)

	_, err = stdin.Write([]byte("O:I am output\n"))
	check("first stdin Write", err)
	if g, e := line("first output line", outbr), "O:I am output"; g != e {
		t.Errorf("got %q, want %q", g, e)
	}

	_, err = stdin.Write([]byte("E:I am error\n"))
	check("second stdin Write", err)
	if g, e := line("first error line", errbr), "E:I am error"; g != e {