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)

        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)

        given:

        when:
        run "transform2"

        then:
        result.assertTasksExecuted(":transform2")
        result.assertTasksSkipped(":transform2")

        when:
        run "transform1"

        then:
        result.assertTasksExecuted(":transform1")
        result.assertTasksNotSkipped(":transform1")

        when:

        def task4 = new TestTaskNode("task4")
        def transform1 = new TestTransformStepNode("transform1")

        dependsOn(task1, [task2, transform1])
        dependsOn(task2, [task3])
        dependsOn(task3, [task4])
        dependsOn(transform1, [task4])

        when:
        collector.collectNodes([task1, task2, task3, task4, transform1])
        def graph = collector.getGraph()

        when:
        fails ":resolve"

        then:
        failure.assertHasCause("Failed to transform bad-b.jar to match attributes {artifactType=size}")
        failure.assertHasCause("Failed to transform bad-c.jar to match attributes {artifactType=size}")
    }

    def "only one transformer execution per workspace"() {

        createDirs("lib", "app1", "app2")
        settingsFile << """

 */
package org.gradle.api;

/**
 * <p>A {@code Transformer} transforms objects of type.</p>
 *
 * <p>Implementations are free to return new objects or mutate the incoming value.</p>
 *
 * @param <OUT> The type the value is transformed to.
 * @param <IN> The type of the value to be transformed.
 */
public interface Transformer<OUT extends @org.jetbrains.annotations.Nullable Object, IN> {
    /**

type Transformer interface {
	// Transform writes to dst the transformed bytes read from src, and
	// returns the number of dst bytes written and src bytes read. The
	// atEOF argument tells whether src represents the last bytes of the
	// input.
	//
	// Callers should always process the nDst bytes produced and account
	// for the nSrc bytes consumed before considering the error err.
	//

    /**
     * Whether the transformer requires dependencies of the transformed artifact to be injected.
     */
    boolean requiresDependencies();

    /**
     * Whether the transformer requires {@link InputChanges} to be injected.
     */
    boolean requiresInputChanges();

    /**
     * Whether the transformer is cacheable.
     */
    boolean isCacheable();

type Transformer interface {
	// Transform writes to dst the transformed bytes read from src, and
	// returns the number of dst bytes written and src bytes read. The
	// atEOF argument tells whether src represents the last bytes of the
	// input.
	//
	// Callers should always process the nDst bytes produced and account
	// for the nSrc bytes consumed before considering the error err.
	//

	for i, transformer := range t.transformers {
		if bytes.HasPrefix(data, transformer.Prefix) {
			result, stale, err := transformer.Transformer.TransformFromStorage(ctx, data[len(transformer.Prefix):], dataCtx)
			// To migrate away from encryption, user can specify an identity transformer higher up
			// (in the config file) than the encryption transformer. In that scenario, the identity transformer needs to