finished: false,
				fullname: "fake-fullname",
			},
			startedStaticPodsByFullname: make(map[string]types.UID),
			waitingToStartStaticPodsByFullname: map[string][]types.UID{
				"fake-fullname": {podUID},
			},
			removed: false,
		},
		{
			desc: "orphaned not started worker",
			podSyncStatus: &podSyncStatus{
				finished: false,
				fullname: "fake-fullname",
			},
			orphan:  true,

	if c.dataqsiz == 0 {
		if raceenabled {
			racesync(c, sg)
		}
		if ep != nil {
			// copy data from sender
			recvDirect(c.elemtype, sg, ep)
		}
	} else {
		// Queue is full. Take the item at the
		// head of the queue. Make the sender enqueue
		// its item at the tail of the queue. Since the
		// queue is full, those are both the same slot.
		qp := chanbuf(c, c.recvx)
		if raceenabled {
			racenotify(c, c.recvx, nil)

	// scheduled time).

	// Add the just-started job to the status list.
	jobRef, err := getRef(jobResp)
	if err != nil {
		logger.V(2).Info("Unable to make object reference", "cronjob", klog.KObj(cronJob), "err", err)
		return nil, updateStatus, fmt.Errorf("unable to make object reference for job for %s", klog.KObj(cronJob))
	}
	cronJob.Status.Active = append(cronJob.Status.Active, *jobRef)

	t.Helper()

	tc := &testContext{}
	tCtx := ktesting.Init(t)
	tc.ctx = tCtx

	tc.client = fake.NewSimpleClientset(objs...)
	reactor := createReactor(tc.client.Tracker())
	tc.client.PrependReactor("*", "*", reactor)

	// Quick-and-dirty workaround for fake client storing ResourceClassParameters and
	// ResourceClaimParameters as "resourceclassparameterses" and "resourceclaimparameterses":

	// let both patches fail. The rs controller will assume it fails to take
	// control of the pods and requeue to try again.
	fakePodControl.Err = fmt.Errorf("fake Error")
	rsKey := GetKey(rs, t)
	err := processSync(ctx, manager, rsKey)
	if err == nil || !strings.Contains(err.Error(), "fake Error") {
		t.Errorf("expected fake Error, got %+v", err)
	}
	// 2 patches to take control of pod1 and pod2 (both fail).

	"sync"
	"sync/atomic"
	"testing"
	"time"
	"unsafe"
)

func prepareAllMetricsSamples() (map[string]metrics.Description, []metrics.Sample) {
	all := metrics.All()
	samples := make([]metrics.Sample, len(all))
	descs := make(map[string]metrics.Description)
	for i := range all {
		samples[i].Name = all[i].Name
		descs[all[i].Name] = all[i]
	}
	return descs, samples
}

func TestReadMetrics(t *testing.T) {

	return a[i].String() < a[j].String()
}
func (a byAddress) Swap(i, j int) {
	a[i], a[j] = a[j], a[i]
}

// NewFake creates a fake ipvs implementation - a cache store.
func NewFake() *FakeIPVS {
	return &FakeIPVS{
		Services:     make(map[ServiceKey]*utilipvs.VirtualServer),
		Destinations: make(map[ServiceKey][]*utilipvs.RealServer),
	}
}

func toServiceKey(serv *utilipvs.VirtualServer) ServiceKey {
	return ServiceKey{

		// now that we can skip scalar portions pretty efficiently?
		scanSize = addr - b + goarch.PtrSize

		// Work here is duplicated in scanblock and above.
		// If you make changes here, make changes there too.
		obj := *(*uintptr)(unsafe.Pointer(addr))

		// At this point we have extracted the next potential pointer.
		// Quickly filter out nil and pointers back to the current object.

	// Out of free connections or we were asked not to use one. If we're not
	// allowed to open any more connections, make a request and wait.
	if db.maxOpen > 0 && db.numOpen >= db.maxOpen {
		// Make the connRequest channel. It's buffered so that the
		// connectionOpener doesn't block while waiting for the req to be read.
		req := make(chan connRequest, 1)
		delHandle := db.connRequests.Add(req)
		db.waitCount++
		db.mu.Unlock()

func NewFake() *FakeInterface {
	fake := &FakeInterface{}
	fake.Reset()
	return fake
}

// Reset clears fake's sets/maps
func (fake *FakeInterface) Reset() {
	fake.ClearedIPs = sets.New[string]()
	fake.ClearedPorts = sets.New[int]()
	fake.ClearedNATs = make(map[string]string)
	fake.ClearedPortNATs = make(map[int]string)
}

// ClearEntriesForIP is part of Interface