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")
		}
	})

// if the non-managed parts of the object are equivalent
func IgnoreManagedFieldsTimestampsTransformer(
	_ context.Context,
	newObj runtime.Object,
	oldObj runtime.Object,
) (res runtime.Object, err error) {
	equalities := getAvoidTimestampEqualities()
	if len(equalities.Equalities) == 0 {
		return newObj, nil
	}

	outcome := "unequal_objects_fast"
	start := time.Now()
	err = nil
	res = nil

	defer func() {

		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)

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

	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{

// object.
func (f *FieldManager) Update(liveObj, newObj runtime.Object, manager string) (object runtime.Object, err error) {
	// First try to decode the managed fields provided in the update,
	// This is necessary to allow directly updating managed fields.
	isSubresource := f.subresource != ""
	managed, err := decodeLiveOrNew(liveObj, newObj, isSubresource)
	if err != nil {
		return newObj, nil
	}

	RemoveObjectManagedFields(newObj)

func DefaultUpdateFilter() func(resource schema.GroupVersionResource, oldObj, newObj interface{}) bool {
	return func(resource schema.GroupVersionResource, oldObj, newObj interface{}) bool {
		switch resource.GroupResource() {
		case schema.GroupResource{Resource: "pods"}:
			oldPod := oldObj.(*v1.Pod)
			newPod := newObj.(*v1.Pod)
			return core.QuotaV1Pod(oldPod, clock.RealClock{}) && !core.QuotaV1Pod(newPod, clock.RealClock{})

		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",
				},
			},