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

import java.util.concurrent.TimeUnit;

/**
 * Command methods for controlling dependency resolution via the DSL.
 * @param <A> The type of the request object for this resolution
 * @param <B> The type of the result of this resolution
 */
public interface ResolutionControl<A, B> {
    /**
     * Returns the query object that was requested in this resolution.
     * @return the request object
     */
    A getRequest();

    /**

    @Override
    public ExecutionFailure assertHasResolution(String resolution) {
        assertThat(this.resolution, containsString("> " + resolution));
        return this;
    }

    @Override
    public ExecutionFailure assertHasResolutions(String... resolutions) {
        String expected = Arrays.stream(resolutions)
            .map(resolution -> "> " + resolution)
            .collect(joining("\n"));

     * in the selection of that module contain at least one dynamic version, then resolution will fail if the resolution
     * result can change because of this version selector.
     *
     * This can be used in cases you want to make sure your build is reproducible, <i>without</i> relying on
     * dependency locking.
     *
     * @return this resolution strategy
     * @since 6.1
     */
    ResolutionStrategy failOnDynamicVersions();

        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'

            }
        }
        fails ':checkDeps'

        then:
        failure.assertHasCause("Could not resolve org:test:$selector1: Resolution strategy disallows usage of dynamic versions")
        failure.assertHasCause("Could not resolve org:test:$selector2: Resolution strategy disallows usage of dynamic versions")

        where:
        selector1        | selector2
        '[1.0, 2.0['     | '[1.0, 1.5['

import org.gradle.internal.component.resolution.failure.exception.VariantSelectionException;
import org.gradle.internal.component.resolution.failure.type.VariantAwareAmbiguousResolutionFailure;
import org.gradle.internal.logging.text.StyledTextOutput;
import org.gradle.internal.logging.text.TreeFormatter;

import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.TreeMap;

 */

package org.gradle.internal.component.resolution.failure.describer;

import org.gradle.api.internal.attributes.AttributeDescriber;
import org.gradle.api.internal.attributes.AttributesSchemaInternal;
import org.gradle.internal.component.model.AttributeDescriberSelector;
import org.gradle.internal.component.resolution.failure.ResolutionCandidateAssessor;
import org.gradle.internal.component.resolution.failure.StyledAttributeDescriber;

    @JvmStatic
    fun main(args: Array<String>) {
        val resolution = schema.resolve(
            """
            val myD = newD("shared")

            val c1 = c(1)
            c1.d = myD
            str = c1.d.id
            """.trimIndent()
        )
        printResolutionResults(resolution)
        printResolvedAssignments(resolution)
    }

import org.gradle.internal.component.resolution.failure.exception.AbstractResolutionFailureException
import org.gradle.internal.component.resolution.failure.exception.ArtifactVariantSelectionException
import org.gradle.internal.component.resolution.failure.exception.ConfigurationSelectionException
import org.gradle.internal.component.resolution.failure.exception.VariantSelectionException