*/
public abstract class InternalTransformers {

    /**
     * Creates a transformer that simply type casts the input to the given output type.
     *
     * @param outputType The type to cast the input to
     * @param <O> The type of the transformed object
     * @param <I> The type of the object to be transformed
     * @return A transformer that simply type casts the input to the given output type.
     */

     *
     * @param artifactTransformer A transformer applied to all artifacts and sub-variant artifacts.
     *
     * @return A copy of this metadata, with the given transformer applied to all artifacts.
     */

import org.apache.maven.model.building.ModelBuildingException;
import org.apache.maven.project.MavenProject;
import org.eclipse.aether.RepositorySystemSession;

/**
 * Transformed artifact is derived with some transformation from source artifact.
 *
 * @since TBD
 */
class TransformedArtifact extends DefaultArtifact {

    private static final int SHA1_BUFFER_SIZE = 8192;

                void beforeTransformExecution(Describable transformer, Describable subject) {
                    println "Before transformer \${transformer.displayName} on \${subject.displayName}"
                }

                @Override
                void afterTransformExecution(Describable transformer, Describable subject) {
                    println "After transformer \${transformer.displayName} on \${subject.displayName}"

        then:
        outputContains("files: [test-lib.jar, transformed-a1.jar, transformed-b2.jar, test-1.0.jar]")
        outputContains("components: [test-lib.jar, project :a, project :b, org:test:1.0]")
        outputContains("variants: [{artifactType=jar}, {artifactType=jar, buildType=debug, flavor=one, usage=transformed}, {artifactType=jar, usage=transformed}, {artifactType=jar, org.gradle.status=release}]")
    }

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Marker annotation attached to rule block closures at compile time to indicate they have been transformed.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface RulesBlock {

    /**
     * <p>Expands property references in each file as it is copied. More specifically, each file is transformed using
     * Groovy's {@link groovy.text.SimpleTemplateEngine}. This means you can use simple property references, such as
     * <code>$property</code> or <code>${property}</code> in the file. You can also include arbitrary Groovy code in the

        Model actual = transform(initial);
        assertTrue(equalsDeep(expected, actual));
    }

    Model transform(Model model) {
        Model transformed = model.clone();
        new BuildModelSourceTransformer().transform(pomFile, context, transformed);
        return transformed;
    }

    public static boolean equalsDeep(Object m1, Object m2) {
        try {
            if (m1 == m2) {
                return true;

    ImmutableAttributes getToAttributes();

    /**
     * Whether the transformer requires dependencies of the transformed artifact to be injected.
     */
    boolean requiresDependencies();

    /**
     * Whether the transformer requires {@link InputChanges} to be injected.
     */
    boolean requiresInputChanges();

    /**
     * Whether the transformer is cacheable.
     */
    boolean isCacheable();

        then:
        outputContains("files: [test-lib.jar, transformed-a1.jar, transformed-b2.jar, test-1.0.jar]")
        outputContains("components: [test-lib.jar, project :lib, project :ui, org:test:1.0]")
        outputContains("variants: [{artifactType=jar}, {artifactType=jar, buildType=debug, flavor=one, usage=transformed}, {artifactType=jar, usage=transformed}, {artifactType=jar, org.gradle.status=integration}]")
    }