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() {

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

			"the storageclass that provisions the pvc must support resize")
	}
	tests := []struct {
		name        string
		resource    schema.GroupVersionResource
		subresource string
		oldObj      runtime.Object
		newObj      runtime.Object

		checkError func(error) bool
	}{
		{
			name:     "pvc-resize, update, no error",
			resource: api.SchemeGroupVersion.WithResource("persistentvolumeclaims"),

		if len(accessor.GetUID()) == 0 {
			if f.probability <= rand.Float32() {
				return newObj, managed, nil
			}
		} else {
			return newObj, managed, nil
		}
	}
	return f.fieldManager.Update(liveObj, newObj, managed, manager)
}

// Apply implements Manager.