}
	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.

			.APIServer.CertSANs is an optional parameter for adding DNS names and IPs to the API Server serving cert SAN
			.Etcd.Local.ServerCertSANs is an optional parameter for adding DNS names and IPs to the etcd serving cert SAN
			.Etcd.Local.PeerCertSANs is an optional parameter for adding DNS names and IPs to the etcd peer cert SAN

		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

	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

        @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

    @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
    }

        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) }

    }

    private
    abstract class MyTopLevelReceiver {
        @Adding
        abstract fun addSomething(x: Int, configure: MyTopLevelReceiver.() -> Unit): MyTopLevelReceiver

        @Adding
        abstract fun addSomething(x: Int): MyTopLevelReceiver
    }

package com.example

import org.gradle.declarative.dsl.model.annotations.Adding
import org.gradle.declarative.dsl.model.annotations.Builder
import org.gradle.declarative.dsl.model.annotations.Restricted


class Abc {
    @get:Restricted
    var a: Int = 0

    @Restricted
    fun b(): Int = 1

    @get:Restricted
    var str: String = ""

    @Adding
    fun c(x: Int, configure: C.() -> Unit = { }) =
        C().apply {

// license that can be found in the LICENSE file.

// Test defer.

package main

import "fmt"

var result string

func addInt(i int) { result += fmt.Sprint(i) }

func test1helper() {
	for i := 0; i < 10; i++ {
		defer addInt(i)
	}
}

func test1() {
	result = ""
	test1helper()
	if result != "9876543210" {