return res
	}

	// Current ratcheting rule is to ratchet errors if DeepEqual(old, new) is true.
	if r.correlation.CachedDeepEqual() {
		newRes := &validate.Result{}
		newRes.MergeAsWarnings(res)
		return newRes
	}

	return res
}

// SubPropertyValidator overrides the standard validator constructor for sub-properties by
// returning our special ratcheting variant.
//

	}{
		{
			name:             "Ratcheting, For creation, FG disabled, no OptionalOldSelf, no field drop",
			enableRatcheting: false,
			crd:              &apiextensions.CustomResourceDefinition{},
			oldCRD:           nil,
			expectedCRD:      &apiextensions.CustomResourceDefinition{},
		},
		{
			name:             "Ratcheting, For creation, FG disabled, set OptionalOldSelf, drop OptionalOldSelf",

						},
					}},
				applyPatchOperation{
					"add new field `otherField`, ratcheting `minField` and `maxField`",
					myCRDV1Beta1, myCRDInstanceName, map[string]interface{}{
						"minField":   "value",
						"maxField":   "valueThatsVeryLongSee",
						"otherField": "otherValue",
					}},
				applyPatchOperation{
					"make minField valid, ratcheting old value for maxField",
					myCRDV1Beta1, myCRDInstanceName, map[string]interface{}{

	// This field is ignored for Validate
	Ratcheting bool

	// Correlation between old and new arguments.
	// If set, this is expected to be the correlation between the `new` and
	// `old` arguments to ValidateUpdate, and values for `new` and `old` will
	// be taken from the correlation.
	//
	// This field is ignored for Validate
	//
	// Used for ratcheting, but left as a separate field since it may be used

func init() {
	legacyregistry.MustRegister(Metrics.(*validationMetrics).RatchetingTime)
}

type validationMetrics struct {
	RatchetingTime *metrics.Histogram
}

// ObserveRatchetingTime records the time spent on ratcheting
func (m *validationMetrics) ObserveRatchetingTime(d time.Duration) {
	m.RatchetingTime.Observe(d.Seconds())
}

// Reset resets the metrics. This is meant to be used for testing. Panics

		// We might be able to support this, but do not currently see a lot
		// of value
		// (would allow you to add/remove items from sets with ratcheting but not change them)
		return nil
	case "":
		fallthrough
	case "atomic":
		// Atomic lists are the default are not correlatable by item
		// Ratcheting is not available on a per-index basis
		return nil
	default:
		// Unrecognized list type. Assume non-correlatable.
		return nil

	}

	var errs field.ErrorList
	errs = append(errs, a.customResourceStrategy.validator.ValidateStatusUpdate(ctx, uNew, uOld, a.scale)...)

	// ratcheting validation of x-kubernetes-list-type value map and set
	if newErrs := structurallisttype.ValidateListSetsAndMaps(nil, a.structuralSchema, uNew.Object); len(newErrs) > 0 {

				allErrs = append(allErrs, celErrs...)

				if len(celErrs) == 0 && utilfeature.DefaultFeatureGate.Enabled(apiextensionsfeatures.CRDValidationRatcheting) {
					// If ratcheting is enabled some CEL rules may use optionalOldSelf
					// For such rules the above validation is not sufficient for
					// determining if the default value is a valid value to introduce

}

// Finds the next node following the field in the tree and returns options using
// that node. If none could be found, then retains a reference to the last
// correlatable ancestor for ratcheting purposes
func (r ratchetingOptions) key(field string) ratchetingOptions {
	if r.currentCorrelation == nil {
		return r
	} else if r.nearestParentCorrelation == nil && (field == "apiVersion" || field == "kind") {

		return err
	})
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	t.Logf("Updating again with invalid values, eventually successfully due to ratcheting logic")
	err = wait.PollImmediate(time.Millisecond*100, wait.ForeverTestTimeout, func() (bool, error) {
		_, err = fooClient.Update(context.TODO(), modifiedInstance, metav1.UpdateOptions{})
		if err == nil {