void removeCollectedEntry(ReferenceEntry<K, V> entry) {
      enqueueNotification(
          entry.getKey(),
          entry.getHash(),
          entry.getValueReference().get(),
          entry.getValueReference().getWeight(),
          RemovalCause.COLLECTED);
      writeQueue.remove(entry);
      accessQueue.remove(entry);
    }

    /** Removes an entry whose key has been garbage collected. */

  }

  private Entry<K, V>[] getEntriesMultipleNullKeys() {
    Entry<K, V>[] entries = createArrayWithNullKey();
    entries[0] = entry(null, entries[0].getValue());
    return entries;
  }

  private Entry<K, V>[] getEntriesMultipleNonNullKeys() {
    Entry<K, V>[] entries = createSamplesArray();
    entries[0] = entry(k1(), v0());
    return entries;
  }

    throw new UnsupportedOperationException();
  }

  /**
   * @since 12.0
   */
  @Override
  public void putAll(Map<? extends K, ? extends V> m) {
    for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
      put(entry.getKey(), entry.getValue());
    }
  }

  @Override
  public void cleanUp() {}

  @Override
  public long size() {
    throw new UnsupportedOperationException();
  }

    public DirectoryCacheEntry getCacheEntry(String directoryPath) {
        DirectoryCacheEntry entry = directoryCache.get(directoryPath);
        
        // Check if cache entry is valid
        if (entry != null && entry.needsRefresh()) {
            // Check if lease is still valid
            LeaseEntry leaseEntry = baseLeaseManager.getLease(entry.getLeaseKey());
            if (leaseEntry == null || !leaseEntry.hasReadCache()) {

                value = resourceName;
            }

            if (value != null) {
                for (final Map.Entry<Pattern, String> entry : passwordMap.entrySet()) {
                    if (entry.getKey().matcher(value).matches()) {
                        return entry.getValue();
                    }
                }
            }
        }

        if (params != null && url != null) {

            Optional<Map<String, String>> up = getter.apply(option);
            if (up.isPresent()) {
                had++;
                for (Map.Entry<String, String> entry : up.get().entrySet()) {
                    items.putIfAbsent(entry.getKey(), entry.getValue());
                }
            }
        }
        return had == 0 ? Optional.empty() : Optional.of(Map.copyOf(items));
    }

        @DisplayName("Should encode entry with non-null buffer")
        void testEncode() throws NdrException {
            // Given: SAM entry with data
            samr.SamrSamEntry entry = new samr.SamrSamEntry();
            entry.idx = 1;
            entry.name = new rpc.unicode_string();
            entry.name.length = 4;
            entry.name.maximum_length = 6;
            entry.name.buffer = new short[] { 't', 'e', 's', 't' };

    // Store a local reference to the cache entry. If the backing map is immutable, this,
    // in combination with immutable cache entries, will ensure a thread-safe cache.
    CacheEntry<K, V> entry;

    // Check cache. We use == on purpose because it's cheaper and a cache miss is ok.
    entry = cacheEntry1;
    if (entry != null && entry.key == key) {
      return entry.value;
    }
    entry = cacheEntry2;

      this.builder = builder;
    }

    @Override
    protected Map<String, String> create(Entry<String, String>[] entries) {
      LocalCache<String, String> map = makeLocalCache(builder);
      for (Entry<String, String> entry : entries) {
        map.put(entry.getKey(), entry.getValue());
      }
      return map;
    }
  }

  @AndroidIncompatible // test-suite builders

              return values().asList().get(index + 1);
            });
    List<Entry<K, V>> expectedEntries = new ArrayList<>();
    for (Entry<K, V> entry : getSampleEntries()) {
      int index = keys().asList().indexOf(entry.getKey());
      expectedEntries.add(Helpers.mapEntry(entry.getKey(), values().asList().get(index + 1)));
    }
    expectContents(expectedEntries);
  }