)
    }


    @Test
    fun `underlay adding blocks appear before overlay ones`() {
        val underlay = resolvedDocument(
            """
            adding(1) {
                a = 1
            }
            """.trimIndent()
        )

        val overlay = resolvedDocument(
            """
            adding(1) {
                b = 2
            }

        Map<String, String> binding = new HashMap<>();
        binding.put(ScriptBindingParameter.APP_NAME.getKey(), details.getApplicationName());
        binding.put(ScriptBindingParameter.OPTS_ENV_VAR.getKey(), details.getOptsEnvironmentVar());
        binding.put(ScriptBindingParameter.EXIT_ENV_VAR.getKey(), details.getExitEnvironmentVar());

/**
 * An implementation of the Codec protocol that (based on a [Binding.tag]) chooses and delegates
 * to the proper binding (if one is found).
 *
 * The binding (a tagged codec) is chosen based on the availability of a [Binding.encoding] for the value being encoded.
 * This is basically implemented as a predicate dispatching on the value type, first available Binding.encoding wins

import kotlin.reflect.KFunction


interface DeclarativeRuntimeFunction {
    fun callBy(receiver: Any, binding: Map<DataParameter, Any?>, hasLambda: Boolean): InvocationResult

    fun callByWithErrorHandling(receiver: Any, binding: Map<DataParameter, Any?>, hasLambda: Boolean): InvocationResult {
        try {
            return callBy(receiver, binding, hasLambda)
        } catch (ite: InvocationTargetException) {
            throw ite.cause ?: ite

<% if (binding.hasVariable("buildScanPluginVersion") || binding.hasVariable("springDmPluginVersion")) {%>

buildscript {
    repositories {
<% if(binding.hasVariable("springDmPluginVersion")) { %>
        mavenLocal()
        mavenCentral()
<% } %>
<% if (binding.hasVariable("buildScanPluginVersion")) { %>
        maven {
            url 'https://repo.gradle.org/gradle/enterprise-libs-snapshots-local/'
        }
<% } %>
    }

<% if (binding.hasVariable("daemonMemory")) { %>org.gradle.jvmargs=-Xms${binding.getVariable("daemonMemory")} -Xmx${binding.getVariable("daemonMemory")}<% } %>
<% if (binding.hasVariable("parallel")) { %>org.gradle.parallel=true<% } %>

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'idea'


<% if (binding.hasVariable("manyPlugins")) { (1..25).findAll { it % 3 == 0 }.each { %>
    apply plugin: "org.gradle.build.gen${it}"
    <% } %>
    <% } %>


<% if (binding.hasVariable("manyScripts")) { (1..30).findAll { it % 5 == 0 }.each { %>
    apply from: "\${rootProject.projectDir.absolutePath}/gradle/script-plugin${it}.gradle"
    <% } %>
    <% } %>

	binding := obj.(*admissionregistration.ValidatingAdmissionPolicyBinding)
	if binding.Spec.ParamRef == nil {
		// no paramRef in new object
		return nil
	}

	return v.authorize(ctx, binding)
}

func (v *validatingAdmissionPolicyBindingStrategy) authorizeUpdate(ctx context.Context, obj, old runtime.Object) error {
	binding := obj.(*admissionregistration.ValidatingAdmissionPolicyBinding)

 * limitations under the License.
 */

<% if (binding.hasVariable("buildScanPluginVersion") || binding.hasVariable("springDmPluginVersion")) {%>

buildscript {
    repositories {
<% if(binding.hasVariable("springDmPluginVersion")) { %>
        mavenLocal()
        mavenCentral()
<% } %>
<% if (binding.hasVariable("buildScanPluginVersion")) { %>
        maven {

        for (ModelBinding binding : ruleBinder.getInputBindings()) {
            addRule(ruleBinder, rulesByInput, binding);
        }
    }

    private void addRule(RuleBinder rule, NodeAtStateIndex index, ModelBinding binding) {
        Reference reference = new Reference(rule, index, binding);
        BindingPredicate predicate = binding.getPredicate();
        if (predicate.getPath() != null) {