@SuppressWarnings("unchecked") // it's definitely equal to a K
      K k = (K) key;
      List<V> result = new ArrayList<>();
      Iterator<V> itr = collection.iterator();
      while (itr.hasNext()) {
        V v = itr.next();
        if (satisfies(k, v)) {
          itr.remove();
          result.add(v);
        }
      }
      if (result.isEmpty()) {
        return null;

  @Override
  public Iterator<E> iterator() {
    return new Itr(toArray());
  }

  /** Snapshot iterator that works off copy of underlying q array. */
  private class Itr implements Iterator<E> {
    final Object[] array; // Array of all elements
    int cursor; // index of next element to return;
    int lastRet; // index of last element, or -1 if no such

    Itr(Object[] array) {
      lastRet = -1;

    }

    @Override
    public boolean removeAll(Collection<?> collection) {
      boolean changed = false;
      Iterator<E> itr = unfiltered.iterator();
      while (itr.hasNext()) {
        E e = itr.next();
        if (predicate.apply(e) && collection.contains(e)) {
          itr.remove();
          changed = true;
        }
      }
      return changed;
    }

    @Override

  @Override
  public Iterator<E> iterator() {
    Monitor monitor = this.monitor;
    monitor.enter();
    try {
      return new Itr();
    } finally {
      monitor.leave();
    }
  }

  /** Iterator for MonitorBasedArrayBlockingQueue */
  private class Itr implements Iterator<E> {
    /** Index of element to be returned by next, or a negative number if no such. */
    private int nextIndex;

    /**

   */
  int adjustAfterRemove(int indexBeforeRemove, @SuppressWarnings("unused") int indexRemoved) {
    return indexBeforeRemove - 1;
  }

  private abstract class Itr<T extends @Nullable Object> implements Iterator<T> {
    int expectedMetadata = metadata;
    int currentIndex = firstEntryIndex();
    int indexToRemove = -1;

    @Override
    public boolean hasNext() {

      collection.clear();
      totalSize -= count;
    }
  }

  private abstract class Itr<T extends @Nullable Object> implements Iterator<T> {
    final Iterator<Entry<K, Collection<V>>> keyIterator;
    @Nullable K key;
    @Nullable Collection<V> collection;
    Iterator<V> valueIterator;

    Itr() {
      keyIterator = map.entrySet().iterator();
      key = null;
      collection = null;

        public static final String CACHE_ARTIFACT_NOT_FOUND = "canf";
        public static final String STRICT_ARTIFACT_DESCRIPTOR_POLICY = "sadp";
        public static final String IGNORE_TRANSITIVE_REPOSITORIES = "itr";
        public static final String AT_FILE = "af";

        @Override
        protected void prepareOptions(org.apache.commons.cli.Options options) {
            super.prepareOptions(options);

    this.delegate.replaceAll(function);
    inverse.delegate.clear();
    Entry<K, V> broken = null;
    Iterator<Entry<K, V>> itr = this.delegate.entrySet().iterator();
    while (itr.hasNext()) {
      Entry<K, V> entry = itr.next();
      K k = entry.getKey();
      V v = entry.getValue();
      K conflict = inverse.delegate.putIfAbsent(v, k);
      if (conflict != null) {

    public static final String CACHE_ARTIFACT_NOT_FOUND = "canf";

    public static final String STRICT_ARTIFACT_DESCRIPTOR_POLICY = "sadp";

    public static final String IGNORE_TRANSITIVE_REPOSITORIES = "itr";

    public static final String DEBUG = "debug";
    public static final String ENC = "enc";
    public static final String YJP = "yjp";

    protected Options options;

    assertEquals(ImmutableList.of(-1, 3, 5), result);
  }

  public void testLeastOfIterator_simple_nMinusOne_withNullElement() {
    Iterator<@Nullable Integer> itr = Iterators.forArray(3, null, 5, -1);
    List<@Nullable Integer> result = Ordering.<Integer>natural().nullsLast().leastOf(itr, 3);
    assertTrue(result instanceof RandomAccess);
    assertListImmutable(result);
    assertEquals(ImmutableList.of(-1, 3, 5), result);
  }