*/

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

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

package org.gradle.kotlin.dsl.fixtures


fun <T> Iterable<T>.joinLines(transform: (T) -> String) =

     * 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

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
import org.gradle.api.tasks.Input
import org.gradle.api.tasks.PathSensitive
import org.gradle.api.tasks.PathSensitivity
import java.io.BufferedOutputStream

        @Override
        public O transform(I input) {
            return Cast.cast(outputType, input);
        }
    }

    public static <T> InternalTransformer<String, T> asString() {
        return new ToStringTransformer<T>();
    }

    private static class ToStringTransformer<T> implements InternalTransformer<String, T> {
        @Override
        public String transform(T original) {

    }

    def "does not report transform progress events when TRANSFORM operations are not requested"() {
        given:
        withFileSizerTransform()

        when:
        runBuild("resolve", EnumSet.complementOf(EnumSet.of(OperationType.TRANSFORM)))

        then:
        events.operations.findAll { it.transform }.empty
    }

    def "reports dependencies of transform operations"() {
        given:

    void testCompileClasspathTransform() throws Exception {
        ClasspathContainer res;

        res = transform.transform(graph, ArtifactScopeEnum.compile, false);

        assertNotNull(res, "null classpath container after compile transform");
        assertNotNull(res.getClasspath(), "null classpath after compile transform");
        assertEquals(3, res.getClasspath().size(), "compile classpath should have 3 entries");
    }

 * limitations under the License.
 */

package org.gradle.tooling.events.transform.internal;

import org.gradle.tooling.events.internal.DefaultFinishEvent;
import org.gradle.tooling.events.transform.TransformFinishEvent;
import org.gradle.tooling.events.transform.TransformOperationDescriptor;
import org.gradle.tooling.events.transform.TransformOperationResult;

                    entry.name.substringBeforeLast('/').replace('/', '.')
                }
                .collect(Collectors.toSet())
        }
    }
// tag::artifact-transform-relocate[]
}
// end::artifact-transform-relocate[]

configurations.create("externalClasspath")

val usage = Attribute.of("usage", String::class.java)
val artifactType = Attribute.of("artifactType", String::class.java)

 * This is the artifact that the transform is applied to.
 *
 * <p>The abstract getter must be declared as type {@link Provider}&lt;{@link org.gradle.api.file.FileSystemLocation}&gt;.</p>
 *
 * <p>Example usage:</p>
 *
 * <pre class='autoTested'>
 * import org.gradle.api.artifacts.transform.TransformParameters;
 *