}

    void configureGarbageCollectionHeapEventsFor(long initial, long max, long leakRate, double gcRate) {
        configureGarbageCollectionEvents("heap", initial, max, leakRate, gcRate)
    }

    void configureGarbageCollectionNonHeapEventsFor(long initial, long max, long leakRate, double gcRate) {
        configureGarbageCollectionEvents("nonHeap", initial, max, leakRate, gcRate)
    }

        }

        class Rules extends RuleSource {
            static final $type<String> INITIAL = ['initial']

            @Model
            void createContainer(Container c) {
                c.items = INITIAL
            }

            @Mutate
            void addItems(Container c) {
                assert !c.items.is(INITIAL)
                c.items.add 'foo'
            }

            @Mutate

import java.io.File;

/**
 * Transform subject is either an initial artifact for the transform chain or a result of a previous transform step.
 */
public abstract class TransformStepSubject implements Describable {

    public static TransformStepSubject initial(ResolvableArtifact artifact) {
        return new Initial(artifact);
    }

    /**
     * The files which should be transformed.
     */

        evenDeeperRepo.file('foo').text = "baz"
        evenDeeperRepo.commit('initial commit', "foo")
        deeperRepo.file('foo').text = "bar"
        deeperRepo.commit("initial commit", "foo")
        // Add submodule to repo
        deeperRepo.addSubmodule(evenDeeperRepo)
        repo.addSubmodule(deeperRepo)
        def commit = repo.commit('initial commit')

        settingsFile << """
            sourceControl {

                        .version("1.0-SNAPSHOT")
                        .build()))
                .build());
        Model actual = transform(initial);
        assertTrue(equalsDeep(expected, actual));
    }

    @Test
    void testCiFriendlyVersion() {
        Model initial = new Model(org.apache.maven.api.model.Model.newBuilder()
                .version("${revision}-${sha1}")
                .build());

    - --cert-file=etcd/server.crt
    - --client-cert-auth=true
    - --data-dir=%s/etcd
    - --experimental-initial-corrupt-check=true
    - --experimental-watch-progress-notify-interval=5s
    - --initial-advertise-peer-urls=https://:2380
    - --initial-cluster==https://:2380
    - --key-file=etcd/server.key
    - --listen-client-urls=https://127.0.0.1:2379,https://:2379

// NewWriteOnce makes a new thread-safe WriteOnce.
//
// If `initial` is non-nil then that value is Set at creation time.
//
// If a `Get` is waiting soon after the channel associated with the
// `doneCtx` becomes selectable (which never happens for the nil
// channel) then `Set(doneVal)` effectively happens at that time.
func NewWriteOnce(initial interface{}, doneCtx context.Context, doneVal interface{}) WriteOnce {
	p := &promise{

                                println "BEFORE GC"
                                println "heap: \${format(heap.used)} (initial \${format(heap.init)}, committed \${format(heap.committed)}, max \${format(heap.max)}"
                                println "nonHeap: \${format(nonHeap.used)} (initial \${format(nonHeap.init)}, committed \${format(nonHeap.committed)}, max \${format(nonHeap.max)}"

        this.idFactory = idFactory;
    }

    /**
     * Create an initial transform step node.
     */
    public TransformStepNode.InitialTransformStepNode createInitial(
        ComponentVariantIdentifier targetComponentVariant,
        AttributeContainer sourceAttributes,
        TransformStep initial,
        ResolvableArtifact artifact,
        TransformUpstreamDependencies upstreamDependencies,

                params = parameters
                parameters.initial = 10
            }

            assert params.initial.get() == 10
            params.initial = 12

            task first {
                doFirst {
                    params.initial = 15 // should have an effect
                    provider.get().reset()
                    params.initial = 1234 // should be ignored. Ideally should fail too