variablesMap.Append("dict", func(_ *MapValue) ref.Val {
		evalCounter++
		v, err := compileAndRun(env, activation, `{"a": "a"}`)
		if err != nil {
			return types.NewErr(err.Error())
		}
		return v
	})

	// iterate the map with .all
	exp = `variables.all(n, n != "")`
	v, err = compileAndRun(env, activation, exp)
	if err != nil {
		t.Fatalf("%q: %v", exp, err)
	}

func (v *ObjectVal) ConvertToType(typeValue ref.Type) ref.Val {
	switch typeValue {
	case v.typeRef:
		return v
	case types.TypeType:
		return v.typeRef.CELType()
	}
	return types.NewErr("unsupported conversion into %v", typeValue)
}

// Equal returns true if the `other` value has the same type and content as the implementing struct.
func (v *ObjectVal) Equal(other ref.Val) ref.Val {

  "reinvocationPolicy" .Values.sidecarInjectorWebhook.reinvocationPolicy
  "namespace" .Release.Namespace }}
{{- define "core" }}
{{- /* Kubernetes unfortunately requires a unique name for the webhook in some newer versions, so we assign
a unique prefix to each. */}}
- name: {{.Prefix}}sidecar-injector.istio.io
  clientConfig:
    {{- if .injectionURL }}
    url: "{{ .injectionURL }}"
    {{- else }}
    service:

			}
			pre = "-" + pre
		}
	}
	vStr := fmt.Sprintf("v%d.%d.%d%s", v.Major(), v.Minor(), patch, pre)
	return vStr, nil
}

// Validate if the remote version is one Minor release newer than the client version.
// This is done to conform with "stable-X" and only allow remote versions from
// the same Patch level release.
func validateStableVersion(remoteVersion, clientVersion string) (string, error) {

			if newObj == nil {
				return
			}
			if onlyIncludeSpecChanges && oldObj.GetResourceVersion() == newObj.GetResourceVersion() {
				return
			}
			newer := filter(newObj)
			older := filter(oldObj)
			if !newer && !older {
				return
			}
			handler(newObj)
		},
		DeleteFunc: single,
	}
}

// Extract pulls a T from obj, handling tombstones.

            return changedTo(versions.get(versions.lastKey()) + 1, minGradleVersion);
        }

        /**
         * Specify the Gradle version where this cache directory was retired.
         * For this and any newer Gradle version, the cache directory is unused.
         * This is indicated by setting the current cache version to Integer.MAX_VALUE (so it cannot be further incremented).
         */

                }
            }

            configurations.all {
                if (it.canBeConsumed && it.name != 'sourcesElements' ) {
                    // let's pretend it was built with a newer Java version
                    attributes {
                        // This test is not Artic Code Vault safe
                        attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, 2099)
                    }

import java.util.Comparator;
import java.util.List;
import java.util.Optional;

/**
 * A {@link ResolutionFailureDescriber} that describes a {@link ResolutionFailure} caused by a plugin requiring
 * a newer Gradle version than the one currently running the build.
 *
 * This is determined by assessing the incompatibility of the {@link GradlePluginApiVersion#GRADLE_PLUGIN_API_VERSION_ATTRIBUTE} attribute.
 */

First, try to fetch a more recent version. For example:
```sh
go get k8s.io/client-go@v0.20.4
```

If that doesn't resolve the problem, see what is requiring an `...+incompatible` version of client-go,
and update to use a newer version of that library, if possible:
```sh
go mod graph | grep " k8s.io/client-go@"
```

As a last resort, you can force the build to use a specific version of client-go,

            executer.expectDocumentedDeprecationWarning("Gradle Enterprise plugin $pluginVersion has been deprecated. Starting with Gradle 9.0, only Gradle Enterprise plugin 3.13.1 or newer is supported. Consult the upgrading guide for further information: https://docs.gradle.org/current/userguide/upgrading_version_8.html#unsupported_ge_plugin_3.13")
        }
        succeeds("t", "--configuration-cache")