// TestDeathSignalSetuid verifies that a command run with a different UID still
// receives PDeathsig; it is a regression test for https://go.dev/issue/9686.
func TestDeathSignalSetuid(t *testing.T) {
	if testing.Short() {
		t.Skipf("skipping test that copies its binary into temp dir")
	}

	// Copy the test binary to a location that another user can read/execute
	// after we drop privileges.
	//

		t.Fatal(err)
	}
	goarch, err := goEnv("GOARCH")
	if err != nil {
		t.Fatal(err)
	}
	// The msan tests require support for the -msan option.
	if !compilerRequiredTsanVersion(goos, goarch) {
		t.Skipf("skipping on %s/%s; compiler version for -tsan option is too old.", goos, goarch)
	}

	t.Parallel()
	requireOvercommit(t)
	config := configure("thread")
	config.skipIfCSanitizerBroken(t)

	case "darwin", "dragonfly", "freebsd", "linux", "netbsd", "openbsd", "illumos", "solaris":
	default:
		t.Skipf("skipping; not supported on %v", runtime.GOOS)
	}

	if runtime.GOOS == "openbsd" && (runtime.GOARCH == "arm" || runtime.GOARCH == "mips64" || runtime.GOARCH == "ppc64") {
		// This may be ncpu < 2 related...
		t.Skipf("skipping; test fails on %s/%s - see issue #42464", runtime.GOOS, runtime.GOARCH)
	}

		}
	}
}

func cCompilerCmd(t *testing.T) []string {
	cc, err := quoted.Split(goEnv(t, "CC"))
	if err != nil {
		t.Skipf("parsing go env CC: %s", err)
	}
	if len(cc) == 0 {
		t.Skipf("no C compiler")
	}
	testenv.MustHaveExecPath(t, cc[0])

	out := goEnv(t, "GOGCCFLAGS")
	quote := '\000'
	start := 0
	lastSpace := true
	backslash := false

	"testing"
)

func TestFindProcessViaPidfd(t *testing.T) {
	testenv.MustHaveGoBuild(t)
	t.Parallel()

	if err := os.CheckPidfdOnce(); err != nil {
		// Non-pidfd code paths tested in exec_unix_test.go.
		t.Skipf("skipping: pidfd not available: %v", err)
	}

	p, err := os.StartProcess(testenv.GoToolPath(t), []string{"go"}, &os.ProcAttr{})
	if err != nil {
		t.Fatalf("starting test process: %v", err)
	}
	p.Wait()

	}
}

func TestUNIXProcessAlive(t *testing.T) {
	testenv.MustHaveGoBuild(t)
	t.Parallel()

	p, err := StartProcess(testenv.GoToolPath(t), []string{"sleep", "1"}, &ProcAttr{})
	if err != nil {
		t.Skipf("starting test process: %v", err)
	}
	defer p.Kill()

	proc, err := FindProcess(p.Pid)
	if err != nil {
		t.Errorf("OS reported error for running process: %v", err)
	}
	err = proc.Signal(syscall.Signal(0))

		if err != nil {
			return err
		}
		if !info.IsDir() && strings.HasSuffix(path, ".gz") {
			files = append(files, path)
		}
		return nil
	})
	if err != nil {
		if os.IsNotExist(err) {
			t.Skipf("skipping: GOROOT directory not found: %s", runtime.GOROOT())
		}
		t.Fatal("error collecting list of .gz files in GOROOT: ", err)
	}
	if len(files) == 0 {
		t.Fatal("expected to find some .gz files under GOROOT")
	}

		if got != tt.want {
			t.Errorf("HasPathPrefix(%q, %q) = %v; want %v", tt.s, tt.prefix, got, tt.want)
		}
	}
}

func TestTrimFilePathPrefixSlash(t *testing.T) {
	if os.PathSeparator != '/' {
		t.Skipf("test requires slash-separated file paths")
	}

	type testCase struct {
		s, prefix, want string
	}
	for _, tt := range []testCase{
		{"/", "", "/"},
		{"/", "/", ""},
		{"/foo", "", "/foo"},

func skipIfK8sVersionUnsupported(t framework.TestContext) {
	if !t.Clusters().Default().MinKubeVersion(16) {
		t.Skipf("k8s version not supported for %s (<%s)", t.Name(), "1.16")
	}
	// Kubernetes 1.22 drops support for a number of legacy resources, so we cannot install the old versions
	if !t.Clusters().Default().MaxKubeVersion(21) {
		t.Skipf("k8s version not supported for %s (>%s)", t.Name(), "1.21")
	}

	network := "ip:tcp"
	if !testableNetwork(network) {
		t.Skipf("skipping %s test", network)
	}

	raddr := &IPAddr{IP: IPv4(127, 0, 0, 1).To4()}
	c, err := DialIP(network, &IPAddr{IP: IPv4(127, 0, 0, 1)}, raddr)
	if testenv.SyscallIsNotSupported(err) {
		// May be inside a container that disallows creating a socket.
		t.Skipf("skipping %s test: %v", network, err)
	} else if err != nil {
		t.Fatal(err)
	}