// so that pass 2 won't stomp on an fd it needs later.
	if pipe < nextfd {
		r1, _, _ = RawSyscall(SYS_DUP, uintptr(pipe), uintptr(nextfd), 0)
		if int32(r1) == -1 {
			goto childerror
		}
		pipe = nextfd
		nextfd++
	}
	for i = 0; i < len(fd); i++ {
		if fd[i] >= 0 && fd[i] < i {
			if nextfd == pipe { // don't stomp on pipe
				nextfd++
			}

// license that can be found in the LICENSE file.

//go:build aix || darwin

package syscall

// forkExecPipe opens a pipe and non-atomically sets O_CLOEXEC on both file
// descriptors.
func forkExecPipe(p []int) error {
	err := Pipe(p)
	if err != nil {
		return err
	}
	_, err = fcntl(p[0], F_SETFD, FD_CLOEXEC)
	if err != nil {
		return err
	}

		out.Insert(firstIdentifier)
	case parse.NodeIf:
		out.Merge(getParams(n.(*parse.IfNode).Pipe))
	case parse.NodeWith:
		out.Merge(getParams(n.(*parse.WithNode).Pipe))
	case parse.NodeRange:
		out.Merge(getParams(n.(*parse.RangeNode).Pipe))
	case parse.NodeAction:
		out.Merge(getParams(n.(*parse.ActionNode).Pipe))
	case parse.NodeCommand:
		for _, arg := range n.(*parse.CommandNode).Args {
			out.Merge(getParams(arg))

	testenv.MustHaveGoBuild(t)
	t.Parallel()

	r, w, err := os.Pipe()
	if err != nil {
		t.Fatalf("Pipe() got err %v, want nil", err)
	}
	defer r.Close()
	defer w.Close()

	p, err := os.StartProcess(testenv.GoToolPath(t), []string{"go"}, &os.ProcAttr{
		// N.B. On Windows, StartProcess requires exactly 3 Files. Pass
		// in a dummy pipe to avoid irrelevant output on the test stdout.
		Files: []*os.File{r, w, w},
	})

			log.Fatalf("opening sidecar log file for child: %v", err)
		}
		defer childLog.Close()
		cmd.Stderr = childLog
	}

	if reportCrashes {
		pipe, err := cmd.StdinPipe()
		if err != nil {
			log.Fatalf("StdinPipe: %v", err)
		}

		crashmonitor.Parent(pipe.(*os.File)) // (this conversion is safe)
	}

	if err := cmd.Start(); err != nil {
		log.Fatalf("can't start telemetry child process: %v", err)
	}

        given:
        createDirs("folder", "folder/name|with|pipes")
        settingsFile << "include 'folder:name|with|pipes'"

        when:
        fails 'help'

        then:
        assertFailureContainsForbiddenCharacterMessage('project name', 'name|with|pipes',
            " Set the 'rootProject.name' or adjust the 'include' statement (see ${settingsDslUrl} for more details).")

	cmd.Env = append(cmd.Env, "GOTRACEBACK=crash")
	pr, pw, err := os.Pipe()
	if err != nil {
		t.Fatal("creating pipe: ", err)
	}
	cmd.Stderr = pw
	if err := cmd.Start(); err != nil {
		t.Fatal("starting command: ", err)
	}
	defer cmd.Process.Wait()
	defer cmd.Process.Kill()
	if err := pw.Close(); err != nil {
		t.Log("closing write pipe: ", err)
	}
	defer pr.Close()

	"time"
)

// TODO(@musiol, @odeke-em): unify this code back into
// example.go when js/wasm gets an os.Pipe implementation.
func runExample(eg InternalExample) (ok bool) {
	if chatty.on {
		fmt.Printf("%s=== RUN   %s\n", chatty.prefix(), eg.Name)
	}

	// Capture stdout to temporary file. We're not using
	// os.Pipe because it is not supported on js/wasm.
	stdout := os.Stdout
	f := createTempFile(eg.Name)
	os.Stdout = f

	if req.TLS != nil {
		url = "https://" + req.ProxyAddress
	}
	// Setup a pipe. We could just pass `conn` to `http.NewRequest`, but this has a few issues:
	// * Less visibility into i/o
	// * http will call conn.Close, which will close before we want to (finished writing response).
	pr, pw := io.Pipe()
	r, err := http.NewRequest(http.MethodConnect, url, pr)
	if err != nil {

// exclusive use of a writable pipe connected to the child process's stdin.
func Parent(pipe *os.File) {
	writeSentinel(pipe)
	// Ensure that we get pc=0x%x values in the traceback.
	debug.SetTraceback("system")
	setCrashOutput(pipe)
}

// Child runs the part of the crashmonitor that runs in the child process.
// It expects its stdin to be connected via a pipe to the parent which has
// run Parent.
func Child() {