/**
 * Represents a variant which is produced as the result of applying an artifact transform chain
 * to a root producer variant.
 */
public class TransformedVariant implements HasAttributes {
    private final ResolvedVariant root;
    private final VariantDefinition chain;

    public TransformedVariant(ResolvedVariant root, VariantDefinition chain) {
        this.root = root;
        this.chain = chain;
    }

    /**

 */
public final class AmbiguousArtifactTransformFailure extends AbstractIncompatibleAttributesSelectionFailure {
    private final ImmutableList<TransformedVariant> transformedVariants;

    public AmbiguousArtifactTransformFailure(String requestedName, AttributeContainerInternal requestedAttributes, List<TransformedVariant> transformedVariants) {
        super(requestedName, requestedAttributes);

     */
    private static List<TransformedVariant> tryDisambiguate(
        AttributeMatcher matcher,
        List<TransformedVariant> candidates,
        ImmutableAttributes componentRequested,
        AttributeMatchingExplanationBuilder explanationBuilder
    ) {
        List<TransformedVariant> matches = matcher.matches(candidates, componentRequested, explanationBuilder);

        formatter.node("Found the following transforms");

        Comparator<TransformedVariant> variantComparator =
            Comparator.<TransformedVariant, String>comparing(x -> x.getTransformChain().getDisplayName())
                .thenComparing(x -> x.getAttributes().toString());
        Map<ResolvedVariant, List<TransformedVariant>> variantToTransforms = failure.getTransformedVariants().stream().collect(Collectors.groupingBy(

            List<TransformedVariant> output = new ArrayList<>(cached.size());
            for (CachedVariant variant : cached) {
                output.add(new TransformedVariant(sources.get(variant.sourceIndex), variant.chain));
            }
            return output;
        }

            getVariants() >> variants
            getOverriddenAttributes() >> ImmutableAttributes.EMPTY
        }
    }

    private List<TransformedVariant> transformedVariants(List<ResolvedVariant> variants) {
        variants.collect {
            new TransformedVariant(it, Mock(VariantDefinition) {
                transformChain >> Mock(TransformChain)
                targetAttributes >> ImmutableAttributes.EMPTY
            })

        attributeContainer.attribute(ARTIFACT_TYPE_ATTRIBUTE, artifactType)
        attributeContainer.asImmutable()
    }

    TransformedVariant transformedVariant(ResolvedVariant root, AttributeContainerInternal attributes) {
        ImmutableAttributes attrs = attributes.asImmutable()
        TransformStep step = Mock(TransformStep) {
            getDisplayName() >> ""

import org.gradle.api.internal.artifacts.ivyservice.resolveengine.graph.builder.NodeState;
import org.gradle.api.internal.artifacts.transform.AttributeMatchingArtifactVariantSelector;
import org.gradle.api.internal.artifacts.transform.TransformedVariant;
import org.gradle.api.internal.attributes.AttributeContainerInternal;
import org.gradle.api.internal.attributes.AttributesSchemaInternal;
import org.gradle.api.internal.attributes.ImmutableAttributes;

        1 * attributeMatcher.isMatching(finalAttributes, requested) >> false

        0 * attributeMatcher._
    }

    private void assertTransformChain(TransformedVariant chain, ResolvedVariant source, AttributeContainer finalAttributes, TransformRegistration... registrations) {
        assert chain.root == source
        assert chain.attributes == finalAttributes
        def actualSteps = []