n, err := listen.Read(buf[:])
	if err != nil {
		listen.Close()
		return nil, err
	}
	name := string(buf[:n])
	ctl, err := os.OpenFile(netdir+"/"+fd.net+"/"+name+"/ctl", os.O_RDWR, 0)
	if err != nil {
		listen.Close()
		return nil, err
	}
	data, err := os.OpenFile(netdir+"/"+fd.net+"/"+name+"/data", os.O_RDWR, 0)
	if err != nil {
		listen.Close()
		ctl.Close()
		return nil, err
	}

	if target != "wasip1/wasm" {
		t.Skip()
	}

	switch os.Getenv("GOWASIRUNTIME") {
	case "wasmer":
		t.Skip("wasmer does not support non-blocking I/O")
	}

	for _, mode := range []string{"os.OpenFile", "os.NewFile"} {
		t.Run(mode, func(t *testing.T) {
			args := []string{"run", "./testdata/nonblock.go", mode}

			fifos := make([]*fifo, 8)
			for i := range fifos {

package main

import (
	"fmt"
	"log"
	"os"
)

func main() {
	if os.Geteuid() == os.Getuid() {
		os.Exit(99)
	}

	fmt.Fprintf(os.Stdout, "GOTRACEBACK=%s\n", os.Getenv("GOTRACEBACK"))
	f, err := os.OpenFile(os.Getenv("TEST_OUTPUT"), os.O_CREATE|os.O_RDWR, 0600)
	if err != nil {
		log.Fatalf("os.Open failed: %s", err)
	}
	defer f.Close()
	fmt.Fprintf(os.Stderr, "hello\n")

	if err != nil {
		t.Fatalf("open ErrPathNUL tempfile: %s", err)
	}
	defer os.Remove(f.Name())
	defer f.Close()
	f2, err := os.OpenFile(f.Name(), os.O_RDWR, 0600)
	if err != nil {
		t.Fatalf("open ErrPathNUL: %s", err)
	}
	f2.Close()
	f2, err = os.OpenFile(f.Name()+"\x00", os.O_RDWR, 0600)
	if err == nil {
		f2.Close()
		t.Fatal("Open should have failed")
	}
}

func AppendFile(dst string, src string, osync bool) error {
	flags := os.O_WRONLY | os.O_APPEND | os.O_CREATE
	if osync {
		flags |= os.O_SYNC
	}
	appendFile, err := os.OpenFile(dst, flags, 0o666)
	if err != nil {
		return err
	}
	defer appendFile.Close()

	srcFile, err := os.Open(src)
	if err != nil {
		return err
	}
	defer srcFile.Close()

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
	"fmt"
	"io"
	"log"
	"os"
)

func main() {
	f, err := os.OpenFile(os.Getenv("TEST_OUTPUT"), os.O_CREATE|os.O_RDWR, 0600)
	if err != nil {
		log.Fatalf("os.Open failed: %s", err)
	}
	defer f.Close()
	b, err := io.ReadAll(os.Stdin)
	if err != nil {

		}
		name = string(buf[:n])
	default:
		if len(comp) < 4 {
			return nil, errors.New("could not find control file for connection")
		}
		dir := netdir + "/" + comp[1] + "/" + name
		ctl, err = os.OpenFile(dir+"/ctl", os.O_RDWR, 0)
		if err != nil {
			return nil, err
		}
		defer close(int(ctl.Fd()))
	}
	dir := netdir + "/" + comp[1] + "/" + name
	laddr, err := readPlan9Addr(comp[1], dir+"/local")
	if err != nil {

	logFile *os.File
)

func TestMain(m *testing.M) {
	flag.Parse()
	var err error
	logFile, err = os.OpenFile(*logPath, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0666)
	if os.IsExist(err) {
		*logPath += ".worker"
		logFile, err = os.OpenFile(*logPath, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0666)
	}
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	os.Exit(m.Run())
}

		return res, nil
	}
	return nil, nil
}

// Open is a fake call that returns nil.
func (*FakeOS) Open(name string) (*os.File, error) {
	return nil, nil
}

// OpenFile is a fake call that return nil.
func (*FakeOS) OpenFile(name string, flag int, perm os.FileMode) (*os.File, error) {
	return nil, nil
}

// Rename is a fake call that return nil.
func (*FakeOS) Rename(oldpath, newpath string) error {

	mode := os.Args[1]

	ready := make(chan struct{})

	var wg sync.WaitGroup
	for _, path := range os.Args[2:] {
		f, err := os.Open(path)
		if err != nil {
			panic(err)
		}
		switch mode {
		case "os.OpenFile":
		case "os.NewFile":
			fd := f.Fd()
			if err := syscall.SetNonblock(int(fd), true); err != nil {
				panic(err)
			}
			f = os.NewFile(fd, path)
		default:
			panic("invalid test mode")
		}