init {
        register {
            add(GradleUserHomeTemporaryFileProvider::class.java, GradleUserHomeTemporaryFileProvider { baseTempDir })
        }
    }
}


/**
 * A simplified Kotlin script evaluator, suitable for cheaper testing of the DSL outside Gradle.
 */
private
class SimplifiedKotlinScriptEvaluator(
    private val baseCacheDir: File,
    private val baseTempDir: File,

				}
			},
			want: true,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			evaluator := &policyRuleEvaluator{
				Policy: test.policy(),
			}

			got := evaluator.EvaluatePolicyRule(attributes)
			if test.want != got.OmitManagedFields {
				t.Errorf("Expected OmitManagedFields to match, want: %t, got: %t", test.want, got.OmitManagedFields)

        mavenSession.getRequest().setRootDirectory(path);
        DefaultModelBuildingRequest mbr = new DefaultModelBuildingRequest();

        PluginParameterExpressionEvaluatorV4 evaluator =
                new PluginParameterExpressionEvaluatorV4(mavenSession.getSession(), null);

        DefaultPlexusConfiguration configuration = new DefaultPlexusConfiguration("config");

	"k8s.io/apiserver/pkg/authorization/authorizer"
	"k8s.io/apiserver/pkg/features"
)

// PolicyTestContext is everything you need to unit test a policy plugin
type PolicyTestContext[P runtime.Object, B runtime.Object, E Evaluator] struct {
	context.Context
	Plugin *Plugin[PolicyHook[P, B, E]]
	Source Source[PolicyHook[P, B, E]]
	Start  func() error

	scheme     *runtime.Scheme
	restMapper *meta.DefaultRESTMapper

			})

			fakePostPlugin := &FakePostFilterPlugin{numViolatingVictim: tt.numViolatingVictim}

			for cycle, pod := range tt.testPods {
				state := framework.NewCycleState()
				pe := Evaluator{
					PluginName: "FakePostFilter",
					Handler:    fwk,
					Interface:  fakePostPlugin,
					State:      state,
				}

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
import org.codehaus.plexus.component.configurator.expression.TypeAwareExpressionEvaluator;

/**
 * Evaluator for plugin parameters expressions. Content surrounded by <code>${</code> and <code>}</code> is evaluated.
 * Recognized values are:
 * <table border="1">
 * <caption>Expression matrix</caption>

platforms/core-configuration/declarative-dsl-api/                   @gradle/bt-declarative-dsl
platforms/core-configuration/declarative-dsl-core/                  @gradle/bt-declarative-dsl
platforms/core-configuration/declarative-dsl-evaluator/             @gradle/bt-declarative-dsl
platforms/core-configuration/declarative-dsl-provider/              @gradle/bt-declarative-dsl
platforms/core-configuration/declarative-dsl-tooling-builders/      @gradle/bt-declarative-dsl

	{"invoke nested int", `{{template "nested" .I}}`, "17", tVal, true},
	{"variable declared by template", `{{template "nested" $x:=.SI}},{{index $x 1}}`, "[3 4 5],4", tVal, true},

	// User-defined function: test argument evaluator.
	{"testFunc literal", `{{oneArg "joe"}}`, "oneArg=joe", tVal, true},
	{"testFunc .", `{{oneArg .}}`, "oneArg=joe", "joe", true},
}

// These strings are also in testdata/*.
const multiText1 = `

import org.jetbrains.kotlin.resolve.constants.evaluate.evalBinaryOp
import org.jetbrains.kotlin.resolve.constants.evaluate.evalUnaryOp
import org.jetbrains.kotlin.types.ConstantValueKind

/**
 * An evaluator that transform numeric operation, such as div, into compile-time constant iff involved operands, such as explicit receiver
 * and the argument, are compile-time constant as well.
 */
internal object FirCompileTimeConstantEvaluator {

    "unitTests": true,
    "functionalTests": true,
    "crossVersionTests": false
  },
  {
    "name": "declarative-dsl-evaluator",
    "path": "platforms/core-configuration/declarative-dsl-evaluator",
    "unitTests": false,
    "functionalTests": false,
    "crossVersionTests": false
  },
  {
    "name": "declarative-dsl-provider",