* @param action the action to add
     */
    public void addAction(Action<? super T> action) {
        actions.add(action);
    }

    /**
     * Transforms a property list object. This will modify the
     * original.
     * @param original the property list to transform
     * @return the transformed property list
     */
    @Override

import org.gradle.api.Action;
import org.gradle.api.Transformer;
import org.gradle.api.UncheckedIOException;
import org.gradle.internal.MutableActionSet;

import java.io.IOException;
import java.io.OutputStream;
import java.util.Properties;

/**
 * Transformer implementation to support modification of Properties objects.
 */
public class PropertiesTransformer implements Transformer<Properties, Properties> {

        result.assertTasksNotSkipped(":b:producer", ":c:producer", ":a:resolve")
        transformed("b.jar", "c.jar")
        outputContains("result = [b.jar.green, c.jar.green]")

        when:
        succeeds(":a:resolve")

        then: // no change, should be up to date
        result.assertTasksNotSkipped(":a:resolve")
        transformed()
        outputContains("result = [b.jar.green, c.jar.green]")

        when:

        output.count("Transformed") == 2
        isTransformed("lib1.jar", "lib1.jar.value")
        isTransformed("lib2.jar", "lib2.jar.value")

        when:
        succeeds ":util:resolve", ":app:resolve"

        then:
        output.count("files 1: [lib1.jar.value, lib2.jar.value]") == 2

        output.count("Transformed") == 0

        where:
        type           | value

    }

    // Called from transformed DSL rules
    public void all(DeferredModelAction configAction) {
        mutateChildren(ModelActionRole.Initialize, elementType, configAction);
    }

    @Override
    public void beforeEach(Action<? super T> configAction) {
        mutateChildren(ModelActionRole.Defaults, elementType, "beforeEach()", configAction);
    }

    // Called from transformed DSL rules

    String getConsumerProjectPath();

    /**
     * The component identifier of the transformed artifact.
     */
    ComponentIdentifier getComponentId();

    /**
     * Full set of attributes of the artifact before the transform.
     */
    Map<String, String> getSourceAttributes();

    /**
     * Target attributes of the transformed artifact.
     * <p>

        then:
        result == transformed

        1 * attributeMatcher.matches(_, _, _) >> Collections.emptyList()
        1 * consumerProvidedVariantFinder.findTransformedVariants(variants, requestedAttributes) >> transformedVariants
        1 * factory.asTransformed(variant, transformedVariants[0].getTransformedVariantDefinition(), dependenciesResolverFactory, transformedVariantFactory) >> transformed
        0 * attributeMatcher._
    }

    def attachesLogLevelToTextOutputEvent() {
        StyledTextOutputEvent event = Mock()
        StyledTextOutputEvent transformed = Mock()

        when:
        listener.onOutput(event)

        then:
        1 * event.withLogLevel(LogLevel.LIFECYCLE) >> transformed
        1 * target.onOutput(transformed)
        0 * target._
    }

    def doesNotChangeLogLevelWhenEventAlreadyHasALogLevel() {

         *
         * @param original the original JAR or classes directory
         * @param transformed the transformed JAR or classes directory
         * @return this builder
         */
        public Builder add(File original, File transformed) {
            originals.add(original);
            if (!original.equals(transformed)) {

	}
}

type link struct {
	t Transformer
	// b[p:n] holds the bytes to be transformed by t.
	b []byte
	p int
	n int
}

func (l *link) src() []byte {
	return l.b[l.p:l.n]
}

func (l *link) dst() []byte {
	return l.b[l.n:]
}

// Chain returns a Transformer that applies t in sequence.
func Chain(t ...Transformer) Transformer {
	if len(t) == 0 {
		return nop{}
	}