return entry;
      }

      @Override
      public void remove() {
        checkState(toRemove != null, "no calls to next() since the last call to remove()");
        LinkedHashMultimap.this.remove(toRemove.getKey(), toRemove.getValue());
        toRemove = null;
      }
    };
  }

  @Override
  Iterator<V> valueIterator() {
    return Maps.valueIterator(entryIterator());
  }

  /**

            if (!holder.closed && !holder.isAlive()) {
                // Resource object has been garbage collected but not closed
                reportLeak(holder);
                activeResources.remove(entry.getKey());
                cleaned++;
            } else if (!holder.closed && holder.getAge() > maxResourceAge * 2) {
                // Very old unclosed resource - attempt to close it

      Collection<V> collection = null;
      while (asMapItr.hasNext()) {
        Entry<K, Collection<V>> asMapEntry = asMapItr.next();
        if (key.equals(asMapEntry.getKey())) {
          collection = asMapEntry.getValue();
          break;
        }
      }
      assertNotNull(collection);
      Collection<V> expectedCollection = copyToList(collection);

      Collection<V> collection = null;
      while (asMapItr.hasNext()) {
        Entry<K, Collection<V>> asMapEntry = asMapItr.next();
        if (key.equals(asMapEntry.getKey())) {
          collection = asMapEntry.getValue();
          break;
        }
      }
      assertNotNull(collection);
      Collection<V> expectedCollection = copyToList(collection);

                    NavigableMap<String, String> map = new SafeTreeMap<>();
                    for (Entry<String, String> entry : entries) {
                      map.put(entry.getKey(), entry.getValue());
                    }
                    return new StandardImplForwardingNavigableMap<>(map);
                  }
                })
            .named(

        for (Map.Entry<String, DirectoryCacheEntry> entry : directoryCache.entrySet()) {
            if (entry.getValue().isExpired()) {
                expiredPaths.add(entry.getKey());
            }
        }

        for (String path : expiredPaths) {
            log.debug("Cleaning up expired directory cache entry: {}", path);
            releaseDirectoryLease(path);
        }

    public Spliterator<K> spliterator() {
      return CollectSpliterators.map(multimap.entries().spliterator(), Map.Entry::getKey);
    }

    @Override
    public void forEach(Consumer<? super K> consumer) {
      checkNotNull(consumer);
      multimap.entries().forEach(entry -> consumer.accept(entry.getKey()));
    }

    @Override
    int distinctElements() {
      return multimap.asMap().size();
    }

      if (delegate != null) {
        return delegate.entrySet().contains(o);
      } else if (o instanceof Entry) {
        Entry<?, ?> entry = (Entry<?, ?>) o;
        int index = indexOf(entry.getKey());
        return index != -1 && Objects.equals(value(index), entry.getValue());
      }
      return false;
    }

    @Override
    public boolean remove(@Nullable Object o) {

                try {
                    ((Destroyable) key).destroy();
                } catch (DestroyFailedException e) {
                    log.warn("Failed to destroy key for session {}: {}", entry.getKey(), e.getMessage());
                }
            }
        }
        sessionKeys.clear();

        // Clear KeyStore entries
        if (keyStore != null) {
            try {

        searchBody.put("size", SEARCH_ALL_NUM);
        for (Map.Entry<String, Object> entry : updateMap.entrySet()) {
            List<String> updatedList = getPropList(searchBody, entry.getKey());
            for (String val : updatedList) {
                assertEquals(entry.getValue().toString(), val);
            }
        }
    }

    protected void testDelete() {