p, err := env.Program(ast)
			if err != nil {
				t.Fatal(err)
			}
			ret, _, err := p.Eval(&simpleActivation{
				foo: map[string]any{"foo": "value", "common": 1, "confusion": "114514"},
				bar: map[string]any{"bar": "value", "common": 2, "confusion": 114514},
			})
			if err != nil {
				t.Fatal(err)
			}
			if ret.Type() != types.BoolType {
				t.Errorf("bad result type: %v", ret.Type())
			}

	for _, tc := range []struct {
		name          string
		expression    string
		expectedValue any
	}{
		{
			name:          "not an object",
			expression:    `string(114514)`,
			expectedValue: "114514",
		},
		{
			name:          "empty",
			expression:    "Object{}",
			expectedValue: map[string]any{},
		},
		{
			name:       "Object.spec",

	for _, tc := range []struct {
		name          string
		expression    string
		expectedValue any
	}{
		{
			name:          "not an object",
			expression:    `2 * 31 * 1847`,
			expectedValue: int64(114514), // type resolver should not interfere.
		},
		{
			name:          "empty",
			expression:    "Object{}",
			expectedValue: map[string]any{},
		},
		{
			name:          "Object.spec",

				&testVariable{
					name:       "count",
					expression: "object.subsets[114514].addresses.size()", // array index out of bound
				},
			},
			attributes:           endpointCreateAttributes(),
			expression:           "variables.count == 810",
			expectErr:            true,
			expectedErrorMessage: `composited variable "count" fails to evaluate: index out of bounds: 114514`,
		},
		{
			name: "out of budget during lazy evaluation",

					},
				},
			},
		}},
	}}

	deploymentPolicyWithBadMessageExpression := deploymentPolicy.DeepCopy()
	deploymentPolicyWithBadMessageExpression.Spec.Validations[0].MessageExpression = "object.foo + 114514" // confusion

	multiExpressionPolicy := &v1.ValidatingAdmissionPolicy{Spec: v1.ValidatingAdmissionPolicySpec{
		Validations: []v1.Validation{
			{
				Expression: "object.foo == 'bar'",
			},
			{

					{
						Name:       "foo",
						Expression: "114 + '514'", // compile error: type confusion
					},
				},
				Validations: []admissionregistration.Validation{
					{
						Expression: "true",
					},
				},
			},
		},

Diagnostics from elements:
  for PSI element of type KtConstructorCalleeExpression at (33,2-12)
    NO_VALUE_FOR_PARAMETER      text ranges: [(114,124)]
      PSI: KtConstructorCalleeExpression at (33,2-12)
  for PSI element of type KtNameReferenceExpression at (31,8-10)
    UNRESOLVED_REFERENCE      text ranges: [(93,95)]

        val expected = """
            UnsupportedConstruct(
                languageFeature = RenamingImport,
                potentialElementSource = indexes: 0..13, line/column: 1/1..1/14, file: test,
                erroneousSource = indexes: 9..13, line/column: 1/10..1/14, file: test
            )
            UnsupportedConstruct(
                languageFeature = RenamingImport,

	"k8s.io/apimachinery/pkg/util/wait"
	"k8s.io/klog/v2"
)

const (
	// Amount of time to wait between attempting to use a Unix domain socket.
	// As detailed in https://github.com/kubernetes/kubernetes/issues/104584
	// the first attempt will most likely fail, hence the need to retry
	socketDialRetryPeriod = 1 * time.Second
	// Overall timeout value to dial a Unix domain socket, including retries
	socketDialTimeout = 4 * time.Second
)

}

// This is required as on Windows it's possible for the socket file backing a Unix domain socket to
// exist but not be ready for socket communications yet as per
// https://github.com/kubernetes/kubernetes/issues/104584
func TestPendingUnixDomainSocket(t *testing.T) {
	// Create a temporary file that will simulate the Unix domain socket file in a
	// not-yet-ready state. We need this because the Kubelet keeps an eye on file