assertThat(cache.asMap().containsKey(key)).isFalse();
      assertThat(cache.asMap().containsValue(value)).isFalse();
    }
  }

  public void testKeySetEntrySetValues() {
    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);

            // Check order by collecting keys in iteration order
            List<String> keys = new ArrayList<>(resultProps.keySet());

            // Verify the original insertion order is maintained
            assertEquals(3, keys.size());
            assertEquals("third", keys.get(0));
            assertEquals("first", keys.get(1));
            assertEquals("second", keys.get(2));
        }

        @Test

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

	if _, ok := lru.Get("key1"); ok {
		t.Errorf("Expected key1 to be removed, but it still exists")
	}
}

func TestLRU_Add_UnlimitedSize_NoEviction(t *testing.T) {
	lru := lru.NewLRU[string, int](0, nil, time.Hour)
	lru.Add("key1", 1)
	lru.Add("key2", 2)
	lru.Add("key3", 3)

	if _, ok := lru.Get("key1"); !ok {

        Smb2LeaseKey key1 = new Smb2LeaseKey(testBytes1);
        Smb2LeaseKey key2 = new Smb2LeaseKey(testBytes2);
        Smb2LeaseKey key3 = new Smb2LeaseKey(testBytes3);

        assertEquals(key1, key2);
        assertNotEquals(key1, key3);
        assertNotEquals(key1, null);
        assertNotEquals(key1, "not a lease key");
        assertEquals(key1, key1); // reflexive
    }

    @Test

		t.Fatal("Unmarshal: ", err)
	} else if len(jk.Keys) != 2 {
		t.Fatalf("Expected 2 keys, got %d", len(jk.Keys))
	}

	keys := make([]crypto.PublicKey, len(jk.Keys))
	for ii, jks := range jk.Keys {
		var err error
		keys[ii], err = jks.DecodePublicKey()
		if err != nil {
			t.Fatalf("Failed to decode key %d: %v", ii, err)
		}
	}

	//nolint:gocritic
	if key0, ok := keys[0].(*ecdsa.PublicKey); !ok {

      assertThat(cache.asMap().containsKey(key)).isFalse();
      assertThat(cache.asMap().containsValue(value)).isFalse();
    }
  }

  public void testKeySetEntrySetValues() {
    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);

            Smb2LeaseKey key3 = limitedManager.requestLease("/share/file3.txt", Smb2LeaseState.SMB2_LEASE_READ_CACHING);

            // key3 should definitely exist (just created)
            assertNotNull(limitedManager.getLease(key3));

            // key1 should have been evicted (oldest)
            assertNull(limitedManager.getLease(key1));

            // key2 should still exist (not the oldest)

            KerberosKey[] keys = credentials.getKeys();
            assertEquals(0, keys.length);
        }
    }

    /**
     * Test getKey method when the requested key type exists.
     *
     * @throws LoginException if login fails.
     */
    @Test
    void testGetKey_KeyExists() throws LoginException {
        when(key1.getKeyType()).thenReturn(KEY_TYPE_1);

        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("");

        MavenProperties props = new MavenProperties();

    public void testGenerateRandomKey() {
        byte[] key1 = keyManager.generateRandomKey(32);
        byte[] key2 = keyManager.generateRandomKey(32);

        assertNotNull(key1, "Should generate key 1");
        assertNotNull(key2, "Should generate key 2");
        assertEquals(32, key1.length, "Key 1 should have correct length");
        assertEquals(32, key2.length, "Key 2 should have correct length");