// This binary collects a 1s delta mutex profile and dumps it to os.Stdout.
//
// This is in a subprocess because we want the base mutex profile to be empty
// (as a regression test for https://go.dev/issue/64566) and the only way to
// force reset the profile is to create a new subprocess.
//
// This manually collects the HTTP response and dumps to stdout in order to

	// a parent is a console process without console is not clearly documented
	// but empirically we observed the new console is created and attached to the
	// subprocess in the default setup.
	//
	// Ensure no new console is attached to the subprocess by setting CREATE_NO_WINDOW.
	//   https://learn.microsoft.com/en-us/windows/console/creation-of-a-console

    logging.info("Setting up GitHub Actions git user")
    subprocess.run(["git", "config", "user.name", "github-actions"], check=True)
    subprocess.run(
        ["git", "config", "user.email", "******@****.***"], check=True
    )
    branch_name = "fastapi-people"
    logging.info(f"Creating a new branch {branch_name}")
    subprocess.run(["git", "checkout", "-b", branch_name], check=True)

# 'go run' should not pass extraneous environment variables to the subprocess.
go run run.go
! stdout .
! stderr .

-- run.go --
package main

import "os"

func main() {
	if os.Getenv("TERM") != "" {
		os.Exit(1)
	}

				// character used for JSON framing so that the JSON parser doesn't
				// misinterpret the subprocess output as output from the parent test.
				t.Logf("%q", b)
			}
			if err != nil {
				t.Error(err)
			}
		})
	}
}

// testFlagHelper is called by the TestFlagHelper subprocess.
func testFlagHelper(t *testing.T) {
	f := flag.Lookup("test.v")
	if f == nil {

internal invocation viewer.
"""
import collections
import os
import re
import subprocess
import sys
from junitparser import JUnitXml

result = JUnitXml()
try:
  files = subprocess.check_output(
      ["grep", "-rlE", '(failures|errors)="[1-9]', sys.argv[1]]
  )
except subprocess.CalledProcessError as e:
  print("No failures found to log!")
  exit(0)

//go:build windows || plan9 || (js && wasm) || wasip1

package testenv

import (
	"errors"
	"io/fs"
	"os"
)

// Sigquit is the signal to send to kill a hanging subprocess.
// On Unix we send SIGQUIT, but on non-Unix we only have os.Kill.
var Sigquit = os.Kill

func syscallIsNotSupported(err error) bool {
	return errors.Is(err, fs.ErrPermission) || errors.Is(err, errors.ErrUnsupported)

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

//go:build unix

package testenv

import (
	"errors"
	"io/fs"
	"syscall"
)

// Sigquit is the signal to send to kill a hanging subprocess.
// Send SIGQUIT to get a stack trace.
var Sigquit = syscall.SIGQUIT

func syscallIsNotSupported(err error) bool {
	if err == nil {
		return false
	}

	var errno syscall.Errno

// Make sure we don't get an index out of bounds error
// while trying to print a map that is concurrently modified.
// The runtime might complain (throw) if it detects the modification,
// so we have to run the test as a subprocess.

package main

import (
	"os/exec"
	"strings"
)

func main() {
	out, _ := exec.Command("go", "run", "fixedbugs/issue33275.go").CombinedOutput()

		}
	}
}

// The prime sieve: Daisy-chain Filter processes together.
func Sieve() {
	ch := make(chan int) // Create a new channel.
	go Generate(ch)      // Start Generate() as a subprocess.
	for {
		prime := <-ch
		print(prime, "\n")
		ch1 := make(chan int)
		go Filter(ch, ch1, prime)
		ch = ch1
	}
}

func main() {
	Sieve()