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

        String expected = "1";
        doc.put("key1", expected);
        assertEquals(expected, DocumentUtil.getValue(doc, "key1", String.class));
        assertEquals(Integer.parseInt(expected), DocumentUtil.getValue(doc, "key1", Integer.class).intValue());
        assertEquals(Long.parseLong(expected), DocumentUtil.getValue(doc, "key1", Long.class).longValue());

        docMap.put("key1", "value1");
        docMap.put("key2", 123);
        docMap.put("key3", true);

        assertEquals(3, docMap.size());
        assertEquals("value1", docMap.get("key1"));
        assertEquals(123, docMap.get("key2"));
        assertEquals(true, docMap.get("key3"));

        assertTrue(docMap.containsKey("key1"));
        assertTrue(docMap.containsValue("value1"));

        facetQueryView.addQuery("key1", "query1");
        assertEquals(1, facetQueryView.getQueryMap().size());
        assertEquals("query1", facetQueryView.getQueryMap().get("key1"));

        facetQueryView.addQuery("key2", "query2");
        assertEquals(2, facetQueryView.getQueryMap().size());
        assertEquals("query2", facetQueryView.getQueryMap().get("key2"));

        // Test overwriting existing key

    public void test_overwriteValues() {
        dataStoreParams.put("key1", "originalValue");
        assertEquals("originalValue", dataStoreParams.get("key1"));

        dataStoreParams.put("key1", "newValue");
        assertEquals("newValue", dataStoreParams.get("key1"));

        dataStoreParams.put("key1", null);
        assertNull(dataStoreParams.get("key1"));
    }

    // Test multiple operations in sequence

        // Test with whitespace around keys and values
        value = "  key1  =  value1  \n  key2=value2\n";
        paramMap = ParameterUtil.parse(value);
        assertEquals(2, paramMap.size());
        assertEquals("value1", paramMap.get("key1"));
        assertEquals("value2", paramMap.get("key2"));

        // Test with empty lines and mixed whitespace
        value = "key1=value1\n\n\t\nkey2=value2\n \n";

        sourceMap.put("key1", "value1");
        sourceMap.put("key2", 123);
        sourceMap.put("key3", true);
        event.setSourceMap(sourceMap);

        Map<String, Object> result = event.toSource();
        assertNotNull(result);
        assertEquals(3, result.size());
        assertEquals("value1", result.get("key1"));
        assertEquals(123, result.get("key2"));

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

        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