assertTrue(
        removeIf(
            list,
            new Predicate<String>() {
              @Override
              public boolean apply(String s) {
                return s.equals("b") || s.equals("d") || s.equals("f");
              }
            }));
    assertEquals(newArrayList("a", "c", "e"), list);
    assertFalse(
        removeIf(
            list,

    assertTrue(
        removeIf(
            list,
            new Predicate<String>() {
              @Override
              public boolean apply(String s) {
                return s.equals("b") || s.equals("d") || s.equals("f");
              }
            }));
    assertEquals(newArrayList("a", "c", "e"), list);
    assertFalse(
        removeIf(
            list,

        // Clean up old failure records
        long now = System.currentTimeMillis();
        lastFailureTimes.entrySet().removeIf(entry -> now - entry.getValue() > FAILURE_RECOVERY_TIME * 2);

        // Clean up old consecutive failure counters
        consecutiveFailures.entrySet().removeIf(entry -> {
            String key = entry.getKey();
            Long lastFailure = lastFailureTimes.get(key);

        // Clean up account attempts
        accountAttempts.entrySet().removeIf(entry -> {
            AccountAttempts account = entry.getValue();
            return !account.isLockedOut() && account.getLastAttempt().plus(cleanupInterval).isBefore(now);
        });

        // Clean up IP attempts
        ipAttempts.entrySet().removeIf(entry -> {
            IpAttempts ip = entry.getValue();

  @Override
  public final boolean removeAll(Collection<?> oldElements) {
    throw new UnsupportedOperationException();
  }

  @Override
  public final boolean removeIf(Predicate<? super E> predicate) {
    throw new UnsupportedOperationException();
  }

  @Override
  public final boolean retainAll(Collection<?> elementsToKeep) {
    throw new UnsupportedOperationException();
  }

  @Override
  public final void clear() {

   * removeFrom.removeIf(predicate)} instead.
   *
   * @param removeFrom the iterable to (potentially) remove elements from
   * @param predicate a predicate that determines whether an element should be removed
   * @return {@code true} if any elements were removed from the iterable
   * @throws UnsupportedOperationException if the iterable does not support {@code remove()}.
   * @since 2.0
   */

                } else {
                    // Remove failed handle
                    handles.remove(path);
                    guidToHandle.remove(info.getCreateGuid());
                    removePersistedHandle(info);
                    log.warn("Reconnection failed, removed handle for: {}", path);
                }
            }
        } finally {

   * removeFrom.removeIf(predicate)} instead.
   *
   * @param removeFrom the iterable to (potentially) remove elements from
   * @param predicate a predicate that determines whether an element should be removed
   * @return {@code true} if any elements were removed from the iterable
   * @throws UnsupportedOperationException if the iterable does not support {@code remove()}.
   * @since 2.0
   */

   * otherwise, this method returns false.
   */
  boolean remove(K key, long value) {
    return map.remove(key, value);
  }

  /**
   * Atomically remove {@code key} from the map iff its associated value is 0.
   *
   * @since 20.0
   */
  @CanIgnoreReturnValue
  public boolean removeIfZero(K key) {
    return remove(key, 0);
  }

  /**

        }
    }

    /**
     * Removes all channels for a session.
     *
     * @param sessionId the session identifier
     */
    public void removeChannels(String sessionId) {
        ChannelGroup channelGroup = sessionChannels.remove(sessionId);
        if (channelGroup != null) {
            for (ChannelInfo channel : channelGroup.getChannels()) {