List<String> list = new ArrayList<String>()
list.add('org/gradle/api/**')
list.add('org/gradle/internal/**')
test.includes = list

// Map literal.
Map<String, String> map = [key1:'value1', key2: 'value2']

// Groovy will coerce named arguments
// into a single map argument
apply plugin: 'java'
// end::listAndMapLiterals[]

// tag::closureAsLastParam[]
repositories {
    println "in a closure"

    def "map preserves entries until keys in use"() {
        WeakIdentityHashMap<Thing, String> map = new WeakIdentityHashMap<>()

        Thing key1 = new Thing("Key1")
        Thing key2 = new Thing("Key2")


        when:
        map.put(key1, "Foo")
        map.put(key2, "Bar")

        then:
        map.keySet().every { it.get() != null }

        when:
        key1 = null
        key2 = null

//   - Each generated node is applied with a rotating label: "zone: zone[0-9]".
//   - Depending on the input labels, each generated pod will be applied with
//     label "key1", "key1,key2", ..., "key1,key2,...,keyN" in a rotating manner.
func MakeNodesAndPodsForEvenPodsSpread(labels map[string]string, existingPodsNum, allNodesNum, filteredNodesNum int) (existingPods []*v1.Pod, allNodes []*v1.Node, filteredNodes []*v1.Node) {

	Keys []Key `json:"keys"`
}

// Key contains name and secret of the provided key for a transformer.
type Key struct {
	// name is the name of the key to be used while storing data to disk.
	Name string `json:"name"`
	// secret is the actual key, encoded in base64.
	Secret string `json:"secret"`
}

// String implements Stringer interface in a log safe way.
func (k Key) String() string {

	}
	return NewBuiltin(keyID, key)
}

// NewBuiltin returns a single-key KMS that derives new DEKs from the
// given key.
func NewBuiltin(keyID string, key []byte) (*KMS, error) {
	if len(key) != 32 {
		return nil, errors.New("kms: invalid key length " + strconv.Itoa(len(key)))
	}
	return &KMS{
		Type:       Builtin,
		DefaultKey: keyID,
		conn: secretKey{
			keyID: keyID,
			key:   key,
		},

}

// SealedKey represents a sealed object key. It can be stored
// at an untrusted location.
type SealedKey struct {
	Key       [64]byte // The encrypted and authenticated object-key.
	IV        [32]byte // The random IV used to encrypt the object-key.
	Algorithm string   // The sealing algorithm used to encrypt the object key.
}

// Seal encrypts the ObjectKey using the 256 bit external key and IV. The sealed

	}
	g.Expect(keys[1]).To(Equal(expected))

	file = c.GetFileFor(keys[1])
	by, err = os.ReadFile(file)
	g.Expect(err).To(BeNil())
	g.Expect(strings.TrimSpace(string(by))).To(Equal(strings.TrimSpace(virtualService)))

	applyKeys := keys
	keys = c.AllKeys()
	g.Expect(keys).To(HaveLen(2))
	g.Expect(keys).To(ContainElement(applyKeys[0]))
	g.Expect(keys).To(ContainElement(applyKeys[1]))

        val entryPoint2 = Any()
        val key1 = Any()
        val key2 = Any()

        reporting.enterDynamicCall(entryPoint1)
        assertTrue(reporting.unreportedProblemInCurrentCall(key1))
        assertFalse(reporting.unreportedProblemInCurrentCall(key1))
        assertTrue(reporting.unreportedProblemInCurrentCall(key2))
        assertFalse(reporting.unreportedProblemInCurrentCall(key2))

apiVersion: apiserver.config.k8s.io/v1
resources:
  - resources:
      - secrets
    providers:
      - aesgcm:
          keys:
            - name: key1
              secret: c2VjcmV0IGlzIHNlY3VyZQ==
            - name: key2
              secret: dGhpcyBpcyBwYXNzd29yZA==
      - secretbox:
          keys:
            - name: key1
              secret: YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXoxMjM0NTY=
      - kms:
          name: testprovider

        expect:
        MavenDependencyKey key1 = new MavenDependencyKey('group-one', 'artifact-one', 'jar', 'sources')
        MavenDependencyKey key2 = new MavenDependencyKey(groupId, artifactId, type, classifier)
        strictlyEquals(key1, key2) == equality
        (key1.hashCode() == key2.hashCode()) == hashCode
        (key1.toString() == key2.toString()) == stringRepresentation

        where: