*
 * Class is non-{@code final} for testing via stubbing.
 */
public class ResolutionFailureHandler {
    public static final String DEFAULT_MESSAGE_PREFIX = "Review the variant matching algorithm at ";

    private final ResolutionFailureDescriberRegistry defaultFailureDescribers;

    public ResolutionFailureHandler(ResolutionFailureDescriberRegistry failureDescriberRegistry) {

    private final ResolutionFailureHandler failureProcessor;

    public DefaultVariantSelectorFactory(
        ConsumerProvidedVariantFinder consumerProvidedVariantFinder,
        AttributesSchemaInternal schema,
        ImmutableAttributesFactory attributesFactory,
        TransformedVariantFactory transformedVariantFactory,
        ResolutionFailureHandler failureProcessor
    ) {

     */
    public GraphVariantSelectionResult selectLegacyConfigurations(ConfigurationMetadata fromConfiguration, ComponentGraphResolveState targetComponent, ResolutionFailureHandler resolutionFailureHandler) {
        // TODO - all this matching stuff is constant for a given DependencyMetadata instance
        List<ConfigurationGraphResolveState> targets = new LinkedList<>();
        boolean matched = false;

        metadata.selectLegacyConfigurations(fromConfig2, toComponent, resolutionFailureHandler).variants == [toConfig2]
    }

    def "configuration mapping can use wildcard on RHS to select all public configurations"() {
        def resolutionFailureHandler = Stub(ResolutionFailureHandler)

        when:
        def conf1State = state.candidatesForGraphVariantSelection.getVariantByConfigurationName("child1", Stub(ResolutionFailureHandler))
        def conf2State = state.candidatesForGraphVariantSelection.getVariantByConfigurationName("child2", Stub(ResolutionFailureHandler))

        then:
        conf1State.resolveArtifacts().artifacts.size() == 3
        conf2State.resolveArtifacts().artifacts.size() == 1

    default VariantGraphResolveState getLegacyVariant(ResolutionFailureHandler failureHandler) {
        return getVariantByConfigurationName(Dependency.DEFAULT_CONFIGURATION, failureHandler);
    }

    /**
     * Returns the variant that is identified by the given configuration name.
     */
    @Nullable
    VariantGraphResolveState getVariantByConfigurationName(String name, ResolutionFailureHandler failureHandler);

import org.gradle.api.internal.attributes.ImmutableAttributes;
import org.gradle.api.internal.attributes.ImmutableAttributesFactory;
import org.gradle.internal.component.ResolutionFailureHandler;
import org.gradle.internal.component.model.AttributeMatcher;
import org.gradle.internal.component.model.AttributeMatchingExplanationBuilder;

import java.util.ArrayList;
import java.util.HashSet;

 * similar purpose.  An instance of {@link ResolutionFailureHandler} is injected in the constructor
 * to allow the caller to handle failures in a consistent way - all matching failures should be reported via
 * calls to that instance.
 */
public class GraphVariantSelector {
    private final ResolutionFailureHandler failureHandler;

    public GraphVariantSelector(ResolutionFailureHandler failureHandler) {

import org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.ResolvedVariantSet;
import org.gradle.api.internal.attributes.ImmutableAttributes;
import org.gradle.internal.component.ResolutionFailureHandler;
import org.gradle.internal.component.model.GraphVariantSelector;

/**
 * Selects artifacts from a set of resolved variants. This can but does not necessarily require an additional

import org.gradle.api.capabilities.Capability;
import org.gradle.api.internal.attributes.AttributesSchemaInternal;
import org.gradle.api.internal.attributes.ImmutableAttributes;
import org.gradle.internal.component.ResolutionFailureHandler;

import javax.annotation.Nullable;
import java.util.Collection;
import java.util.List;

/**
 * A dependency that can participate in dependency resolution.