if goosPrefersCgo() {
		confVal.preferCgo = true
		return
	}

	// The remaining checks are specific to Unix systems.
	switch runtime.GOOS {
	case "plan9", "windows", "js", "wasip1":
		return
	}

	// If any environment-specified resolver options are specified,
	// prefer the cgo resolver.
	// Note that LOCALDOMAIN can change behavior merely by being
	// specified with the empty string.

	}
	if addr != nil {
		t.Errorf("ReadFromUDP got addr %+#v want nil", addr)
	}
}

func TestAllocs(t *testing.T) {
	switch runtime.GOOS {
	case "plan9", "js", "wasip1":
		// These implementations have not been optimized.
		t.Skipf("skipping on %v", runtime.GOOS)
	}
	if !testableNetwork("udp4") {
		t.Skipf("skipping: udp4 not available")
	}

				cpu:     "10",
				pkg:     "sync",
			})
	}

	const cgoHeading = "Testing cgo"
	if t.cgoEnabled {
		t.registerCgoTests(cgoHeading)
	}

	if goos == "wasip1" {
		t.registerTest("wasip1 host tests",
			&goTest{
				variant:   "host",
				pkg:       "runtime/internal/wasitest",
				timeout:   1 * time.Minute,
				runOnHost: true,
			})
	}

		}
		map2 = &profile.Mapping{
			ID:           1,
			Start:        start,
			Limit:        end,
			File:         exe,
			BuildID:      buildID,
			HasFunctions: true,
		}
	case "js", "wasip1":
		addr1 = uint64(abi.FuncPCABIInternal(f1))
		addr2 = uint64(abi.FuncPCABIInternal(f2))
	default:
		addr1 = uint64(abi.FuncPCABIInternal(f1))
		addr2 = uint64(abi.FuncPCABIInternal(f2))

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build !js && !plan9 && !wasip1 && !windows

package os_test

import (
	"fmt"
	"io"
	"math/rand"
	"os"
	"os/signal"
	"runtime"
	"sync"
	"syscall"
	"testing"
	"time"
)

func TestNonpollableDeadline(t *testing.T) {

	sizeOffset := writeSecHeader(ctxt, sectionExport)

	switch buildcfg.GOOS {
	case "wasip1":
		writeUleb128(ctxt.Out, 2) // number of exports
		s := ldr.Lookup("_rt0_wasm_wasip1", 0)
		idx := uint32(lenHostImports) + uint32(ldr.SymValue(s)>>16) - funcValueOffset
		writeName(ctxt.Out, "_start")       // the wasi entrypoint
		ctxt.Out.WriteByte(0x00)            // func export
		writeUleb128(ctxt.Out, uint64(idx)) // funcidx

				t.Errorf("Read(buf) = %d, %v, want %d, nil", n, err, x)
			}
			c.Close()
			<-done
		})
	}
}

func TestCopyPipeIntoTCP(t *testing.T) {
	switch runtime.GOOS {
	case "js", "wasip1":
		t.Skipf("skipping: os.Pipe not supported on %s", runtime.GOOS)
	}

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

	errc := make(chan error, 1)
	defer func() {

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build unix || (js && wasm) || wasip1

package poll

import (
	"internal/itoa"
	"internal/syscall/unix"
	"io"
	"sync/atomic"
	"syscall"
)

// FD is a file descriptor. The net and os packages use this type as a

		// and only on some file systems (AFS, FAT).  To avoid errors during
		// all.bash on those file systems, skip during go test -short.
		// Chmod is not supported on wasip1.
		if runtime.GOOS == "windows" || runtime.GOOS == "wasip1" {
			t.Skip("skipping on " + runtime.GOOS)
		}
		if os.Getuid() == 0 {
			t.Skip("skipping as root")
		}
		if testing.Short() {
			t.Skip("skipping in short mode")
		}

	//
	// Even if GOMAXPROCS=1, we expect the runtime to eventually schedule
	// the AfterFunc goroutine instead of the runnable channel goroutine.
	// However, in https://go.dev/issue/65178 this was observed to live-lock
	// on wasip1/wasm and js/wasm after <10000 runs.
	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(1))

	var (
		wg   sync.WaitGroup
		stop atomic.Bool
		c    = make(chan bool, 1)
	)

	wg.Add(2)
	go func() {