if err != nil {
			syscall.Close(fds[0])
			syscall.Close(fds[1])
			t.Fatalf("SetsockoptInt: %v", err)
		}

		srvFile := os.NewFile(uintptr(fds[0]), "server")
		cliFile := os.NewFile(uintptr(fds[1]), "client")
		defer srvFile.Close()
		defer cliFile.Close()

		srv, err := net.FileConn(srvFile)
		if err != nil {
			t.Errorf("FileConn: %v", err)
			return
		}

func Open(name string) (*File, error) {
	f, err := os.Open(name)
	if err != nil {
		return nil, err
	}
	ff, err := NewFile(f)
	if err != nil {
		f.Close()
		return nil, err
	}
	ff.closer = f
	return ff, nil
}

// Close closes the [File].
// If the [File] was created using [NewFile] directly instead of [Open],
// Close has no effect.
func (f *File) Close() error {
	var err error
	if f.closer != nil {

        def fileSnapshotContext = Mock(RegularFileSnapshotContext)
        def fileSnapshot = Mock(RegularFileSnapshot)

        given:
        def file = temporaryDirectory.newFile('String.class')
        file.bytes = bytesOf(String.class)

        when:
        resourceHasher.hash(fileSnapshotContext)

        then:
        1 * fileSnapshotContext.getSnapshot() >> fileSnapshot

func SetupEmptyFiles(t *testing.T, tmpdir string, fileNames ...string) {
	for _, fileName := range fileNames {
		newFile, err := os.Create(filepath.Join(tmpdir, fileName))
		if err != nil {
			t.Fatalf("Error creating file %s in %s: %v", fileName, tmpdir, err)
		}
		newFile.Close()
	}
}

// SetupPkiDirWithCertificateAuthority is a utility function for kubeadm testing that creates a

			return err
		}
		runtime.KeepAlive(f) // prevent finalization before dup
		fd = uintptr(fd2)
	}
	if prev := runtime_setCrashFD(fd); prev != ^uintptr(0) {
		// We use NewFile+Close because it is portable
		// unlike syscall.Close, whose parameter type varies.
		os.NewFile(prev, "").Close() // ignore error
	}
	return nil
}

//go:linkname runtime_setCrashFD runtime.setCrashFD

		syscall.Close(m)
		return nil, "", ptyError("unlockpt", err)
	}
	processTTY, err = unix.Ptsname(m)
	if err != nil {
		syscall.Close(m)
		return nil, "", ptyError("ptsname", err)
	}
	return os.NewFile(uintptr(m), "pty"), processTTY, nil

    private
    fun MetadataFileChange.writeChange(output: File) {
        when (this) {
            is MetadataNotChanged -> Unit
            is MetadataRemoved -> output.delete()
            is MetadataModified -> this.newFile.copyTo(output, overwrite = true)
        }
    }

    private
    fun writeSuperTypes(superTypesFile: File, superTypes: Properties) {
        superTypesFile.writer().use {

	}

	// Wait for all the goroutines to start executing.
	for _, c := range chans {
		<-c
	}

	// Tell our parent that all the goroutines are executing.
	if _, err := os.NewFile(3, "pipe").WriteString("x"); err != nil {
		fmt.Fprintf(os.Stderr, "write to pipe failed: %v\n", err)
		os.Exit(2)
	}

	select {}
}

func crashDumpsAllThreadsLoop(i int, c chan bool) {
	close(c)
	for {

	// are reserved for stdio. Pre-opened directors also start at fd=3, so
	// we skip fds that aren't sockets. Once we reach EBADF we know there
	// are no more pre-opens.
	for preopenFd := uintptr(3); ; preopenFd++ {
		f := os.NewFile(preopenFd, "")
		l, err := net.FileListener(f)
		f.Close()

		var se syscall.Errno
		switch errors.As(err, &se); se {
		case syscall.ENOTSOCK:
			continue
		case syscall.EBADF:
			err = nil
		}

type Trace struct {
	Spans []Span
}

// New returns a new instance of zipkin.
func New(ctx resource.Context, c Config) (i Instance, err error) {
	return newKube(ctx, c)
}

// NewOrFail returns a new zipkin instance or fails test.
func NewOrFail(t *testing.T, ctx resource.Context, c Config) Instance {
	t.Helper()
	i, err := New(ctx, c)
	if err != nil {