Operation string `json:"operation"`

	// Object is the object from the incoming request.
	Object runtime.RawExtension `json:"object,omitempty"`

	// OldObject is the existing object. Only populated for DELETE and UPDATE requests.
	OldObject runtime.RawExtension `json:"oldObject,omitempty"`

	// DryRun indicates that modifications will definitely not be persisted for this request.
	// Defaults to false.

		resource:            resource,
		subresource:         subresource,
		operation:           operation,
		options:             operationOptions,
		dryRun:              dryRun,
		object:              object,
		oldObject:           oldObject,
		userInfo:            userInfo,
		reinvocationContext: &reinvocationContext{},
	}
}

func (record *attributesRecord) GetKind() schema.GroupVersionKind {
	return record.kind
}

		*out = new(v1.GroupVersionResource)
		**out = **in
	}
	in.UserInfo.DeepCopyInto(&out.UserInfo)
	if in.Object != nil {
		out.Object = in.Object.DeepCopyObject()
	}
	if in.OldObject != nil {
		out.OldObject = in.OldObject.DeepCopyObject()
	}
	if in.DryRun != nil {
		in, out := &in.DryRun, &out.DryRun
		*out = new(bool)
		**out = **in
	}
	if in.Options != nil {
		out.Options = in.Options.DeepCopyObject()

			hasParams:        false,
		},
		{
			name:        "oldObject comparison",
			expressions: []string{"object.foo == oldObject.foo"},
		},
		{
			name: "object null checks",
			// since object and oldObject are CEL variable, has() cannot be used (it works only on fields),
			// so we always populate it to allow for a null check in the case of CREATE, where oldObject is
			// null, and DELETE, where object is null.

	compiler Compiler
}

func NewFilterCompiler(env *environment.EnvSet) FilterCompiler {
	return &filterCompiler{compiler: NewCompiler(env)}
}

type evaluationActivation struct {
	object, oldObject, params, request, namespace, authorizer, requestResourceAuthorizer, variables interface{}
}

// ResolveName returns a value from the activation by qualified name, or false if the name
// could not be found.

			results: []EvaluationResult{
				{
					EvalResult: celtypes.True,
				},
			},
			hasParamKind: false,
		},
		{
			name: "valid syntax for oldObject",
			validations: []ExpressionAccessor{
				&condition{
					Expression: "oldObject == null",
				},
				&condition{
					Expression: "object != null",
				},
			},
			attributes: newValidAttribute(nil, false),
			results: []EvaluationResult{

	}
}

func TestLargeLastApplied(t *testing.T) {
	tests := []struct {
		name      string
		oldObject *unstructured.Unstructured
		newObject *unstructured.Unstructured
	}{
		{
			name: "old object + new object last-applied annotation is too big",
			oldObject: func() *unstructured.Unstructured {
				u := &unstructured.Unstructured{}
				err := json.Unmarshal([]byte(`
{
   "metadata": {

    version: versionValue
  name: nameValue
  namespace: namespaceValue
  object:
    apiVersion: example.com/v1
    kind: CustomType
    spec:
      replicas: 1
    status:
      available: 1
  oldObject:
    apiVersion: example.com/v1
    kind: CustomType
    spec:
      replicas: 1
    status:
      available: 1
  operation: operationValue
  options:
    apiVersion: example.com/v1
    kind: CustomType

		return err
	}
	if err := runtime.Convert_runtime_RawExtension_To_runtime_Object(&in.Object, &out.Object, s); err != nil {
		return err
	}
	if err := runtime.Convert_runtime_RawExtension_To_runtime_Object(&in.OldObject, &out.OldObject, s); err != nil {
		return err
	}
	out.DryRun = (*bool)(unsafe.Pointer(in.DryRun))
	if err := runtime.Convert_runtime_RawExtension_To_runtime_Object(&in.Options, &out.Options, s); err != nil {
		return err
	}

		return err
	}
	if err := runtime.Convert_runtime_RawExtension_To_runtime_Object(&in.Object, &out.Object, s); err != nil {
		return err
	}
	if err := runtime.Convert_runtime_RawExtension_To_runtime_Object(&in.OldObject, &out.OldObject, s); err != nil {
		return err
	}
	out.DryRun = (*bool)(unsafe.Pointer(in.DryRun))
	if err := runtime.Convert_runtime_RawExtension_To_runtime_Object(&in.Options, &out.Options, s); err != nil {
		return err
	}