interpreter/attribute_patterns_test.go - external/github.com/google/cel-go - Git at Google

 // Copyright 2020 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package interpreter

 import (
 	"fmt"
 	"testing"

 	"github.com/google/cel-go/common/containers"
 	"github.com/google/cel-go/common/types"
 )

 // attr describes a simplified format for specifying common Attribute and Qualifier values for
 // use in pattern matching tests.
 type attr struct {
 	// unchecked indicates whether the attribute has not been type-checked and thus not gone
 	// the variable and function resolution step.
 	unchecked bool
 	// container simulates the expression container and is only relevant on 'unchecked' test inputs
 	// as the container is used to resolve the potential fully qualified variable names represented
 	// by an identifier or select expression.
 	container string
 	// variable name, fully qualified unless the attr is marked as unchecked=true
 	name string
 	// quals contains a list of static qualifiers.
 	quals []any
 }

 // patternTest describes a pattern, and a set of matches and misses for the pattern to highlight
 // what the pattern will and will not match.
 type patternTest struct {
 	pattern *AttributePattern
 	matches []attr
 	misses  []attr
 }

 var patternTests = map[string]patternTest{
 	"var": {
 		pattern: NewAttributePattern("var"),
 		matches: []attr{
 			{name: "var"},
 			{name: "var", quals: []any{"field"}},
 		},
 		misses: []attr{
 			{name: "ns.var"},
 		},
 	},
 	"var_namespace": {
 		pattern: NewAttributePattern("ns.app.var"),
 		matches: []attr{
 			{name: "ns.app.var"},
 			{name: "ns.app.var", quals: []any{int64(0)}},
 			{
 				name:      "ns",
 				quals:     []any{"app", "var", "foo"},
 				container: "ns.app",
 				unchecked: true,
 			},
 		},
 		misses: []attr{
 			{name: "ns.var"},
 			{
 				name:      "ns",
 				quals:     []any{"var"},
 				container: "ns.app",
 				unchecked: true,
 			},
 		},
 	},
 	"var_field": {
 		pattern: NewAttributePattern("var").QualString("field"),
 		matches: []attr{
 			{name: "var"},
 			{name: "var", quals: []any{"field"}},
 			{name: "var", quals: []any{"field"}, unchecked: true},
 			{name: "var", quals: []any{"field", uint64(1)}},
 		},
 		misses: []attr{
 			{name: "var", quals: []any{"other"}},
 		},
 	},
 	"var_index": {
 		pattern: NewAttributePattern("var").QualInt(0),
 		matches: []attr{
 			{name: "var"},
 			{name: "var", quals: []any{int64(0)}},
 			{name: "var", quals: []any{float64(0)}},
 			{name: "var", quals: []any{int64(0), false}},
 			{name: "var", quals: []any{uint64(0)}},
 		},
 		misses: []attr{
 			{name: "var", quals: []any{int64(1), false}},
 		},
 	},
 	"var_index_uint": {
 		pattern: NewAttributePattern("var").QualUint(1),
 		matches: []attr{
 			{name: "var"},
 			{name: "var", quals: []any{uint64(1)}},
 			{name: "var", quals: []any{uint64(1), true}},
 			{name: "var", quals: []any{int64(1), false}},
 		},
 		misses: []attr{
 			{name: "var", quals: []any{uint64(0)}},
 		},
 	},
 	"var_index_bool": {
 		pattern: NewAttributePattern("var").QualBool(true),
 		matches: []attr{
 			{name: "var"},
 			{name: "var", quals: []any{true}},
 			{name: "var", quals: []any{true, "name"}},
 		},
 		misses: []attr{
 			{name: "var", quals: []any{false}},
 			{name: "none"},
 		},
 	},
 	"var_wildcard": {
 		pattern: NewAttributePattern("ns.var").Wildcard(),
 		matches: []attr{
 			{name: "ns.var"},
 			// The unchecked attributes consider potential namespacing and field selection
 			// when testing variable names.
 			{
 				name:      "var",
 				quals:     []any{true},
 				container: "ns",
 				unchecked: true,
 			},
 			{
 				name:      "var",
 				quals:     []any{"name"},
 				container: "ns",
 				unchecked: true,
 			},
 			{
 				name:      "var",
 				quals:     []any{"name"},
 				container: "ns",
 				unchecked: true,
 			},
 		},
 		misses: []attr{
 			{name: "var", quals: []any{false}},
 			{name: "none"},
 		},
 	},
 	"var_wildcard_field": {
 		pattern: NewAttributePattern("var").Wildcard().QualString("field"),
 		matches: []attr{
 			{name: "var"},
 			{name: "var", quals: []any{true}},
 			{name: "var", quals: []any{int64(10), "field"}},
 		},
 		misses: []attr{
 			{name: "var", quals: []any{int64(10), "other"}},
 		},
 	},
 	"var_wildcard_wildcard": {
 		pattern: NewAttributePattern("var").Wildcard().Wildcard(),
 		matches: []attr{
 			{name: "var"},
 			{name: "var", quals: []any{true}},
 			{name: "var", quals: []any{int64(10), "field"}},
 		},
 		misses: []attr{
 			{name: "none"},
 		},
 	},
 }

 func TestAttributePattern_UnknownResolution(t *testing.T) {
 	reg := newTestRegistry(t)
 	for nm, tc := range patternTests {
 		tst := tc
 		t.Run(nm, func(t *testing.T) {
 			for i, match := range tst.matches {
 				m := match
 				t.Run(fmt.Sprintf("match[%d]", i), func(t *testing.T) {
 					var err error
 					cont := containers.DefaultContainer
 					if m.unchecked {
 						cont, err = containers.NewContainer(containers.Name(m.container))
 						if err != nil {
 							t.Fatal(err)
 						}
 					}
 					fac := NewPartialAttributeFactory(cont, reg, reg)
 					attr := genAttr(fac, m)
 					partVars, _ := NewPartialActivation(EmptyActivation(), tst.pattern)
 					val, err := attr.Resolve(partVars)
 					if err != nil {
 						t.Fatalf("Got error: %s, wanted unknown", err)
 					}
 					_, isUnk := val.(*types.Unknown)
 					if !isUnk {
 						t.Fatalf("Got value %v, wanted unknown", val)
 					}
 				})
 			}
 			for i, miss := range tst.misses {
 				m := miss
 				t.Run(fmt.Sprintf("miss[%d]", i), func(t *testing.T) {
 					cont := containers.DefaultContainer
 					if m.unchecked {
 						var err error
 						cont, err = containers.NewContainer(containers.Name(m.container))
 						if err != nil {
 							t.Fatal(err)
 						}
 					}
 					fac := NewPartialAttributeFactory(cont, reg, reg)
 					attr := genAttr(fac, m)
 					partVars, _ := NewPartialActivation(EmptyActivation(), tst.pattern)
 					val, err := attr.Resolve(partVars)
 					if err == nil {
 						t.Fatalf("Got value: %s, wanted error", val)
 					}
 				})
 			}
 		})
 	}
 }

 func TestAttributePattern_CrossReference(t *testing.T) {
 	reg := newTestRegistry(t)
 	fac := NewPartialAttributeFactory(containers.DefaultContainer, reg, reg)
 	a := fac.AbsoluteAttribute(1, "a")
 	b := fac.AbsoluteAttribute(2, "b")
 	a.AddQualifier(b)

 	// Ensure that var a[b], the dynamic index into var 'a' is the unknown value
 	// returned from attribute resolution.
 	partVars, _ := NewPartialActivation(
 		map[string]any{"a": []int64{1, 2}},
 		NewAttributePattern("b"))
 	val, err := a.Resolve(partVars)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if !types.NewUnknown(2, types.NewAttributeTrail("b")).Contains(val.(*types.Unknown)) {
 		t.Errorf("Got %v, wanted unknown attribute id for 'b' (2)", val)
 	}

 	// Ensure that a[b], the dynamic index into var 'a' is the unknown value
 	// returned from attribute resolution. Note, both 'a' and 'b' have unknown attribute
 	// patterns specified. This changes the evaluation behavior slightly, but the end
 	// result is the same.
 	partVars, _ = NewPartialActivation(
 		map[string]any{"a": []int64{1, 2}},
 		NewAttributePattern("a").QualInt(0),
 		NewAttributePattern("b"))
 	val, err = a.Resolve(partVars)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if !types.NewUnknown(2, types.NewAttributeTrail("b")).Contains(val.(*types.Unknown)) {
 		t.Errorf("Got %v, wanted unknown attribute id for 'b' (2)", val)
 	}

 	// Note, that only 'a[0].c' will result in an unknown result since both 'a' and 'b'
 	// have values. However, since the attribute being pattern matched is just 'a.b',
 	// the outcome will indicate that 'a[b]' is unknown.
 	partVars, _ = NewPartialActivation(
 		map[string]any{"a": []int64{1, 2}, "b": 0},
 		NewAttributePattern("a").QualInt(0).QualString("c"))
 	val, err = a.Resolve(partVars)
 	if err != nil {
 		t.Fatal(err)
 	}
 	unkAttr := types.NewAttributeTrail("a")
 	types.QualifyAttribute[int64](unkAttr, 0)
 	wantUnk := types.NewUnknown(2, unkAttr)
 	if !wantUnk.Contains(val.(*types.Unknown)) {
 		t.Errorf("Got %v, wanted unknown attribute id for %v", val, wantUnk)
 	}

 	// Test a positive case that returns a valid value even though the attribugte factory
 	// is the partial attribute factory.
 	partVars, _ = NewPartialActivation(
 		map[string]any{"a": []int64{1, 2}, "b": 0})
 	val, err = a.Resolve(partVars)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if val != int64(1) {
 		t.Errorf("Got %v, wanted 1 for a[b]", val)
 	}

 	// Ensure the unknown attribute id moves when the attribute becomes more specific.
 	partVars, _ = NewPartialActivation(
 		map[string]any{"a": []int64{1, 2}, "b": 0},
 		NewAttributePattern("a").QualInt(0).QualString("c"))
 	// Qualify a[b] with 'c', a[b].c
 	c, _ := fac.NewQualifier(nil, 3, "c", false)
 	a.AddQualifier(c)
 	// The resolve step should return unknown
 	val, err = a.Resolve(partVars)
 	if err != nil {
 		t.Fatal(err)
 	}
 	unkAttr = types.NewAttributeTrail("a")
 	types.QualifyAttribute[int64](unkAttr, 0)
 	types.QualifyAttribute[string](unkAttr, "c")
 	wantUnk = types.NewUnknown(3, unkAttr)
 	if !wantUnk.Contains(val.(*types.Unknown)) {
 		t.Errorf("Got %v, wanted unknown attribute id for %v", val, wantUnk)
 	}
 }

 func genAttr(fac AttributeFactory, a attr) Attribute {
 	id := int64(1)
 	var attr Attribute
 	if a.unchecked {
 		attr = fac.MaybeAttribute(1, a.name)
 	} else {
 		attr = fac.AbsoluteAttribute(1, a.name)
 	}
 	for _, q := range a.quals {
 		qual, _ := fac.NewQualifier(nil, id, q, false)
 		attr.AddQualifier(qual)
 		id++
 	}
 	return attr
 }

 func TestAttributePattern_LocallyBound(t *testing.T) {
 	reg := newTestRegistry(t)
 	fac := NewPartialAttributeFactory(containers.DefaultContainer, reg, reg)

 	// Create a partial activation that designates "x" and "y" as unknown.
 	partAct, err := NewPartialActivation(EmptyActivation(), NewAttributePattern("x"), NewAttributePattern("y"))
 	if err != nil {
 		t.Fatal(err)
 	}

 	frame := mustNewExecutionFrame(t, partAct)
 	defer frame.Close()

 	// Create folder (representing a local scope for variable "x" only)
 	fold := &evalFold{
 		iterVar: "x",
 		adapter: types.DefaultTypeAdapter,
 	}
 	fld := newFolder(fold, frame)
 	defer releaseFolder(fld)

 	// Push onto the frame stack to simulate local variable scope
 	frame1 := frame.Push(fld)
 	defer frame1.Pop()

 	// 1. Resolve attribute matching "x".
 	// Because "x" is locally bound in fld, it should not resolve to types.Unknown.
 	attrX := fac.AbsoluteAttribute(1, "x")
 	valX, err := attrX.Resolve(frame1)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if _, isUnk := valX.(*types.Unknown); isUnk {
 		t.Errorf("Resolve(x) got unknown, wanted value (since x is locally bound)")
 	}

 	// 2. Resolve attribute matching "y".
 	// Because "y" is NOT locally bound in any local scope layer, it should resolve to types.Unknown.
 	attrY := fac.AbsoluteAttribute(2, "y")
 	valY, err := attrY.Resolve(frame1)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if _, isUnk := valY.(*types.Unknown); !isUnk {
 		t.Errorf("Resolve(y) got %v, wanted types.Unknown (since y is not locally bound)", valY)
 	}
 }

 func TestQualifierValueEquals(t *testing.T) {
 	tests := []struct {
 		name      string
 		qualifier interface {
 			QualifierValueEquals(any) bool
 		}
 		cases []struct {
 			input any
 			want  bool
 		}
 	}{
 		{
 			name:      "fieldQualifier",
 			qualifier: &fieldQualifier{Name: "foo"},
 			cases: []struct {
 				input any
 				want  bool
 			}{
 				{input: "foo", want: true},
 				{input: "bar", want: false},
 				{input: 123, want: false},
 				{input: true, want: false},
 				{input: nil, want: false},
 			},
 		},
 		{
 			name:      "stringQualifier",
 			qualifier: &stringQualifier{value: "hello"},
 			cases: []struct {
 				input any
 				want  bool
 			}{
 				{input: "hello", want: true},
 				{input: "world", want: false},
 				{input: 123, want: false},
 				{input: nil, want: false},
 			},
 		},
 		{
 			name:      "boolQualifier",
 			qualifier: &boolQualifier{value: true},
 			cases: []struct {
 				input any
 				want  bool
 			}{
 				{input: true, want: true},
 				{input: false, want: false},
 				{input: "true", want: false},
 				{input: 1, want: false},
 				{input: nil, want: false},
 			},
 		},
 		{
 			name:      "intQualifier",
 			qualifier: &intQualifier{celValue: types.Int(42)},
 			cases: []struct {
 				input any
 				want  bool
 			}{
 				{input: int64(42), want: true},
 				{input: int32(42), want: true},
 				{input: uint64(42), want: true},
 				{input: float64(42.0), want: true},
 				{input: types.Int(42), want: true},
 				{input: types.Double(42.0), want: true},
 				{input: int64(100), want: false},
 				{input: "42", want: false},
 				{input: nil, want: false},
 			},
 		},
 		{
 			name:      "uintQualifier",
 			qualifier: &uintQualifier{celValue: types.Uint(100)},
 			cases: []struct {
 				input any
 				want  bool
 			}{
 				{input: uint64(100), want: true},
 				{input: int64(100), want: true},
 				{input: float64(100.0), want: true},
 				{input: types.Uint(100), want: true},
 				{input: uint64(50), want: false},
 				{input: "100", want: false},
 				{input: nil, want: false},
 			},
 		},
 		{
 			name:      "doubleQualifier",
 			qualifier: &doubleQualifier{celValue: types.Double(3.14)},
 			cases: []struct {
 				input any
 				want  bool
 			}{
 				{input: float64(3.14), want: true},
 				{input: types.Double(3.14), want: true},
 				{input: float64(2.71), want: false},
 				{input: int64(3), want: false},
 				{input: "3.14", want: false},
 				{input: nil, want: false},
 			},
 		},
 	}

 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			for _, c := range tc.cases {
 				if got := tc.qualifier.QualifierValueEquals(c.input); got != c.want {
 					t.Errorf("%s.QualifierValueEquals(%v (%T)) = %t, wanted %t", tc.name, c.input, c.input, got, c.want)
 				}
 			}
 		})
 	}
 }

 func TestPartialAttributeFactory_MaybeAttributeGloballyNamespaced(t *testing.T) {
 	reg := newTestRegistry(t)
 	fac := NewPartialAttributeFactory(containers.DefaultContainer, reg, reg)
 	dotAttr := fac.MaybeAttribute(10, ".global_var")
 	if dotAttr == nil {
 		t.Error("MaybeAttribute(.global_var) got nil")
 	}
 }

 func TestPartialAttributeFactory_ResolveUnknownQualifier(t *testing.T) {
 	reg := newTestRegistry(t)
 	fac := NewPartialAttributeFactory(containers.DefaultContainer, reg, reg)
 	partVars, _ := NewPartialActivation(
 		map[string]any{"a": map[string]any{"b": 1}},
 		NewAttributePattern("a").QualString("b"))
 	a := fac.AbsoluteAttribute(1, "a")
 	b, _ := fac.NewQualifier(nil, 2, "b", false)
 	a.AddQualifier(b)
 	val, err := a.Resolve(partVars)
 	if err != nil {
 		t.Fatal(err)
 	}
 	unkVal, ok := val.(*types.Unknown)
 	if !ok {
 		t.Fatalf("Resolve(a.b) got %v (%T), wanted *types.Unknown", val, val)
 	}
 	unkAttr := types.NewAttributeTrail("a")
 	types.QualifyAttribute[string](unkAttr, "b")
 	wantUnk := types.NewUnknown(2, unkAttr)
 	if !wantUnk.Contains(unkVal) {
 		t.Errorf("Resolve(a.b) got unknown %v, wanted %v", unkVal, wantUnk)
 	}
 }
	// Copyright 2020 Google LLC
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package interpreter

	import (
	"fmt"
	"testing"

	"github.com/google/cel-go/common/containers"
	"github.com/google/cel-go/common/types"
	)

	// attr describes a simplified format for specifying common Attribute and Qualifier values for
	// use in pattern matching tests.
	type attr struct {
	// unchecked indicates whether the attribute has not been type-checked and thus not gone
	// the variable and function resolution step.
	unchecked bool
	// container simulates the expression container and is only relevant on 'unchecked' test inputs
	// as the container is used to resolve the potential fully qualified variable names represented
	// by an identifier or select expression.
	container string
	// variable name, fully qualified unless the attr is marked as unchecked=true
	name string
	// quals contains a list of static qualifiers.
	quals []any
	}

	// patternTest describes a pattern, and a set of matches and misses for the pattern to highlight
	// what the pattern will and will not match.
	type patternTest struct {
	pattern *AttributePattern
	matches []attr
	misses []attr
	}

	var patternTests = map[string]patternTest{
	"var": {
	pattern: NewAttributePattern("var"),
	matches: []attr{
	{name: "var"},
	{name: "var", quals: []any{"field"}},
	},
	misses: []attr{
	{name: "ns.var"},
	},
	},
	"var_namespace": {
	pattern: NewAttributePattern("ns.app.var"),
	matches: []attr{
	{name: "ns.app.var"},
	{name: "ns.app.var", quals: []any{int64(0)}},
	{
	name: "ns",
	quals: []any{"app", "var", "foo"},
	container: "ns.app",
	unchecked: true,
	},
	},
	misses: []attr{
	{name: "ns.var"},
	{
	name: "ns",
	quals: []any{"var"},
	container: "ns.app",
	unchecked: true,
	},
	},
	},
	"var_field": {
	pattern: NewAttributePattern("var").QualString("field"),
	matches: []attr{
	{name: "var"},
	{name: "var", quals: []any{"field"}},
	{name: "var", quals: []any{"field"}, unchecked: true},
	{name: "var", quals: []any{"field", uint64(1)}},
	},
	misses: []attr{
	{name: "var", quals: []any{"other"}},
	},
	},
	"var_index": {
	pattern: NewAttributePattern("var").QualInt(0),
	matches: []attr{
	{name: "var"},
	{name: "var", quals: []any{int64(0)}},
	{name: "var", quals: []any{float64(0)}},
	{name: "var", quals: []any{int64(0), false}},
	{name: "var", quals: []any{uint64(0)}},
	},
	misses: []attr{
	{name: "var", quals: []any{int64(1), false}},
	},
	},
	"var_index_uint": {
	pattern: NewAttributePattern("var").QualUint(1),
	matches: []attr{
	{name: "var"},
	{name: "var", quals: []any{uint64(1)}},
	{name: "var", quals: []any{uint64(1), true}},
	{name: "var", quals: []any{int64(1), false}},
	},
	misses: []attr{
	{name: "var", quals: []any{uint64(0)}},
	},
	},
	"var_index_bool": {
	pattern: NewAttributePattern("var").QualBool(true),
	matches: []attr{
	{name: "var"},
	{name: "var", quals: []any{true}},
	{name: "var", quals: []any{true, "name"}},
	},
	misses: []attr{
	{name: "var", quals: []any{false}},
	{name: "none"},
	},
	},
	"var_wildcard": {
	pattern: NewAttributePattern("ns.var").Wildcard(),
	matches: []attr{
	{name: "ns.var"},
	// The unchecked attributes consider potential namespacing and field selection
	// when testing variable names.
	{
	name: "var",
	quals: []any{true},
	container: "ns",
	unchecked: true,
	},
	{
	name: "var",
	quals: []any{"name"},
	container: "ns",
	unchecked: true,
	},
	{
	name: "var",
	quals: []any{"name"},
	container: "ns",
	unchecked: true,
	},
	},
	misses: []attr{
	{name: "var", quals: []any{false}},
	{name: "none"},
	},
	},
	"var_wildcard_field": {
	pattern: NewAttributePattern("var").Wildcard().QualString("field"),
	matches: []attr{
	{name: "var"},
	{name: "var", quals: []any{true}},
	{name: "var", quals: []any{int64(10), "field"}},
	},
	misses: []attr{
	{name: "var", quals: []any{int64(10), "other"}},
	},
	},
	"var_wildcard_wildcard": {
	pattern: NewAttributePattern("var").Wildcard().Wildcard(),
	matches: []attr{
	{name: "var"},
	{name: "var", quals: []any{true}},
	{name: "var", quals: []any{int64(10), "field"}},
	},
	misses: []attr{
	{name: "none"},
	},
	},
	}

	func TestAttributePattern_UnknownResolution(t *testing.T) {
	reg := newTestRegistry(t)
	for nm, tc := range patternTests {
	tst := tc
	t.Run(nm, func(t *testing.T) {
	for i, match := range tst.matches {
	m := match
	t.Run(fmt.Sprintf("match[%d]", i), func(t *testing.T) {
	var err error
	cont := containers.DefaultContainer
	if m.unchecked {
	cont, err = containers.NewContainer(containers.Name(m.container))
	if err != nil {
	t.Fatal(err)
	}
	}
	fac := NewPartialAttributeFactory(cont, reg, reg)
	attr := genAttr(fac, m)
	partVars, _ := NewPartialActivation(EmptyActivation(), tst.pattern)
	val, err := attr.Resolve(partVars)
	if err != nil {
	t.Fatalf("Got error: %s, wanted unknown", err)
	}
	_, isUnk := val.(*types.Unknown)
	if !isUnk {
	t.Fatalf("Got value %v, wanted unknown", val)
	}
	})
	}
	for i, miss := range tst.misses {
	m := miss
	t.Run(fmt.Sprintf("miss[%d]", i), func(t *testing.T) {
	cont := containers.DefaultContainer
	if m.unchecked {
	var err error
	cont, err = containers.NewContainer(containers.Name(m.container))
	if err != nil {
	t.Fatal(err)
	}
	}
	fac := NewPartialAttributeFactory(cont, reg, reg)
	attr := genAttr(fac, m)
	partVars, _ := NewPartialActivation(EmptyActivation(), tst.pattern)
	val, err := attr.Resolve(partVars)
	if err == nil {
	t.Fatalf("Got value: %s, wanted error", val)
	}
	})
	}
	})
	}
	}

	func TestAttributePattern_CrossReference(t *testing.T) {
	reg := newTestRegistry(t)
	fac := NewPartialAttributeFactory(containers.DefaultContainer, reg, reg)
	a := fac.AbsoluteAttribute(1, "a")
	b := fac.AbsoluteAttribute(2, "b")
	a.AddQualifier(b)

	// Ensure that var a[b], the dynamic index into var 'a' is the unknown value
	// returned from attribute resolution.
	partVars, _ := NewPartialActivation(
	map[string]any{"a": []int64{1, 2}},
	NewAttributePattern("b"))
	val, err := a.Resolve(partVars)
	if err != nil {
	t.Fatal(err)
	}
	if !types.NewUnknown(2, types.NewAttributeTrail("b")).Contains(val.(*types.Unknown)) {
	t.Errorf("Got %v, wanted unknown attribute id for 'b' (2)", val)
	}

	// Ensure that a[b], the dynamic index into var 'a' is the unknown value
	// returned from attribute resolution. Note, both 'a' and 'b' have unknown attribute
	// patterns specified. This changes the evaluation behavior slightly, but the end
	// result is the same.
	partVars, _ = NewPartialActivation(
	map[string]any{"a": []int64{1, 2}},
	NewAttributePattern("a").QualInt(0),
	NewAttributePattern("b"))
	val, err = a.Resolve(partVars)
	if err != nil {
	t.Fatal(err)
	}
	if !types.NewUnknown(2, types.NewAttributeTrail("b")).Contains(val.(*types.Unknown)) {
	t.Errorf("Got %v, wanted unknown attribute id for 'b' (2)", val)
	}

	// Note, that only 'a[0].c' will result in an unknown result since both 'a' and 'b'
	// have values. However, since the attribute being pattern matched is just 'a.b',
	// the outcome will indicate that 'a[b]' is unknown.
	partVars, _ = NewPartialActivation(
	map[string]any{"a": []int64{1, 2}, "b": 0},
	NewAttributePattern("a").QualInt(0).QualString("c"))
	val, err = a.Resolve(partVars)
	if err != nil {
	t.Fatal(err)
	}
	unkAttr := types.NewAttributeTrail("a")
	types.QualifyAttribute[int64](unkAttr, 0)
	wantUnk := types.NewUnknown(2, unkAttr)
	if !wantUnk.Contains(val.(*types.Unknown)) {
	t.Errorf("Got %v, wanted unknown attribute id for %v", val, wantUnk)
	}

	// Test a positive case that returns a valid value even though the attribugte factory
	// is the partial attribute factory.
	partVars, _ = NewPartialActivation(
	map[string]any{"a": []int64{1, 2}, "b": 0})
	val, err = a.Resolve(partVars)
	if err != nil {
	t.Fatal(err)
	}
	if val != int64(1) {
	t.Errorf("Got %v, wanted 1 for a[b]", val)
	}

	// Ensure the unknown attribute id moves when the attribute becomes more specific.
	partVars, _ = NewPartialActivation(
	map[string]any{"a": []int64{1, 2}, "b": 0},
	NewAttributePattern("a").QualInt(0).QualString("c"))
	// Qualify a[b] with 'c', a[b].c
	c, _ := fac.NewQualifier(nil, 3, "c", false)
	a.AddQualifier(c)
	// The resolve step should return unknown
	val, err = a.Resolve(partVars)
	if err != nil {
	t.Fatal(err)
	}
	unkAttr = types.NewAttributeTrail("a")
	types.QualifyAttribute[int64](unkAttr, 0)
	types.QualifyAttribute[string](unkAttr, "c")
	wantUnk = types.NewUnknown(3, unkAttr)
	if !wantUnk.Contains(val.(*types.Unknown)) {
	t.Errorf("Got %v, wanted unknown attribute id for %v", val, wantUnk)
	}
	}

	func genAttr(fac AttributeFactory, a attr) Attribute {
	id := int64(1)
	var attr Attribute
	if a.unchecked {
	attr = fac.MaybeAttribute(1, a.name)
	} else {
	attr = fac.AbsoluteAttribute(1, a.name)
	}
	for _, q := range a.quals {
	qual, _ := fac.NewQualifier(nil, id, q, false)
	attr.AddQualifier(qual)
	id++
	}
	return attr
	}

	func TestAttributePattern_LocallyBound(t *testing.T) {
	reg := newTestRegistry(t)
	fac := NewPartialAttributeFactory(containers.DefaultContainer, reg, reg)

	// Create a partial activation that designates "x" and "y" as unknown.
	partAct, err := NewPartialActivation(EmptyActivation(), NewAttributePattern("x"), NewAttributePattern("y"))
	if err != nil {
	t.Fatal(err)
	}

	frame := mustNewExecutionFrame(t, partAct)
	defer frame.Close()

	// Create folder (representing a local scope for variable "x" only)
	fold := &evalFold{
	iterVar: "x",
	adapter: types.DefaultTypeAdapter,
	}
	fld := newFolder(fold, frame)
	defer releaseFolder(fld)

	// Push onto the frame stack to simulate local variable scope
	frame1 := frame.Push(fld)
	defer frame1.Pop()

	// 1. Resolve attribute matching "x".
	// Because "x" is locally bound in fld, it should not resolve to types.Unknown.
	attrX := fac.AbsoluteAttribute(1, "x")
	valX, err := attrX.Resolve(frame1)
	if err != nil {
	t.Fatal(err)
	}
	if _, isUnk := valX.(*types.Unknown); isUnk {
	t.Errorf("Resolve(x) got unknown, wanted value (since x is locally bound)")
	}

	// 2. Resolve attribute matching "y".
	// Because "y" is NOT locally bound in any local scope layer, it should resolve to types.Unknown.
	attrY := fac.AbsoluteAttribute(2, "y")
	valY, err := attrY.Resolve(frame1)
	if err != nil {
	t.Fatal(err)
	}
	if _, isUnk := valY.(*types.Unknown); !isUnk {
	t.Errorf("Resolve(y) got %v, wanted types.Unknown (since y is not locally bound)", valY)
	}
	}

	func TestQualifierValueEquals(t *testing.T) {
	tests := []struct {
	name string
	qualifier interface {
	QualifierValueEquals(any) bool
	}
	cases []struct {
	input any
	want bool
	}
	}{
	{
	name: "fieldQualifier",
	qualifier: &fieldQualifier{Name: "foo"},
	cases: []struct {
	input any
	want bool
	}{
	{input: "foo", want: true},
	{input: "bar", want: false},
	{input: 123, want: false},
	{input: true, want: false},
	{input: nil, want: false},
	},
	},
	{
	name: "stringQualifier",
	qualifier: &stringQualifier{value: "hello"},
	cases: []struct {
	input any
	want bool
	}{
	{input: "hello", want: true},
	{input: "world", want: false},
	{input: 123, want: false},
	{input: nil, want: false},
	},
	},
	{
	name: "boolQualifier",
	qualifier: &boolQualifier{value: true},
	cases: []struct {
	input any
	want bool
	}{
	{input: true, want: true},
	{input: false, want: false},
	{input: "true", want: false},
	{input: 1, want: false},
	{input: nil, want: false},
	},
	},
	{
	name: "intQualifier",
	qualifier: &intQualifier{celValue: types.Int(42)},
	cases: []struct {
	input any
	want bool
	}{
	{input: int64(42), want: true},
	{input: int32(42), want: true},
	{input: uint64(42), want: true},
	{input: float64(42.0), want: true},
	{input: types.Int(42), want: true},
	{input: types.Double(42.0), want: true},
	{input: int64(100), want: false},
	{input: "42", want: false},
	{input: nil, want: false},
	},
	},
	{
	name: "uintQualifier",
	qualifier: &uintQualifier{celValue: types.Uint(100)},
	cases: []struct {
	input any
	want bool
	}{
	{input: uint64(100), want: true},
	{input: int64(100), want: true},
	{input: float64(100.0), want: true},
	{input: types.Uint(100), want: true},
	{input: uint64(50), want: false},
	{input: "100", want: false},
	{input: nil, want: false},
	},
	},
	{
	name: "doubleQualifier",
	qualifier: &doubleQualifier{celValue: types.Double(3.14)},
	cases: []struct {
	input any
	want bool
	}{
	{input: float64(3.14), want: true},
	{input: types.Double(3.14), want: true},
	{input: float64(2.71), want: false},
	{input: int64(3), want: false},
	{input: "3.14", want: false},
	{input: nil, want: false},
	},
	},
	}

	for _, tc := range tests {
	t.Run(tc.name, func(t *testing.T) {
	for _, c := range tc.cases {
	if got := tc.qualifier.QualifierValueEquals(c.input); got != c.want {
	t.Errorf("%s.QualifierValueEquals(%v (%T)) = %t, wanted %t", tc.name, c.input, c.input, got, c.want)
	}
	}
	})
	}
	}

	func TestPartialAttributeFactory_MaybeAttributeGloballyNamespaced(t *testing.T) {
	reg := newTestRegistry(t)
	fac := NewPartialAttributeFactory(containers.DefaultContainer, reg, reg)
	dotAttr := fac.MaybeAttribute(10, ".global_var")
	if dotAttr == nil {
	t.Error("MaybeAttribute(.global_var) got nil")
	}
	}

	func TestPartialAttributeFactory_ResolveUnknownQualifier(t *testing.T) {
	reg := newTestRegistry(t)
	fac := NewPartialAttributeFactory(containers.DefaultContainer, reg, reg)
	partVars, _ := NewPartialActivation(
	map[string]any{"a": map[string]any{"b": 1}},
	NewAttributePattern("a").QualString("b"))
	a := fac.AbsoluteAttribute(1, "a")
	b, _ := fac.NewQualifier(nil, 2, "b", false)
	a.AddQualifier(b)
	val, err := a.Resolve(partVars)
	if err != nil {
	t.Fatal(err)
	}
	unkVal, ok := val.(*types.Unknown)
	if !ok {
	t.Fatalf("Resolve(a.b) got %v (%T), wanted *types.Unknown", val, val)
	}
	unkAttr := types.NewAttributeTrail("a")
	types.QualifyAttribute[string](unkAttr, "b")
	wantUnk := types.NewUnknown(2, unkAttr)
	if !wantUnk.Contains(unkVal) {
	t.Errorf("Resolve(a.b) got unknown %v, wanted %v", unkVal, wantUnk)
	}
	}