testServer := httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
		res.WriteHeader(http.StatusOK)
		res.Write([]byte("server happy"))
	}))
	defer func() { testServer.Close() }()

	cniC := fakeCNIEventClient(testServer.URL)

	err := PushCNIEvent(cniC, fakeCmdArgs, []*cniv1.IPConfig{&fakePrevResultIPConfig}, "testpod", "testns")

	assert.NoError(t, err)
}

	ctx, cancel := context.WithCancel(context.Background())

	dm.m.Lock()
	dm.cancelRefresh = cancel
	dm.m.Unlock()

	go func() {
		defer cancel()

		refreshTimer := time.NewTimer(dm.refreshInterval)
		defer refreshTimer.Stop()

		for {
			select {
			case <-ctx.Done():
				return
			case <-refreshTimer.C:
				noQuorum, err := refreshLock(ctx, dm.clnt, id, source, quorum)

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()
	objLayer, disks, err := prepareTestBackend(ctx, instanceType)
	if err != nil {
		b.Fatalf("Failed obtaining Temp Backend: <ERROR> %s", err)
	}
	// cleaning up the backend by removing all the directories and files created on function return.
	defer removeRoots(disks)

	// uses *testing.B and the object Layer to run the benchmark.

func testServicesCmdHandler(cmd cmdType, t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	adminTestBed, err := prepareAdminErasureTestBed(ctx)
	if err != nil {
		t.Fatal("Failed to initialize a single node Erasure backend for admin handler tests.", err)
	}
	defer adminTestBed.TearDown()

	// Initialize admin peers to make admin RPC calls. Note: In a

	return &targetsList{}
}

func (tl *targetsList) get() []Target {
	tl.mu.RLock()
	defer tl.mu.RUnlock()

	return tl.list
}

func (tl *targetsList) add(t Target) {
	tl.mu.Lock()
	defer tl.mu.Unlock()

	tl.list = append(tl.list, t)
}

func (tl *targetsList) set(tgts []Target) {
	tl.mu.Lock()
	defer tl.mu.Unlock()

	tl.list = tgts
}

var (

// as an error to be reported.
func ReadFileWithFileInfo(name string) ([]byte, fs.FileInfo, error) {
	f, err := OsOpenFile(name, readMode, 0o666)
	if err != nil {
		return nil, nil, err
	}
	defer f.Close()

	st, err := f.Stat()
	if err != nil {
		return nil, nil, err
	}

	dst := make([]byte, st.Size())
	_, err = io.ReadFull(f, dst)
	return dst, st, err
}

func TestCopyAligned(t *testing.T) {
	f, err := os.CreateTemp("", "")
	if err != nil {
		t.Errorf("Error creating tmp file: %v", err)
	}
	defer f.Close()
	defer os.Remove(f.Name())

	r := strings.NewReader("hello world")

	bufp := ODirectPoolSmall.Get().(*[]byte)
	defer ODirectPoolSmall.Put(bufp)

	written, err := CopyAligned(f, io.LimitReader(r, 5), *bufp, r.Size(), f)
	if !errors.Is(err, io.ErrUnexpectedEOF) {

// Enabled - indicates if callhome is enabled or not
func (c *Config) Enabled() bool {
	configLock.RLock()
	defer configLock.RUnlock()

	return c.Enable
}

// FrequencyDur - returns the currently configured callhome frequency
func (c *Config) FrequencyDur() time.Duration {
	configLock.RLock()
	defer configLock.RUnlock()

	if c.Frequency == 0 {
		return callhomeCycleDefault
	}

	return c.Frequency
}

		fd, err = openFileWithFD(dirPath, os.O_RDONLY, 0o666)
		if err != nil {
			return nil, osErrToFileErr(err)
		}
	}
	defer syscall.Close(fd)

	bufp := direntPool.Get().(*[]byte)
	defer direntPool.Put(bufp)
	buf := *bufp

	nameTmp := direntNamePool.Get().(*[]byte)
	defer direntNamePool.Put(nameTmp)
	tmp := *nameTmp

	boff := 0 // starting read position in buf
	nbuf := 0 // end valid data in buf

	currentMinute    serviceRTTMinuteStats
}

func (h *metrics) setConnSuccess(reqStartTime time.Time) {
	h.Lock()
	defer h.Unlock()
	h.LastCheckSuccess = reqStartTime
}

func (h *metrics) setConnFailure(reqStartTime time.Time) {
	h.Lock()
	defer h.Unlock()
	h.LastCheckFailure = reqStartTime
}

func (h *metrics) updateLastFullMinute(currReqMinute time.Time) {