Laura Kassovic <******@****.***> 1701107622 -0800

        transformRegistry.registrations >> [transform1, transform2, transform3, transform4, transform5, transform6]

        when:
        def result = transformations.findTransformedVariants(variants, requested)

        then:
        result.size() == 2
        // sourceVariant + transform2 + transform3 = compatible
        assertTransformChain(result[0], sourceVariant, compatible, transform2, transform3)

        and:
        1 * transform1.transform(someValue()) >> someOtherValue()
        1 * transform2.transform(someOtherValue()) >> someOtherValue2()
        1 * transform3.transform(someOtherValue2()) >> someOtherValue3()
        0 * _
    }

    def "can chain mapped providers with filtering providers"() {
        def transform1 = Mock(Transformer)
        def spec = Mock(Spec)
        def transform2 = Mock(Transformer)

== Artifact transform selection and execution

As described above, when Gradle resolves a configuration and a dependency in the configuration does not have a variant with the requested attributes, Gradle tries to find a chain of artifact transforms to create the variant.
The process of finding a matching chain of artifact transforms is called _artifact transform selection_.

 */

package org.gradle.internal.serialize.codecs.dm.transform

import org.gradle.api.file.FileCollection
import org.gradle.api.internal.artifacts.transform.BoundTransformStep
import org.gradle.api.internal.artifacts.transform.DefaultTransformDependencies
import org.gradle.api.internal.artifacts.transform.DefaultTransformUpstreamDependenciesResolver
import org.gradle.api.internal.artifacts.transform.TransformDependencies

            TransformWorkspaceIdentity transformWorkspaceIdentity,
            Transform transform,
            ComponentIdentifier componentIdentifier
        ) {
            this.inputArtifact = inputArtifact;
            this.transformWorkspaceIdentity = transformWorkspaceIdentity;
            this.transform = transform;
            this.componentIdentifier = componentIdentifier;
        }

        @Override

    protected abstract List<Transform> getIncrementalChanges();

    /**
     * Transforms the app element into the alternate app element in the given project.
     */
    public void applyChangesToProject(TestFile projectDir) {
        for (Transform transform : getIncrementalChanges()) {
            transform.applyChangesToProject(projectDir);
        }
    }

    /**

        }
        return newMap;
    }

    protected XmlNode transform(XmlNode node) {
        if (node != null) {
            String oldValue = node.getValue();
            String newValue = transform(oldValue);
            Map<String, String> oldAttrs = node.getAttributes();
            Map<String, String> newAttrs = transform(oldAttrs, this::transform);
            List<XmlNode> oldChildren = node.getChildren();

    /**
     * Full set of attributes of the artifact before the transform.
     */
    Map<String, String> getSourceAttributes();

    /**
     * Target attributes of the transformed artifact.
     * <p>
     * The attributes include all source attributes of the artifact before the transform,
     * values for some of which have been changed by the transform.
     */
    Map<String, String> getTargetAttributes();

    /**

 *
 * <p>
 *     To register an artifact transform, use {@link org.gradle.api.artifacts.dsl.DependencyHandler#registerTransform(java.lang.Class, org.gradle.api.Action)}.
 *     This allows you to register a {@link org.gradle.api.artifacts.transform.TransformAction} using {@link org.gradle.api.artifacts.transform.TransformSpec}.
 * </p>
 *