static class VariantExtractor implements Transformer<List<ResolvedVariantResult>, Collection<ResolvedArtifactResult>> {
        @Override
        public List<ResolvedVariantResult> transform(Collection<ResolvedArtifactResult> artifacts) {
            return artifacts.stream().map(ResolvedArtifactResult::getVariant).collect(Collectors.toList());
        }
    }

</table>
</div>
<div class="tab" id="tab3">
<h2>Artifact Transforms</h2>
<table>
<thead>
<tr>
<th>Transform</th>
<th class="numeric">Duration</th>
</tr>
</thead>
<tr>
<td>All transforms</td>
<td class="numeric">31.000s</td>
</tr>
<tr>
<td>some other transform</td>
<td class="numeric">19.000s</td>
</tr>
<tr>
<td>some transform</td>
<td class="numeric">12.000s</td>
</tr>
</table>

import org.gradle.api.Action;
import org.gradle.api.Transformer;
import org.gradle.api.file.FileCopyDetails;
import org.gradle.api.file.RelativePath;

public class RenamingCopyAction implements Action<FileCopyDetails> {
    private final Transformer<String, String> transformer;

    public RenamingCopyAction(Transformer<String, String> transformer) {
        this.transformer = transformer;
    }

    @Override

    }

    def "replace transformation runs eagerly"() {
        given:
        Transformer<Provider<String>, Provider<String>> transform = Mock()
        def property = property().value(someValue())

        when:
        property.replace(transform)

        then:
        1 * transform.transform(_)
    }

     * Updates jar/directory content hash to account for the transform produced by this factory.
     *
     * @param hasher the hasher to modify
     */
    void applyConfigurationTo(Hasher hasher);

    /**
     * Returns the transformation to be applied to the given jar/directory.
     *
     * @param file the jar/directory to transform
     * @param classTransform the transform that will be applied to every class

// license that can be found in the LICENSE file.

package cases

import "golang.org/x/text/transform"

type caseFolder struct{ transform.NopResetter }

// caseFolder implements the Transformer interface for doing case folding.
func (t *caseFolder) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
	c := context{dst: dst, src: src, atEOF: atEOF}
	for c.next() {
		foldFull(&c)

    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);
        }
    }

    /**

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;

        where:
        type << TESTED_CONSOLE_TYPES
    }

    def "progress display name is 'Transforming' for top level transforms"() {
        // Build scan plugin filters artifact transform logging by the name of the progress display name
        // since that is the only way it currently can distinguish transforms.
        // When it has a better way, then this test can be removed.
        consoleType = ConsoleOutput.Rich

import org.gradle.internal.operations.CallableBuildOperation;
import org.gradle.internal.scan.UsedByScanPlugin;
import org.gradle.operations.dependencies.transforms.ExecutePlannedTransformStepBuildOperationType;
import org.gradle.operations.dependencies.transforms.PlannedTransformStepIdentity;
import org.gradle.operations.dependencies.variants.Capability;
import org.gradle.operations.dependencies.variants.ComponentIdentifier;