}

    String transform(File from, File to) {
        return normaliseFileSeparators(RelativeFileNameTransformer.forDirectory(rootDir, from).transform(to))
    }

    String pathToDescendant(File parent, File to) {
        assert parent.exists()
        assert to.exists()
        return normaliseFileSeparators(RelativeFileNameTransformer.from(parent).transform(to))
    }

import org.gradle.api.Action;
import org.gradle.api.artifacts.transform.TransformAction;
import org.gradle.api.artifacts.transform.TransformParameters;
import org.gradle.api.artifacts.transform.TransformSpec;

import java.util.List;

public interface VariantTransformRegistry {

    /**
     * Register an artifact transform.
     *
     * @see TransformAction
     */

            @Override
            ResourceLockState.Disposition transform(ResourceLockState resourceLockState) {
                disposition = tryLock(lock1, lock2).transform(resourceLockState)
                return FINISHED
            }
        })

        then:
        disposition == expectedDisposition

        and:

            String basicName = subjectName + " with " + transformStepName;
            return BuildOperationDescriptor.displayName("Transform " + basicName)
                .progressDisplayName(TRANSFORMING_PROGRESS_PREFIX + basicName)
                .metadata(BuildOperationCategory.TRANSFORM)
                .details(new ExecutePlannedTransformStepBuildOperationDetails(TransformStepNode.this, transformStepName, subjectName));
        }

    /**
     * @return The transform chain which transforms the root variant to this variant.
     */
    TransformChain getTransformChain();

    /**
     * The single transform step which transforms the previous variant to this variant.
     */
    TransformStep getTransformStep();

    /**
     * @return The previous variant in the transform chain. If null, this variant uses the producer variant as its root.

        outputContains("processing c.jar using [tool-a.jar]")
        outputContains("result = [b.jar.green, c.jar.green]")
    }

    def "transform can receive a file collection containing transform outputs as parameter"() {
        createDirs("a", "b", "c", "d", "e")
        settingsFile << """
                include 'a', 'b', 'c', 'd', 'e'
            """

import gradlebuild.basics.classanalysis.addJarEntry
import org.gradle.api.artifacts.transform.CacheableTransform
import org.gradle.api.artifacts.transform.InputArtifact
import org.gradle.api.artifacts.transform.TransformAction
import org.gradle.api.artifacts.transform.TransformOutputs
import org.gradle.api.artifacts.transform.TransformParameters
import org.gradle.api.file.FileSystemLocation
import org.gradle.api.provider.Provider

        buildA.buildFile << """
            import org.gradle.api.artifacts.transform.TransformParameters

            abstract class XForm implements TransformAction<TransformParameters.None> {
                @InputArtifact
                abstract Provider<FileSystemLocation> getInputArtifact()

                void transform(TransformOutputs outputs) {
                    def input = inputArtifact.get().asFile

 * limitations under the License.
 */

package org.gradle.api.internal.artifacts.transform;

/**
 * A transform step with all of its parameters bound to their providers.
 * <p>
 * A transform step may take parameters from a parameters object specified when the transform is registered
 * and may also take the upstream dependencies of the source artifact as a parameter.
 */

     * @param original the property list to transform
     * @return the transformed property list
     */
    @Override
    public T transform(T original) {
        return doTransform(original);
    }

    /**
     * Transforms a property list object and write them out to a stream.
     * This will modify the original property list.
     * @param original the property list to transform