}

    @VisibleForTesting
    DaemonHealthStats(DaemonRunningStats runningStats, GarbageCollectionInfo gcInfo, GarbageCollectionMonitor gcMonitor) {
        this.runningStats = runningStats;
        this.scheduler = null;
        this.gcInfo = gcInfo;
        this.gcMonitor = gcMonitor;
    }

    @VisibleForTesting
    public GarbageCollectionMonitor getGcMonitor() {
        return gcMonitor;

			if d.class == windows.FileIdBothDirectoryInfo {
				info := (*windows.FILE_ID_BOTH_DIR_INFO)(entry)
				nextEntryOffset = info.NextEntryOffset
				nameslice = unsafe.Slice(&info.FileName[0], info.FileNameLength/2)
			} else {
				info := (*windows.FILE_FULL_DIR_INFO)(entry)
				nextEntryOffset = info.NextEntryOffset
				nameslice = unsafe.Slice(&info.FileName[0], info.FileNameLength/2)
			}
			d.bufp += int(nextEntryOffset)

		return &buf
	},
}

func (d *dirInfo) close() {
	if d.buf != nil {
		dirBufPool.Put(d.buf)
		d.buf = nil
	}
}

func (f *File) readdir(n int, mode readdirMode) (names []string, dirents []DirEntry, infos []FileInfo, err error) {
	// If this file has no dirInfo, create one.
	d := f.dirinfo.Load()
	if d == nil {
		d = new(dirInfo)
		f.dirinfo.Store(d)
	}
	d.mu.Lock()
	defer d.mu.Unlock()

func (m *MockInterface) EXPECT() *MockInterfaceMockRecorder {
	return m.recorder
}

// ContainerFsInfo mocks base method.
func (m *MockInterface) ContainerFsInfo() (v2.FsInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ContainerFsInfo")
	ret0, _ := ret[0].(v2.FsInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ContainerFsInfo indicates an expected call of ContainerFsInfo.

}

func (f *fakeHostStatsProvider) getPodEtcHostsStats(podUID types.UID, rootFsInfo *cadvisorapiv2.FsInfo) (*statsapi.FsStats, error) {
	return nil, fmt.Errorf("not implemented")
}

func fakeMetricsProvidersToStats(metricsProviders []volume.MetricsProvider, rootFsInfo *cadvisorapiv2.FsInfo) (*statsapi.FsStats, error) {
	result := rootFsInfoToFsStats(rootFsInfo)
	for i, metricsProvider := range metricsProviders {

	"io/fs"
	"syscall"
)

func (file *File) readdir(n int, mode readdirMode) (names []string, dirents []DirEntry, infos []FileInfo, err error) {
	// If this file has no dirinfo, create one.
	d := file.dirinfo.Load()
	if d == nil {
		d = new(dirInfo)
		file.dirinfo.Store(d)
	}
	d.mu.Lock()
	defer d.mu.Unlock()

	size := n
	if size <= 0 {
		size = 100
		n = -1
	}
	for n != 0 {
		// Refill the buffer if necessary.

		t.Fatalf("expected error message `%s` but got `%v`", expectedErrMsg, err)
	}

	dir, err := os.MkdirTemp("", "fsinfo")
	assert.NoError(t, err)
	defer os.RemoveAll(dir)

	fsInfo, err := c.GetDirFsInfo(dir)
	assert.NoError(t, err)
	assert.NotZero(t, fsInfo.Capacity)
	assert.NotZero(t, fsInfo.Available)
}

func getClient(t *testing.T) Client {
	f := fakeWinNodeStatsClient{}
	c, err := newClient(f)

#include "tensorflow/core/platform/types.h"

namespace tensorflow {
namespace cc_op {

// String with single fuzzer file content.
string WriteSingleFuzzer(const OpInfo& op_info, bool is_fuzzable);

// Do we have all we need to create a fuzzer
bool OpFuzzingIsOk(const OpInfo& op_info);

}  // namespace cc_op
}  // namespace tensorflow

func walkDeep(root string, walkFunc filepath.WalkFunc) error {
	info, err := os.Lstat(root)
	if err != nil {
		return walkFunc(root, nil, err)
	}
	return walk(root, info, walkFunc)
}

func walk(path string, info os.FileInfo, walkFunc filepath.WalkFunc) error {
	if !info.IsDir() {
		return walkFunc(path, info, nil)
	}
	names, err := readDirNames(path)
	if err != nil {
		return err
	}

	Name     string `json:"name"`
	Revision string `json:"revision"`
	Tag      string `json:"tag,omitempty"`
}

// NsInfo represents namespace related information like pods running there.
// It is used to display data and is exposed for integration tests.
type NsInfo struct {
	Name string             `json:"name,omitempty"`
	Pods []*PodFilteredInfo `json:"pods,omitempty"`
}