ctx := genericapirequest.NewDefaultContext()
		resourceClassParameters := resourceClassParameters.DeepCopy()
		newObj := resourceClassParameters.DeepCopy()
		newObj.Name += "-2"
		newObj.ResourceVersion = "4"

		Strategy.PrepareForUpdate(ctx, newObj, resourceClassParameters)
		errs := Strategy.ValidateUpdate(ctx, newObj, resourceClassParameters)
		if len(errs) == 0 {
			t.Errorf("expected a validation error")
		}
	})

		resource    schema.GroupVersionResource
		subresource string
		oldObj      runtime.Object
		newObj      runtime.Object

		checkError func(error) bool
	}{
		{
			name:       "super-user, create, no objectref change",
			username:   "super",
			resource:   api.SchemeGroupVersion.WithResource("pods"),
			newObj:     &api.Pod{},
			checkError: expectNoError,
		},
		{

	verify(ktesting.WithStep(tCtx, "after nop add"), cache, key, newObj, newObj)
	informer.add(nil)
	verify(ktesting.WithStep(tCtx, "after nil add"), cache, key, newObj, newObj)
	informer.update(oldObj)
	verify(ktesting.WithStep(tCtx, "after nop update"), cache, key, newObj, newObj)
	informer.update(nil)
	verify(ktesting.WithStep(tCtx, "after nil update"), cache, key, newObj, newObj)
	informer.delete(nil)

	newObj := &networking.ServiceCIDR{
		Spec: networking.ServiceCIDRSpec{
			CIDRs: []string{"10.10.0.0/16"},
		},
	}
	StatusStrategy.PrepareForUpdate(context.TODO(), newObj, oldObj)
	if !reflect.DeepEqual(newObj.Spec, networking.ServiceCIDRSpec{}) {
		t.Errorf("Expected spec field to be preserved from old object during status update")
	}

	newObj = &networking.ServiceCIDR{

		ctx := genericapirequest.NewDefaultContext()
		resourceClaimParameters := resourceClaimParameters.DeepCopy()
		newObj := resourceClaimParameters.DeepCopy()
		newObj.Name += "-2"
		newObj.ResourceVersion = "4"

		Strategy.PrepareForUpdate(ctx, newObj, resourceClaimParameters)
		errs := Strategy.ValidateUpdate(ctx, newObj, resourceClaimParameters)
		if len(errs) == 0 {
			t.Errorf("expected a validation error")
		}
	})

	defer func() {
		NowFunc = metav1.Now
	}()
	tests := []struct {
		name        string
		fg          bool
		newObj      *api.PersistentVolume
		expectedObj *api.PersistentVolume
	}{
		{
			name: "feature enabled: pv is in pending phase and has a timestamp",
			fg:   true,
			newObj: &api.PersistentVolume{
				ObjectMeta: metav1.ObjectMeta{
					Name: "foo",
				},
			},

		pod          *v1.Pod
		oldObj       interface{}
		newObj       interface{}
		expectedHint framework.QueueingHint
		wantErr      bool
	}{
		{
			name:         "backoff-wrong-new-object",
			newObj:       "not-a-node",
			expectedHint: framework.Queue,
			wantErr:      true,
		},
		{
			name:         "backoff-wrong-old-object",

			if oldObj == nil {
				return
			}
			newObj := ExtractObject(newInterface)
			if newObj == nil {
				return
			}
			if onlyIncludeSpecChanges && oldObj.GetResourceVersion() == newObj.GetResourceVersion() {
				return
			}
			newer := filter(newObj)
			older := filter(oldObj)
			if !newer && !older {
				return
			}
			handler(newObj)
		},
		DeleteFunc: single,
	}
}

		c.queue.Add(key)
	}

	registration, err := c.informer.AddEventHandler(cache.ResourceEventHandlerDetailedFuncs{
		AddFunc: enqueue,
		UpdateFunc: func(oldObj, newObj interface{}) {
			oldMeta, err1 := meta.Accessor(oldObj)
			newMeta, err2 := meta.Accessor(newObj)

			if err1 != nil || err2 != nil {
				if err1 != nil {
					utilruntime.HandleError(err1)
				}

				if err2 != nil {

func (c *EndpointSliceConfig) handleUpdateEndpointSlice(oldObj, newObj interface{}) {
	oldEndpointSlice, ok := oldObj.(*discoveryv1.EndpointSlice)
	if !ok {
		utilruntime.HandleError(fmt.Errorf("unexpected object type: %T", newObj))
		return
	}
	newEndpointSlice, ok := newObj.(*discoveryv1.EndpointSlice)
	if !ok {
		utilruntime.HandleError(fmt.Errorf("unexpected object type: %T", newObj))
		return
	}
	for _, h := range c.eventHandlers {