cache.put("key_1", 1);
        cache.put("key_2", 2);
        cache.put("key_3", 3);
        cache.put("key_4", 4);
        cache.put("key_5", 5);

        cache.put("key_1", 1);
        cache.put("key_4", 12);

        assertThat(cache.get("key_1"), equalTo(1));
        assertThat(cache.get("key_2"), equalTo(2));
        assertThat(cache.get("key_3"), equalTo(3));

            entry("org", "foo", "1.0", "foo-1.0.pom").addVerifiedKey(KEY_1)
            entry("org", "foo", "1.1", "foo-1.1.jar").addVerifiedKey(KEY_1)
            entry("org", "foo", "1.1", "foo-1.1.pom").addVerifiedKey(KEY_1)
        }

        when:
        executeGrouping()

        then:
        verifier.configuration.trustedKeys*.keyId == [KEY_1]
    }

[
 {
	 "key_1": "value",
	 "key_2": "value"
 }
]
[
	{
		"key_1": "value2",
		"key_2": "value3"
	}

		"metadata": {
			"name": "configmap"
		},
		"data": {
			"key_a": "value"
		}
	}`))
	if err != nil {
		t.Fatal(err)
	}
	err = updateObject(f, "fieldmanager_b_test", []byte(`{
		"apiVersion": "v1",
		"kind": "ConfigMap",
		"metadata": {
			"name": "configmap"
		},
		"data": {
			"key_b": "value"
		}
	}`))
	if err != nil {
		t.Fatal(err)
	}

# Tests handling dupliate functions after V1 control flow is functionalized.

# CHECK:  func {{.*}} tf_saved_model.exported_names = ["key_1"]
# CHECK: "tf.If"
# CHECK-SAME: else_branch = @[[else:[a-zA-Z_0-9]+]]
# CHECK-SAME: then_branch = @[[then:[a-zA-Z_0-9]+]]

# CHECK:  func {{.*}} tf_saved_model.exported_names = ["key_2"]
# CHECK: "tf.If"
# CHECK-SAME: else_branch = @[[else]]
# CHECK-SAME: then_branch = @[[then]]

[
 {
	 "key_1": "value",
	 "key_2": "value"
 }

-key2 'value2'
-key3 'value3'
""")
        when:
        optionsMap.put("locale", new StringJavadocOptionFileOption("locale", "alocale"));
        and:
        javadocOptionFileWriter.write(tempFile)
        then:
        tempFile.text == toPlatformLineSeparators("""-locale 'alocale'
-key1 'value1'
-key2 'value2'
-key3 'value3'
""")
    }

	}
	m[key[T1, T2]{v1, v2}]++
}

type key3[T1, T2, T3 comparable] struct {
	f1 T1
	f2 T2
	f3 T3
}

type Metric3[T1, T2, T3 comparable] struct {
	mu sync.Mutex
	m  map[key3[T1, T2, T3]]int
}

func (m *Metric3[T1, T2, T3]) Add(v1 T1, v2 T2, v3 T3) {
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.m == nil {
		m.m = make(map[key3]int)
	}
	m[key[T1, T2, T3]{v1, v2, v3}]++
}

        DefaultManifest nestedMergeManifest = new DefaultManifest(Mock(FileResolver)).attributes(key3: 'value3')
        mergeManifest.from(nestedMergeManifest)
        mergeSpec.from(mergeManifest)

        expect:
        mergeSpec.merge(baseManifest, Mock(FileResolver)).attributes == [key1: 'value1', key2: 'value2', key3: 'value3'] +
                MANIFEST_VERSION_MAP
    }

    def mergeWithChangeValueAction() {

	m.mu.Lock()
	defer m.mu.Unlock()
	if m.m == nil {
		m.m = make(map[key3[T1, T2, T3]]int)
	}
	m.m[key3[T1, T2, T3]{v1, v2, v3}]++
}

// Count returns the number of instances we've seen of v1/v2/v3.
func (m *_Metric3[T1, T2, T3]) Count(v1 T1, v2 T2, v3 T3) int {
	m.mu.Lock()
	defer m.mu.Unlock()
	return m.m[key3[T1, T2, T3]{v1, v2, v3}]
}

// Metrics returns all the values we've seen, in an indeterminate order.