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));
      assertThat(cache.asMap().values()).containsExactly(value1, value2);

        assertTrue(dataStoreParams.containsKey("key1"));

        dataStoreParams.put("key2", null);
        assertTrue(dataStoreParams.containsKey("key2"));
    }

    // Test putAll
    @Test
    public void test_putAll() {
        Map<String, String> map = new HashMap<>();
        map.put("key1", "value1");
        map.put("key2", "value2");
        map.put("key3", "value3");

        dataStoreParams.putAll(map);

        DocMap docMap = new DocMap(parentMap);

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

	}
	if !ok {
		t.Fatalf("should be true")
	}

	if !lc.Contains("key1") {
		t.Fatalf("should contain key1")
	}
	if lc.Contains("key2") {
		t.Fatalf("should not contain key2")
	}

	v, ok = lc.Peek("key2")
	if v != "" {
		t.Fatalf("should be empty")
	}
	if ok {
		t.Fatalf("should be false")
	}

	if !reflect.DeepEqual(lc.Keys(), []string{"key1"}) {

        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"));
        assertEquals(true, result.get("key3"));

        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");
        assertFalse(Arrays.equals(key1, key2), "Random keys should be different");
    }

    @Test
    void testGetKey_KeyExists() throws LoginException {
        when(key1.getKeyType()).thenReturn(KEY_TYPE_1);
        when(key2.getKeyType()).thenReturn(KEY_TYPE_2);
        Set<Object> privateCredentials = new HashSet<>();
        privateCredentials.add(key1);
        privateCredentials.add(key2);
        when(subject.getPrivateCredentials()).thenReturn(privateCredentials);

        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
        facetQueryView.addQuery("key1", "query1_updated");

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

                DirectoryCacheScope.IMMEDIATE_CHILDREN);

        Smb2LeaseKey key2 =
                directoryLeaseManager.requestDirectoryLease(dir2, DirectoryLeaseState.DIRECTORY_FULL, DirectoryCacheScope.RECURSIVE_TREE);

        assertNotNull(key1);
        assertNotNull(key2);
        assertNotEquals(key1, key2);

        // Verify both cache entries exist