import org.gradle.internal.component.resolution.failure.ResolutionCandidateAssessor;
import org.gradle.internal.component.resolution.failure.ResolutionCandidateAssessor.AssessedCandidate;
import org.gradle.internal.component.resolution.failure.ResolutionFailureDescriberRegistry;
import org.gradle.internal.component.resolution.failure.describer.ResolutionFailureDescriber;

    /**
     * Returns the public view of all variants of this component that are available for variant selection, either during graph resolution or artifact resolution.
     */
    List<ResolvedVariantResult> getAllSelectableVariantResults();

    /**
     * Returns the candidates for variant selection during graph resolution.
     */
    GraphSelectionCandidates getCandidatesForGraphVariantSelection();

    /**

    /**
     * Returns all the candidates considered during [overload resolution](https://kotlinlang.org/spec/overload-resolution.html) for the call
     * corresponding to this [KtElement].
     *
     * [resolveCallOld] only returns the final result of overload resolution, i.e., the selected callable after considering candidate
     * applicability and choosing the most specific candidate.
     */

	creationTime := cfg.CreationTimestamp

	var resolution model.Resolution
	switch serviceEntry.Resolution {
	case networking.ServiceEntry_NONE:
		resolution = model.Passthrough
	case networking.ServiceEntry_DNS:
		resolution = model.DNSLB
	case networking.ServiceEntry_DNS_ROUND_ROBIN:
		resolution = model.DNSRoundRobinLB
	case networking.ServiceEntry_STATIC:
		resolution = model.ClientSideLB
	}

        when: 'exception is thrown in resolution'
        repositoryBlacklister.getDisabledReason(REPOSITORY_ID) >> Optional.of(exception)
        effectiveRetries * delegate.listModuleVersions(dependency, result) >> { throw exception }
        access.listModuleVersions(dependency, result)

        then: 'resolution fails and repo is disabled'

object EmptyBlocksTest {
    @Test
    fun `empty configuring block leads to object access`() {
        val resolution = schema.resolve(
            """
            configuring { }
            """.trimIndent()
        )

        val result = runtimeInstanceFromResult(schema, resolution, kotlinFunctionAsConfigureLambda, RuntimeCustomAccessors.none, ::TopLevel)

        assertTrue { result.configuredLazy.isInitialized() }

fun AnalysisSchema.reflect(code: String): ObjectReflection {
    val resolution = resolve(code)
    val trace = assignmentTrace(resolution)
    val context = ReflectionContext(SchemaTypeRefContext(this), resolution, trace)
    val topLevel = org.gradle.internal.declarativedsl.objectGraph.reflect(resolution.topLevelReceiver, context)

    return topLevel
}

    /**
     * Discard any configuration state that is not required after graph resolution has been attempted.
     */
    void maybeDiscardStateRequiredForGraphResolution();

    /**
     * Sets whether or not any configuration resolution is final and the state required for resolution can be
     * discarded.  Setting this to true implies that the configuration may be re-resolved again in the future.
     *

import kotlin.test.Test
import kotlin.test.assertEquals


object OriginReplacementTest {
    @Test
    fun `replaces configured object access and function call receiver`() {
        with(resolution("configuring { property = value() }")) {
            val assignment = assignments.single()
            val lhs = replaceInnerReceiverWithTopLevel(assignment.lhs.receiverObject)

    schema: AnalysisSchema,
    resolution: ResolutionResult,
    configureLambdas: ConfigureLambdaHandler,
    customAccessors: RuntimeCustomAccessors,
    createInstance: () -> T
): T {
    val trace = assignmentTrace(resolution)
    val context = ReflectionContext(SchemaTypeRefContext(schema), resolution, trace)
    val topLevel = reflect(resolution.topLevelReceiver, context)

    return createInstance().also {