buildFile << '''
            allprojects { p ->
                println "[1] Adding afterEvaluate for $p.name"
                p.afterEvaluate {
                    println "[1] afterEvaluate $p.name"
                }
            }

            project(':a') {
                println "[2] Adding evaluationDependsOn"
                evaluationDependsOn(':b')
            }

            allprojects { p ->

	N := 32
	for i := 0; i < N; i++ {
		q.enqueue(i)
		if n := q.len; n != i+1 {
			t.Fatalf("after adding %d elements, queue has len %d", i, n)
		}
		if v, ok := q.peek(); !ok {
			t.Fatalf("couldn't peek after adding %d elements", i)
		} else if v.(int) != 0 {
			t.Fatalf("after adding %d elements, peek is %d; want 0", i, v)
		}
	}

	// As we remove and add elements, len should shrink and grow.

        val addedObjects = mutableListOf<AddedObject>()

        @Adding
        @Suppress("unused")
        fun addSomething(x: Int, configure: AddedObject.() -> Unit): AddedObject =
            AddedObject("addSomething($x) { ... }")
                .also(configure)
                .also(addedObjects::add)

        @Adding
        fun addSomething(x: Int): AddedObject =
            AddedObject("addSomething($x)")

./mc mb sitec/bucket/
./mc version enable sitec/bucket/
./mc mb -l sitec/olockbucket

echo "adding replication rule for a -> b : ${remote_arn}"
sleep 1
./mc replicate add sitea/bucket/ \
	--remote-bucket http://minio:minio123@127.0.0.1:9004/bucket \
	--replicate "existing-objects,delete,delete-marker,replica-metadata-sync"
sleep 1

echo "adding replication rule for b -> a : ${remote_arn}"
./mc replicate add siteb/bucket/ \

	}
	keys, items, err = batch.GetAll()
	if err != nil {
		t.Fatalf("unable to get the items from the batch; %v", err)
	}
	if len(items) != 1 {
		t.Fatalf("Expected length of the batch items to be 1 but got %v", len(items))
	}
	if len(keys) != 1 {
		t.Fatalf("Expected length of the batch keys to be 1 but got %v", len(items))
	}
	// try adding again after Get.

		moduledata.AddAddr(ctxt.Arch, sym)
		moduledata.AddUint(ctxt.Arch, len)
		moduledata.AddUint(ctxt.Arch, len)
	}

	sliceSym := func(sym loader.Sym) {
		slice(sym, uint64(ldr.SymSize(sym)))
	}

	nilSlice := func() {
		moduledata.AddUint(ctxt.Arch, 0)
		moduledata.AddUint(ctxt.Arch, 0)
		moduledata.AddUint(ctxt.Arch, 0)
	}

	// The pcHeader

        @Configuring
        fun configuring(fn: InnerReceiver.() -> Unit)

        @Adding
        fun adding(fn: InnerReceiver.() -> Unit): InnerReceiver
    }

    interface InnerReceiver {
        @Restricted
        fun value(): Value

        @Restricted
        fun value(arg: Value): Value

        @Adding
        fun addingValue(value: Value): Value

        @get:Restricted

        then:
        env2.java.jvmArguments.contains(JVM_ARG_1)
        env2.java.jvmArguments.contains(JVM_ARG_2)
    }

    def "Adding zero JVM arguments is a no-op"() {
        expect:
        loadBuildEnvironment { builder -> builder.addJvmArguments() }
    }

    def "Adding null JVM argument throws NPE"() {
        when:
        loadBuildEnvironment { builder -> builder.addJvmArguments(null as String) }

	widths  []int    // list of column widths in runes - re-used during formatting
}

// addLine adds a new line.
// flushed is a hint indicating whether the underlying writer was just flushed.
// If so, the previous line is not likely to be a good indicator of the new line's cells.
func (b *Writer) addLine(flushed bool) {
	// Grow slice instead of appending,
	// as that gives us an opportunity

    @Suppress("unused")
    private
    abstract class Receiver {
        @Adding
        abstract fun lambdaRequired(x: Int, configure: Receiver.() -> Unit): Receiver

        @Adding
        abstract fun lambdaOptional(x: Int, configure: Receiver.() -> Unit = { }): Receiver

        @Adding
        abstract fun lambdaNotAllowed(x: Int): Receiver
    }