public void test_putAndGet() {
        dataStoreParams.put("key1", "value1");
        assertEquals("value1", dataStoreParams.get("key1"));

        dataStoreParams.put("key2", 123);
        assertEquals(123, dataStoreParams.get("key2"));

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

    // Test get for non-existent key
    public void test_getNonExistentKey() {

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

        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

            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)

        Smb2LeaseKey key1 = new Smb2LeaseKey();
        Smb2LeaseKey key2 = new Smb2LeaseKey();
        Smb2LeaseKey key3 = new Smb2LeaseKey();

        when(baseLeaseManager.requestLease(dir1, DirectoryLeaseState.DIRECTORY_READ_HANDLE)).thenReturn(key1);
        when(baseLeaseManager.requestLease(dir2, DirectoryLeaseState.DIRECTORY_READ_HANDLE)).thenReturn(key2);

        StringBuilder buf = new StringBuilder();

        monitorTarget.append(buf, "key1", () -> "value1");
        buf.append(",");
        monitorTarget.append(buf, "key2", () -> 123);
        buf.append(",");
        monitorTarget.append(buf, "key3", () -> null);

        assertEquals("\"key1\":\"value1\",\"key2\":123,\"key3\":null", buf.toString());
    }

    // Test append with empty string

        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

        dataMap.put("key1", "value1");
        dataMap.put("key2", "");
        dataMap.put("key3", null);

        // Test with existing value
        String result1 = (String) method.invoke(crawler, dataMap, "key1", "default");
        assertEquals("value1", result1);

        // Test with empty value
        String result2 = (String) method.invoke(crawler, dataMap, "key2", "default");

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

      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
        same |= ~(hash1 ^ hash2);