t.Errorf("stderr is unexpectedly a terminal")
		}
	})

	// Now test with a read PTY.
	t.Run("pty", func(t *testing.T) {
		r, processTTY, err := testpty.Open()
		if errors.Is(err, testpty.ErrNotSupported) {
			t.Skipf("%s", err)
		} else if err != nil {
			t.Fatalf("failed to open test PTY: %s", err)
		}
		defer r.Close()
		w, err := os.OpenFile(processTTY, os.O_RDWR, 0)
		if err != nil {
			t.Fatal(err)
		}

	// skip this test. Mutex profile is likely not working,
	// so is the delta profile.

	p, err := query("/debug/pprof/mutex")
	if err != nil {
		t.Skipf("mutex profile is unsupported: %v", err)
	}

	if !seen(p, "mutexHog1") {
		t.Skipf("mutex profile is not working: %v", p)
	}

	// causes mutexHog2 call stacks to appear in the mutex profile.
	done := make(chan bool)
	go func() {
		for {

	"internal/testenv"
	"math/big"
	"runtime"
	"testing"
	"time"
)

func TestHybridPool(t *testing.T) {
	t.Parallel()
	if !(runtime.GOOS == "windows" || runtime.GOOS == "darwin" || runtime.GOOS == "ios") {
		t.Skipf("platform verifier not available on %s", runtime.GOOS)
	}
	if !testenv.HasExternalNetwork() {
		t.Skip()
	}
	if runtime.GOOS == "windows" {
		// NOTE(#51599): on the Windows builders we sometimes see that the state

			t.Skip("https://github.com/istio/istio/pull/46213")
			// 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")
			}
			versions := []string{NMinusOne, NMinusTwo, NMinusThree, NMinusFour}
			for _, v := range versions {

}

func TestUDPServer(t *testing.T) {
	for i, tt := range udpServerTests {
		i, tt := i, tt
		t.Run(fmt.Sprint(i), func(t *testing.T) {
			if !testableListenArgs(tt.snet, tt.saddr, tt.taddr) {
				t.Skipf("skipping %s %s<-%s test", tt.snet, tt.saddr, tt.taddr)
			}
			t.Logf("%s %s<-%s", tt.snet, tt.saddr, tt.taddr)

			c1, err := ListenPacket(tt.snet, tt.saddr)
			if err != nil {

	} else {
		// TODO: we're depending on platform-native objdump here. Hence the Skipf
		// below if it doesn't run for some reason.
		cmd := testenv.Command(t, "objdump", "-d", src)
		var err error
		disasm, err = cmd.StdoutPipe()
		if err != nil {
			t.Fatal(err)
		}
		if err := cmd.Start(); err != nil {
			if errors.Is(err, exec.ErrNotFound) {
				t.Skipf("can't run test due to missing objdump: %s", err)
			}
			t.Fatal(err)

		}
		if gotSum != wantSum {
			t.Errorf("writev call sum  = %v; want %v", gotSum, wantSum)
		}
		return nil
	})
}

func TestWritevError(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skipf("skipping the test: windows does not have problem sending large chunks of data")
	}

	ln := newLocalListener(t, "tcp")

	ch := make(chan Conn, 1)
	defer func() {
		ln.Close()
		for c := range ch {

			t.Logf("%v: %v\n%s", cmd, cmdErr, ee.Stderr)
			if testing.Short() && strings.Contains(string(ee.Stderr), "No process corpse slots currently available, waiting to get one") {
				t.Skipf("Skipping knwn flake in short test mode")
			}
			retryable = bytes.Contains(ee.Stderr, []byte("resource shortage"))
		}
		t.Logf("%v: %v\n", cmd, cmdErr)
		if retryable {
			return 0, 0, true, cmdErr
		}
	}

// Test that sendfile doesn't put a pipe into blocking mode.
func TestSendfilePipe(t *testing.T) {
	switch runtime.GOOS {
	case "plan9", "windows", "js", "wasip1":
		// These systems don't support deadlines on pipes.
		t.Skipf("skipping on %s", runtime.GOOS)
	}

	t.Parallel()

	ln := newLocalListener(t, "tcp")
	defer ln.Close()

	r, w, err := os.Pipe()
	if err != nil {
		t.Fatal(err)
	}
	defer w.Close()

					// Reiserfs rejects the big seeks.
					t.Skipf("skipping test known to fail on reiserfs; https://golang.org/issue/91")
				}
			}
			t.Errorf("#%d: Seek(%v, %v) = %v, %v want %v, nil", i, tt.in, tt.whence, off, err, tt.out)
		}
	}
}

func TestSeekError(t *testing.T) {
	switch runtime.GOOS {
	case "js", "plan9", "wasip1":
		t.Skipf("skipping test on %v", runtime.GOOS)
	}
	t.Parallel()