)

func openNsTestOverride(s string) (NetnsCloser, error) {
	return newFakeNs(inc()), nil
}

func openNsTestOverrideWithInodes(inodes ...uint64) func(s string) (NetnsCloser, error) {
	i := 0
	return func(s string) (NetnsCloser, error) {
		inode := inodes[i]
		i++
		return newFakeNsInode(inc(), inode), nil
	}
}

func TestUpsertPodCache(t *testing.T) {
	counter.Store(0)

// limitations under the License.

package nodeagent

import (
	"fmt"
	"io/fs"
)

func GetInode(fi fs.FileInfo) (uint64, error) {
	return 0, fmt.Errorf("unable to get inode os not supported")

// unless that metadata is needed in order to allow a subsequent data retrieval
// to  be  correctly  handled.   For example, changes to st_atime or st_mtime
// (respectively, time of last access and time of last modification; see inode(7))
// do not require flushing because they are not necessary for a subsequent data
// read to be handled correctly. On the other hand, a change to the file size

	// Get the quota-based storage consumption for the path
	GetConsumption(path string) (*resource.Quantity, error)

	// Get the quota-based inode consumption for the path
	GetInodes(path string) (*resource.Quantity, error)

	// Remove the quota from a path
	// Implementations may assume that any data covered by the
	// quota has already been removed.

		}
		next()          // dev
		inode := next() // inode
		if line == nil {
			continue
		}
		file := string(line)

		// Trim deleted file marker.
		deletedStr := " (deleted)"
		deletedLen := len(deletedStr)
		if len(file) >= deletedLen && file[len(file)-deletedLen:] == deletedStr {
			file = file[:len(file)-deletedLen]
		}

		if len(inode) == 1 && inode[0] == '0' && file == "" {

	procGetDiskFreeSpaceEx = modkernel32.NewProc("GetDiskFreeSpaceExW")
)

type UsageInfo struct {
	Bytes  int64
	Inodes int64
}

// Info returns (available bytes, byte capacity, byte usage, total inodes, inodes free, inode usage, error)
// for the filesystem that path resides upon.
func Info(path string) (int64, int64, int64, int64, int64, int64, error) {

	}

	inodes, _ := fsquota.GetInodes(path)
	if inodes != nil {
		usage.Inodes = inodes.Value()
	}

	if inodes != nil && consumption != nil {
		return usage, nil
	}

	topLevelStat := &unix.Stat_t{}
	err := unix.Stat(path, topLevelStat)
	if err != nil {
		return usage, err
	}

	// dedupedInode stores inodes that could be duplicates (nlink > 1)

			if errno == syscall.EINTR {
				continue
			}
			return names, dirents, infos, &PathError{Op: "readdir", Path: f.name, Err: errno}
		}
		if entptr == nil { // EOF
			break
		}
		// Darwin may return a zero inode when a directory entry has been
		// deleted but not yet removed from the directory. The man page for
		// getdirentries(2) states that programs are responsible for skipping
		// those entries:
		//

func (fs *fileStat) IsDir() bool  { return fs.Mode().IsDir() }

// SameFile reports whether fi1 and fi2 describe the same file.
// For example, on Unix this means that the device and inode fields
// of the two underlying structures are identical; on other systems
// the decision may be based on the path names.
// SameFile only applies to results returned by this package's [Stat].
// It returns false in other cases.

	f2 := mustOpen(t, f.Name())
	defer f2.Close()

	doUnlockTF := false
	switch runtime.GOOS {
	case "aix", "solaris":
		// When using POSIX locks (as on Solaris), we can't safely read-lock the
		// same inode through two different descriptors at the same time: when the
		// first descriptor is closed, the second descriptor would still be open but
		// silently unlocked. So a second RLock must block instead of proceeding.