when(mockReferralData.getKey()).thenReturn(key);
            doNothing().when(mockReferralData).setKey(key);

            mockReferralData.setKey(key);
            String retrievedKey = mockReferralData.getKey();

            assertEquals(key, retrievedKey);
            verify(mockReferralData, times(1)).setKey(key);
            verify(mockReferralData, times(1)).getKey();

        DocMap docMap = new DocMap(parentMap);

        assertNull(docMap.put("newKey", "newValue"));
        assertEquals("newValue", docMap.get("newKey"));

        assertEquals("newValue", docMap.put("newKey", "updatedValue"));
        assertEquals("updatedValue", docMap.get("newKey"));

        assertNull(docMap.get("nonexistent"));
    }

    public void test_remove() {

        // don't let the new entry get GCed
        warmed.add(entryOf(entry.getKey(), newValue));
        Object newKey = new Object();
        assertNull(cache.asMap().put(newKey, entry.getValue()));
        // this getUnchecked() call shouldn't be a cache miss; verified below
        assertEquals(newValue, cache.getUnchecked(entry.getKey()));

        // don't let the new entry get GCed
        warmed.add(entryOf(entry.getKey(), newValue));
        Object newKey = new Object();
        assertNull(cache.asMap().put(newKey, entry.getValue()));
        // this getUnchecked() call shouldn't be a cache miss; verified below
        assertEquals(newValue, cache.getUnchecked(entry.getKey()));

            }
            
            // Create new lease
            Smb2LeaseKey newKey = new Smb2LeaseKey();
            LeaseEntry newEntry = new LeaseEntry(newKey, path, requestedState);
            leases.put(newKey, newEntry);
            pathToLease.put(path, newKey);
            
            return newKey;
        } finally {
            lock.writeLock().unlock();
        }
    }
    

            // Create new lease
            Smb2LeaseKey newKey = new Smb2LeaseKey();
            LeaseEntry newEntry = new LeaseEntry(newKey, path, requestedState);
            leases.put(newKey, newEntry);
            pathToLease.put(path, newKey);

            log.debug("Created new lease for path: {} with key: {}", path, newKey);
            return newKey;
        } finally {
            lock.writeLock().unlock();

   * the position of the new key if it was previously present.
   */
  private void replaceKeyInEntry(int entry, @ParametricNullness K newKey, boolean force) {
    checkArgument(entry != ABSENT);
    int newKeyHash = Hashing.smearedHash(newKey);
    int newKeyIndex = findEntryByKey(newKey, newKeyHash);

    int newPredecessor = lastInInsertionOrder;
    int newSuccessor = ENDPOINT;
    if (newKeyIndex != ABSENT) {

        byte[] decrypted1 = context.decryptMessage(encrypted1);
        assertArrayEquals(plaintext1, decrypted1);

        // When - Rotate keys
        byte[] newKey = new byte[16];
        new SecureRandom().nextBytes(newKey);
        context.rotateKeys(newKey, newKey); // Use same key for test

        // Then - Can encrypt/decrypt with new keys
        byte[] plaintext2 = "After key rotation".getBytes();

     * Sets the DES encryption key
     * @param key the 8-byte DES key
     */
    public void setKey(final byte[] key) {

        // CHECK PAROTY TBD
        deskey(key, true, encryptKeys);
        deskey(key, false, decryptKeys);
    }

    // Turn an 8-byte key into internal keys.
    private void deskey(final byte[] keyBlock, final boolean encrypting, final int[] KnL) {

        int i, j, l, m, n;

        }

        @Test
        @DisplayName("Should get and set key")
        void testKey() {
            assertNull(referralData.getKey());
            referralData.setKey("cache-key-123");
            assertEquals("cache-key-123", referralData.getKey());
        }

        @Test
        @DisplayName("Should get server")
        void testGetServer() {
            assertNull(referralData.getServer());