}
}

func TestMapValueNotEqual(t *testing.T) {
	mv := NewMapValue()
	name := NewField(1, "name")
	name.Ref = testValue(t, 2, "alert")
	priority := NewField(3, "priority")
	priority.Ref = testValue(t, 4, int64(4))
	mv.AddField(name)
	mv.AddField(priority)

	mv2 := NewMapValue()
	mv2.AddField(name)
	if mv.Equal(mv2) != types.False {

	}

	// Manually constructed instance of the schema.
	name := apiservercel.NewField(1, "name")
	name.Ref = testValue(t, 2, "test-instance")
	nestedVal := apiservercel.NewMapValue()
	flags := apiservercel.NewField(5, "flags")
	flagsVal := apiservercel.NewMapValue()
	myFlag := apiservercel.NewField(6, "my_flag")
	myFlag.Ref = testValue(t, 7, true)
	flagsVal.AddField(myFlag)
	flags.Ref = testValue(t, 8, flagsVal)

	"k8s.io/apiserver/pkg/cel/environment"
)

func TestLazyMapType(t *testing.T) {
	env, variablesType, err := buildTestEnv()
	if err != nil {
		t.Fatal(err)
	}
	variablesMap := NewMapValue(variablesType)
	activation := &testActivation{variables: variablesMap}

	// add foo as a string
	variablesType.Fields["foo"] = apiservercel.NewDeclField("foo", apiservercel.StringType, true, nil, nil)

	// callbacks are a map of field name to the function that returns the field Val
	callbacks map[string]GetFieldFunc
	// knownValues are registered names, used for iteration
	knownValues []string
}

func NewMapValue(objectType ref.Type) *MapValue {
	return &MapValue{
		typeValue: types.NewTypeValue(objectType.TypeName(), traits.IndexerType|traits.FieldTesterType|traits.IterableType),
		values:    map[string]ref.Val{},

}

type compositionContext struct {
	context.Context

	compositionEnv  *CompositionEnv
	accumulatedCost int64
}

func (c *compositionContext) Variables(activation any) ref.Val {
	lazyMap := lazy.NewMapValue(c.compositionEnv.MapType)
	for name, result := range c.compositionEnv.CompiledVariables {
		accessor := &variableAccessor{
			name:       name,
			result:     result,
			activation: activation,
			context:    c,

	return o.objectType
}

// Value returns the Go-native representation of the object.
func (o *ObjectValue) Value() interface{} {
	return o
}

// NewMapValue returns an empty MapValue.
func NewMapValue() *MapValue {
	return &MapValue{
		structValue: newStructValue(),
	}
}

// MapValue declares an object with a set of named fields whose values are dynamically typed.

	return &DeclType{
		name:         "map",
		KeyType:      key,
		ElemType:     elem,
		MaxElements:  maxProperties,
		celType:      cel.MapType(key.CelType(), elem.CelType()),
		defaultValue: NewMapValue(),
		// a map can always be represented as {} in JSON, so hardcode the min size
		// to 2
		MinSerializedSize: 2,
	}
}

// NewObjectType creates an object type with a qualified name and a set of field declarations.