import org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.ResolvedVariant;

public interface TransformedVariantFactory {
    ResolvedArtifactSet transformedExternalArtifacts(ComponentIdentifier componentIdentifier,
                                                     ResolvedVariant sourceVariant,
                                                     VariantDefinition variantDefinition,

    private final ImmutableAttributes selectionAttributes;
    private final ImmutableSet<ResolvedVariant> variants;

    public DefaultResolvedVariantSet(ComponentIdentifier componentIdentifier, AttributesSchemaInternal schema, ImmutableAttributes selectionAttributes, ImmutableSet<ResolvedVariant> variants) {
        this.componentIdentifier = componentIdentifier;
        this.schema = schema;

 * limitations under the License.
 */

package org.gradle.internal.component.model;

import org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.ResolvedVariant;
import org.gradle.internal.resolve.resolver.VariantArtifactResolver;

import java.util.List;
import java.util.Set;

/**

                                                             boolean constraint) {
        List<Object> key = asList(requested, from, selected, resolvedVariant, constraint);
        if (!resolvedDependencies.containsKey(key)) {
            resolvedDependencies.put(key, new DefaultResolvedDependencyResult(requested, constraint, selected, resolvedVariant, from));
        }

                return candidates.variants[0].artifacts
            }
        }, spec)

        then:
        1 * variantResolver.resolveVariant(_, subvariant1) >> Mock(ResolvedVariant)
        1 * variantResolver.resolveVariant(_, subvariant2) >> Mock(ResolvedVariant)
        0 * variantResolver._
    }

    def "selects artifacts when component id matches spec"() {
        given:

import org.gradle.api.internal.attributes.AttributesSchemaInternal;
import org.gradle.api.internal.attributes.ImmutableAttributes;

import java.util.Set;

/**
 * Represents some provider of {@link ResolvedVariant} instances to select from.
 * Used to select the artifacts given a particular variant selected during graph resolution.
 */
public interface ResolvedVariantSet {
    Describable asDescribable();

import com.google.common.collect.Ordering;
import org.gradle.api.attributes.Attribute;
import org.gradle.api.attributes.AttributeContainer;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.ResolvedVariant;
import org.gradle.api.internal.artifacts.transform.TransformedVariant;
import org.gradle.api.internal.attributes.AttributesSchemaInternal;

        if (resolvedVariant != null) {
            return resolvedVariant;
        }
        List<NodeState> targetNodes = findTargetNodes();
        assert !targetNodes.isEmpty();
        for (NodeState targetNode : targetNodes) {
            if (targetNode.isSelected()) {
                resolvedVariant = targetNode;
                return resolvedVariant;
            }
        }

                        if (it instanceof ResolvedDependencyResult) {
                            def resolvedVariant = it.resolvedVariant
                            def selected = it.selected
                            println("   " * depth + "\$selected (\$resolvedVariant)")
                            dump(root, selected, resolvedVariant, depth, visited)
                        } else {

            this.action = action;
        }

        private List<TransformedVariant> query(
            List<ResolvedVariant> sources, ImmutableAttributes requested
        ) {
            List<ImmutableAttributes> variantAttributes = new ArrayList<>(sources.size());
            for (ResolvedVariant variant : sources) {
                variantAttributes.add(variant.getAttributes().asImmutable());
            }