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

        // Given
        byte[] encKey = new byte[16];
        byte[] decKey = new byte[16];
        new SecureRandom().nextBytes(encKey);
        new SecureRandom().nextBytes(decKey);

        // When using try-with-resources
        assertDoesNotThrow(() -> {
            try (Smb2EncryptionContext context = new Smb2EncryptionContext(1, DialectVersion.SMB311, encKey, decKey)) {

        assertThat(cache.asMap().replace(entry.getKey(), newValue))
            .isSameInstanceAs(entry.getValue());
        assertThat(cache.asMap().replace(entry.getKey(), newValue, entry.getValue())).isTrue();
        Object newKey = new Object();
        assertThat(cache.asMap().replace(newKey, entry.getValue())).isNull();
        assertThat(cache.asMap().replace(newKey, entry.getValue(), newValue)).isFalse();

            }
            
            // 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();
        }
    }
    

        // When
        byte[] encKey = Smb3KeyDerivation.deriveEncryptionKey(dialect, sessionKey, preauthIntegrity);

        // Then
        assertNotNull(encKey, "Encryption key should not be null");
        assertEquals(16, encKey.length, "Encryption key should be 16 bytes");
        assertFalse(Arrays.equals(sessionKey, encKey), "Encryption key should be different from session key");
    }

        try {
            int expectedKeyLength = getKeyLength();
            byte[] encKey = getEncryptionKey();
            byte[] decKey = getDecryptionKey();

            try {
                boolean valid =
                        encKey != null && encKey.length == expectedKeyLength && decKey != null && decKey.length == expectedKeyLength;
                return valid;
            } finally {

        decodedContext.decode(buffer, 0, buffer.length);

        // Verify decoded values
        assertArrayEquals(originalKey.getKey(), decodedContext.getLeaseKey().getKey());
        assertEquals(originalLeaseState, decodedContext.getLeaseState());
        assertEquals(originalScope, decodedContext.getCacheScope());
        assertEquals(60000L, decodedContext.getMaxCacheAge());

        Objects.requireNonNull(model, "model cannot be null");

        ClassLoader parent = getMavenApiRealm();

        return createRealm(getKey(model), RealmType.Project, parent, null, null, artifacts);
    }

    private static String getKey(Model model) {
        return "project>" + model.getGroupId() + ":" + model.getArtifactId() + ":" + model.getVersion();
    }

    @Override

      this.samples =
          new SampleElements<>(
              mapSamples.e0().getKey(),
              mapSamples.e1().getKey(),
              mapSamples.e2().getKey(),
              mapSamples.e3().getKey(),
              mapSamples.e4().getKey());
    }

    @Override
    public SampleElements<K> samples() {
      return samples;
    }

    @Override

    RangeMapEntry(Range<K> range, V value) {
      super(range, value);
    }

    boolean contains(K value) {
      return getKey().contains(value);
    }

    Cut<K> getLowerBound() {
      return getKey().lowerBound;
    }

    Cut<K> getUpperBound() {
      return getKey().upperBound;
    }
  }

  @Override
  public @Nullable V get(K key) {
    Entry<Range<K>, V> entry = getEntry(key);