org.gradle.api.internal.tasks.execution.TaskValidator
org.gradle.api.artifacts.transform.ArtifactTransformDependencies
org.gradle.internal.filewatch.FileWatcherFactory
org.gradle.api.artifacts.transform.ArtifactTransform
org.gradle.api.artifacts.transform.ArtifactTransformException
org.gradle.api.artifacts.transform.VariantTransform
org.gradle.api.tasks.incremental.IncrementalTaskInputs
org.gradle.workers.WorkerConfiguration

 * limitations under the License.
 */

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

import org.gradle.api.artifacts.transform.TransformOutputs;
import org.gradle.api.internal.initialization.transform.utils.InstrumentationAnalysisSerializer;
import org.gradle.api.internal.initialization.transform.utils.InstrumentationTransformUtils.InstrumentationInputType;

    public FilterChain(String charset) {
        this.charset = charset;
    }

    /**
     * Transforms the given Reader. The original Reader will be closed by the returned Reader.
     */
    public Reader transform(Reader original) {
        return transformers.transform(original);
    }

    /**
     * Transforms the given InputStream. The original InputStream will be closed by the returned InputStream.
     */
    @Override

import java.util.zip.ZipFile

import org.gradle.api.artifacts.transform.TransformParameters

// tag::artifact-transform-unzip[]
abstract class Unzip : TransformAction<TransformParameters.None> {          // <1>
    @get:InputArtifact                                                      // <2>
    abstract val inputArtifact: Provider<FileSystemLocation>

    override
    fun transform(outputs: TransformOutputs) {

    // This tests current behaviour, not desired behaviour
    @UnsupportedWithConfigurationCache(because = "Task does not declare that it uses the transform outputs")
    def "can consume transform outputs produced by another project without declaring this access"() {
        createDirs("a", "b", "sneaky")
        settingsFile << """
            include 'a', 'b', 'sneaky'
        """

    private final ClassTransform transform;
    private final Predicate<String> shouldLoadTransformedClass;
    private final ClassLoader source;
    private final InstrumentationTypeRegistry typeRegistry;

    TestInstrumentedClassLoader(
        ClassLoader source,
        Predicate<String> shouldLoadTransformedClass,
        ClassTransform transform,
        InstrumentationTypeRegistry typeRegistry
    ) {

 * limitations under the License.
 */

package org.gradle.kotlin.dsl.resolver

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

/**
 * <p>A mapping provider that uses a transform for which {@link MappingProvider} cannot be used.
 * This implementation is used for user provided transforms and also for internal transforms that don't meet the constraints of {@link MappingProvider}.</p>
 *
 * <p>This provider checks that the contents of value have been built prior to running the transform, as the transform may use the content.

import java.util.jar.JarFile
import java.util.stream.Collectors

import org.gradle.api.artifacts.transform.TransformParameters

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath("me.lucko:jar-relocator:1.3")
    }
}

// tag::artifact-transform-relocate[]
@CacheableTransform                                                          // <1>

 */

package org.gradle.integtests.resolve.transform

import org.gradle.integtests.fixtures.AbstractDependencyResolutionTest
import spock.lang.Issue

class ArtifactTransformOfDirectoriesIntegrationTest extends AbstractDependencyResolutionTest implements ArtifactTransformTestFixture {
    @Issue("https://github.com/gradle/gradle/issues/15351")
    def "can transform a file dependency that contains a directory"() {