for (LoadingCache<Key, String> cache : caches()) {
      Key key1 = new Key(1);
      String value1 = key1.toString();
      Key key2 = new Key(2);
      String value2 = key2.toString();
      assertThat(cache.getUnchecked(key1)).isSameInstanceAs(value1);
      assertThat(cache.getUnchecked(key2)).isSameInstanceAs(value2);
      assertThat(cache.asMap().keySet()).isEqualTo(ImmutableSet.of(key1, key2));

	lru := lru.NewLRU[string, int](10, nil, time.Hour)
	lru.Add("key1", 1)
	lru.Add("key1", 2)

	if value, ok := lru.Get("key1"); !ok || value != 2 {
		t.Errorf("Expected value to be updated to 2, got %v", value)
	}
}

func TestLRU_Add_NewKey_AddsEntry(t *testing.T) {
	lru := lru.NewLRU[string, int](10, nil, time.Hour)
	lru.Add("key1", 1)

	if value, ok := lru.Get("key1"); !ok || value != 1 {

    for (LoadingCache<Key, String> cache : caches()) {
      Key key1 = new Key(1);
      String value1 = key1.toString();
      Key key2 = new Key(2);
      String value2 = key2.toString();
      assertThat(cache.getUnchecked(key1)).isSameInstanceAs(value1);
      assertThat(cache.getUnchecked(key2)).isSameInstanceAs(value2);
      assertThat(cache.asMap().keySet()).isEqualTo(ImmutableSet.of(key1, key2));

        pw.println("");
        pw.println("# Another comment");
        pw.println("");
        pw.println("# A value comment");
        pw.println("key1 = val1");
        pw.println("");
        pw.println("# Another value comment");
        pw.println("key2 = ${key1}/foo");
        pw.println("");
        pw.println("# A third comment");
        pw.println("key3 = val3");
        pw.println("");

        assertEquals(100, builder.initialSettings.get("key2"));
        assertEquals(true, builder.initialSettings.get("key3"));

        // Test overwriting existing setting
        builder.addInitialSettings("key1", "newValue1");
        assertEquals(3, builder.initialSettings.size());
        assertEquals("newValue1", builder.initialSettings.get("key1"));
    }

    @Test

        String sessionId1 = "session-1";
        String sessionId2 = "session-2";

        byte[] key1 = new byte[16];
        byte[] key2 = new byte[16];
        new SecureRandom().nextBytes(key1);
        new SecureRandom().nextBytes(key2);

        keyManager.storeSessionKey(sessionId1, key1, "AES");
        keyManager.storeSessionKey(sessionId2, key2, "AES");

      int maxCount = (int) (4 * Math.log(2 * keyBits * hashBits) + 1);
      while (same != 0xffffffff || diff != 0xffffffff) {
        int key1 = rand.nextInt();
        // flip input bit for key2
        int key2 = key1 ^ (1 << i);
        // get hashes
        int hash1 = function.hashInt(key1).asInt();
        int hash2 = function.hashInt(key2).asInt();
        // test whether the hash values have same output bits

      int maxCount = (int) (4 * Math.log(2 * keyBits * hashBits) + 1);
      while (same != 0xffffffff || diff != 0xffffffff) {
        int key1 = rand.nextInt();
        // flip input bit for key2
        int key2 = key1 ^ (1 << i);
        // get hashes
        int hash1 = function.hashInt(key1).asInt();
        int hash2 = function.hashInt(key2).asInt();
        // test whether the hash values have same output bits

    async def get_model_a(name: str, model_c=Depends(get_model_c)):
        return {
            "name": name,
            "description": "model-a-desc",
            "foo": model_c,
            "tags": {"key1": "value1", "key2": "value2"},
        }

    client = TestClient(app)
    return client


def test_filter_sub_model(client: TestClient):
    response = client.get("/model/modelA")

 * for the following multimap definition:
 *
 * {@snippet :
 * Multimap<K, V> multimap = LinkedListMultimap.create();
 * multimap.put(key1, foo);
 * multimap.put(key2, bar);
 * multimap.put(key1, baz);
 * }
 *
 * ... the iteration order for {@link #keys()} is {@code [key1, key2, key1]}, and similarly for
 * {@link #entries()}. Unlike {@link LinkedHashMultimap}, the iteration order is kept consistent