def "does nothing to empty classpath when transform is none"() {
        given:
        def classpath = DefaultClassPath.of()

        when:
        def cachedClasspath = transformer.transform(classpath, None)

        then:
        cachedClasspath.empty

        and:
        0 * fileAccessTimeJournal._
    }

    def "does nothing to empty classpath when transform is build logic"() {
        given:

        GroupedTransformOutputFixture transform = transforms.get(key);
        if (transform == null) {
            transform = new GroupedTransformOutputFixture(initialSubjectType, subject, transformer);
            transforms.put(key, transform);
        }

        transform.addOutput(transformOutput);
    }

import java.io.File;

/**
 * A single transform step in a transform chain.
 * <p>
 * Transforms a subject by invoking a transform on each of the subjects files.
 *
 * @see TransformChain
 */
public class TransformStep implements TaskDependencyContainer, Describable {
    private static final Logger LOGGER = LoggerFactory.getLogger(TransformStep.class);

    private final Transform transform;

    }

    @Override
    public ClassPath transform(ClassPath classPath, StandardTransform transform) {
        if (classPath.isEmpty()) {
            return classPath;
        }
        return transformPipelineFor(transform).transform(classPath);

    }

    @FunctionalInterface
    private interface TransformPipeline {
        ClassPath transform(ClassPath original);
    }

            configHashFor(classpathElementTransformFactory, transform, gradleCoreInstrumentationTypeRegistry),
            classpathFileHasher);
        this.classpathElementTransformFactory = classpathElementTransformFactory;
        this.transform = transform;
    }

 * limitations under the License.
 */

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

import com.google.common.base.Function;
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.internal.initialization.transform.InstrumentationAnalysisTransform;
import org.gradle.api.internal.initialization.transform.MergeInstrumentationAnalysisTransform;
import org.gradle.api.internal.initialization.transform.ProjectDependencyInstrumentingArtifactTransform;
import org.gradle.api.internal.initialization.transform.services.CacheInstrumentationDataBuildService;

        then:
        output.count("transform") == 3
        outputContains("transform external test-1.2.jar")
        outputContains("transform local test2-1.5.thing using [test-1.2.jar.external]")
        outputContains("transform local test3-1.5.thing using [test-1.2.jar.external]")
        outputContains("artifacts = [test2-1.5.thing.local (test:test2:1.5), test3-1.5.thing.local (test:test3:1.5)]")

        when:

    /**
     * Returns the subject of this transform operation.
     */
    SubjectDescriptor getSubject();

    /**
     * Returns the dependencies (other transforms and tasks) of this transform operation.
     */
    Set<? extends OperationDescriptor> getDependencies();

    /**
     * Describes the transformer of a transform operation.
     *
     * @since 5.1
     */
    interface TransformerDescriptor {

        actions.add(action);
    }

    /**
     * Transforms a properties object.  This will modify the
     * original.
     * @param original the properties to transform
     * @return the transformed properties
     */
    @Override
    public Properties transform(Properties original) {
        return doTransform(original);
    }

    /**
     * Transforms a properties object and write them out to a stream.