}

    /**
     * Removes the mapping for a key from this map if it is present.
     *
     * @param key the key whose mapping is to be removed from the map
     * @return the previous value associated with key, or null if no mapping existed
     */
    @Override
    public Object remove(final Object key) {
        return parent.remove(key);
    }

    /**

        FileNotifyInformation removedFile = mock(FileNotifyInformation.class);
        when(removedFile.getAction()).thenReturn(FileNotifyInformation.FILE_ACTION_REMOVED);
        when(removedFile.getFileName()).thenReturn("removed.txt");

        FileNotifyInformation modifiedFile = mock(FileNotifyInformation.class);
        when(modifiedFile.getAction()).thenReturn(FileNotifyInformation.FILE_ACTION_MODIFIED);

   * one, stay the same, or even decrease by one.
   *
   * <p><b>Warning:</b> If an existing entry with this value is removed, the key for that entry is
   * discarded and not returned.
   *
   * @param key the key with which the specified value is to be associated
   * @param value the value to be associated with the specified key

   * Returns a fluent iterable whose {@code Iterator} cycles indefinitely over the elements of this
   * fluent iterable.
   *
   * <p>That iterator supports {@code remove()} if {@code iterable.iterator()} does. After {@code
   * remove()} is called, subsequent cycles omit the removed element, which is no longer in this
   * fluent iterable. The iterator's {@code hasNext()} method returns {@code true} until this fluent
   * iterable is empty.
   *

   * Returns a fluent iterable whose {@code Iterator} cycles indefinitely over the elements of this
   * fluent iterable.
   *
   * <p>That iterator supports {@code remove()} if {@code iterable.iterator()} does. After {@code
   * remove()} is called, subsequent cycles omit the removed element, which is no longer in this
   * fluent iterable. The iterator's {@code hasNext()} method returns {@code true} until this fluent
   * iterable is empty.
   *

        pendingOperations.add(operation);
    }

    /**
     * Remove a pending operation
     *
     * @param operation operation to remove
     * @return true if operation was removed
     */
    public boolean removePendingOperation(CommonServerMessageBlock operation) {
        return pendingOperations.remove(operation);
    }

    /**
     * Clear all pending operations
     */

    }

    @Override
    public void remove() {
      valueIterator.remove();
      /*
       * requireNonNull is safe because we've already initialized `collection`. If we hadn't, then
       * valueIterator.remove() would have failed.
       */
      if (requireNonNull(collection).isEmpty()) {
        keyIterator.remove();
      }
      totalSize--;
    }
  }

  /**

        )
      // Not much we can guarantee on JDK 11.
      PlatformVersion.majorVersion == 11 ->
        assertThat(s.enabledProtocols.toList()).contains(
          "TLSv1.2",
        )
      // JDK 8 291 removed older versions
      // See https://java.com/en/jre-jdk-cryptoroadmap.html
      PlatformVersion.majorVersion == 8 ->
        assertThat(s.enabledProtocols.toList()).contains(
          "TLSv1.2",
        )

        return channels.values().stream().filter(c -> c.getTransport() == transport).findFirst().orElse(null);
    }

    /**
     * Remove a channel
     *
     * @param channel channel to remove
     */
    public void removeChannel(ChannelInfo channel) {
        channels.remove(channel.getChannelId());
        try {
            if (channel.getTransport() != null) {
                channel.getTransport().close();

      K key = keys[entry];
      removeEntryValueHashKnown(entry, valueHash);
      return key;
    }
  }

  /** Removes the entry at the specified index with no additional data. */
  void removeEntry(int entry) {
    removeEntryKeyHashKnown(entry, Hashing.smearedHash(keys[entry]));
  }

  /** Removes the entry at the specified index, given the hash of its key and value. */