"small": 500,
	}, map[string]interface{}{
		"small": 501,
	}, validation.WithRatcheting(nil)).IsValid())
}

// Shows schemas with object fields which themselves are ratcheted can be ratcheted
func TestObjectObjectFieldsRatcheting(t *testing.T) {
	validator := validation.NewRatchetingSchemaValidator(objectObjectSchema, nil, "", strfmt.Default)
	assert.True(t, validator.ValidateUpdate(map[string]interface{}{

						}}},
				expectError{
					applyPatchOperation{
						"revert minFIeld to previously ratcheted value",
						myCRDV1Beta1, myCRDInstanceName, map[string]interface{}{
							"minField": "value",
						}}},
				expectError{
					applyPatchOperation{
						"revert maxField to previously ratcheted value",
						myCRDV1Beta1, myCRDInstanceName, map[string]interface{}{
							"maxField": "valueThatsVeryLongSee",

	// which was correlatable. If the parent is deepequal to its old value,
	// then errors thrown by this node are ratcheted
	nearestParentCorrelation *common.CorrelatedObject
}

// shouldRatchetError returns true if the errors raised by the current node
// should be ratcheted.
//
// Errors for the current node should be ratcheted if one of the following is true:
//  1. The current node is correlatable, and it is equal to its old value

        	apiextensions_apiserver_validation_ratcheting_seconds_sum 1.0000000000000002e-08
        	apiextensions_apiserver_validation_ratcheting_seconds_count 10
			`,
			iters: 10,
		},
		{
			desc: "ratcheted change object yields metrics",
			obj: &unstructured.Unstructured{
				Object: map[string]interface{}{
					"foo": "bar",
				},
			},
			old: &unstructured.Unstructured{
				Object: map[string]interface{}{

					mapField:
						bar: notbaz
						otherBar: otherBaz
			`),
			errors: []string{
				// Didn't get ratcheted because we changed its value from baz to notbaz
				`root.mapField.foo: Invalid value: "string": gotta be baz`,
			},
			warnings: []string{
				// Ratcheted because its value remained the same, even though it is invalid
				`root.mapField.mapField.bar: Invalid value: "string": gotta be baz`,
			},

type SchemaCreateValidator interface {
	Validate(value interface{}, options ...ValidationOption) *validate.Result
}

type ValidationOptions struct {
	// Whether errors from unchanged portions of the schema should be ratcheted
	// 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

	s := validate.NewSchemaValidator(r.schema, r.root, r.path, r.knownFormats, opts...)

	res := s.Validate(r.correlation.Value)

	if res.IsValid() {
		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
}