}

    abstract class ReceiverOne {
        @Adding
        abstract fun adding(receiver: ReceiverOne.() -> Unit): ReceiverOne
    }

    abstract class ReceiverTwo {
        @Adding
        abstract fun adding(receiver: ReceiverTwo.() -> Unit)
    }

    abstract class ReceiverThree {
        @Adding
        abstract fun adding(three: Int)
    }

        assertTrue { result.configuredLazy.isInitialized() }
    }

    @Test
    fun `empty adding block ensures that the object is created`() {
        val resolution = schema.resolve(
            """
            adding()
            adding { }
            adding { x = 2 }
            addingWithArg(3)
            addingWithArg(4) { }
            """.trimIndent()
        )

/**
 * 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

                Set<Binding<Q>> res = getBindings(key);
                if (res != null && !res.isEmpty()) {
                    List<Binding<Q>> bindingList = new ArrayList<>(res);
                    Comparator<Binding<Q>> comparing = Comparator.comparing(Binding::getPriority);
                    bindingList.sort(comparing.reversed());
                    Binding<Q> binding = bindingList.get(0);

        buildFile << '''
            allprojects { p ->
                println "[1] Adding afterEvaluate for $p.name"
                p.afterEvaluate {
                    println "[1] afterEvaluate $p.name"
                }
            }

            project(':a') {
                println "[2] Adding evaluationDependsOn"
                evaluationDependsOn(':b')
            }

            allprojects { p ->

 *  by invoking {@link org.gradle.internal.serialize.graph.codecs.Binding#encodingForType(java.lang.Class)} on each binding. If a binding supports the type,
 *  it will return the proper {@link org.gradle.internal.serialize.graph.EncodingProvider} (or null, otherwise).
 *  </p><p>

            }

            if (used < namedArguments.size)
                return null

            if (hasLambda && captor == null)
                return null
        }
        return Binding(map, captor)
    }

    data class Binding(
        val map: Map<KParameter, Any?>,
        val valueCaptor: ConfigureLambdaHandler.ValueCaptor?
    )

        @Configuring
        fun configuring(fn: InnerReceiver.() -> Unit)

        @Adding
        fun adding(fn: InnerReceiver.() -> Unit): InnerReceiver
    }

    interface InnerReceiver {
        @Restricted
        fun value(): Value

        @Restricted
        fun value(arg: Value): Value

        @Adding
        fun addingValue(value: Value): Value

        @get:Restricted

        then:
        env2.java.jvmArguments.contains(JVM_ARG_1)
        env2.java.jvmArguments.contains(JVM_ARG_2)
    }

    def "Adding zero JVM arguments is a no-op"() {
        expect:
        loadBuildEnvironment { builder -> builder.addJvmArguments() }
    }

    def "Adding null JVM argument throws NPE"() {
        when:
        loadBuildEnvironment { builder -> builder.addJvmArguments(null as String) }