sb.append(LS);
            sb.append(indentation);
            sb.append("Path to dependency: ");
            sb.append(LS);
            int num = 1;
            for (Iterator<String> i = path.iterator(); i.hasNext(); num++) {
                sb.append(indentation);
                sb.append('\t');
                sb.append(num);
                sb.append(") ");
                sb.append(i.next());

        if (r1.size() != r2.size()) {
            return false;
        }

        for (Iterator<ArtifactRepository> it1 = r1.iterator(), it2 = r2.iterator(); it1.hasNext(); ) {
            if (!repositoryEquals(it1.next(), it2.next())) {
                return false;
            }
        }

        return true;
    }

 * target iterators on demand. It also requires three additional constructor parameters: {@code
 * elementsToInsert}, the elements to be passed to {@code set()} and {@code add()} calls; {@code
 * features}, the features supported by the iterator; and {@code expectedElements}, the elements the
 * iterator should return in order.
 *

  }

  @CollectionSize.Require(absent = ZERO)
  @CollectionFeature.Require(SUPPORTS_ITERATOR_REMOVE)
  public void testKeySetIteratorRemove() {
    int key0Count = multimap().get(k0()).size();
    Iterator<K> keyItr = multimap().keySet().iterator();
    while (keyItr.hasNext()) {
      if (keyItr.next().equals(k0())) {
        keyItr.remove();
      }
    }
    assertEquals(getNumElements() - key0Count, multimap().size());

    resetContainer(mapEntry(k0(), v0()), mapEntry(k0(), v3()));
    Set<Entry<K, Collection<V>>> asMapEntrySet = multimap().asMap().entrySet();
    Iterator<Entry<K, Collection<V>>> asMapEntryItr = asMapEntrySet.iterator();
    asMapEntryItr.next();
    asMapEntryItr.remove();
    assertTrue(multimap().isEmpty());
  }

  }

  /**
   * Returns an iterator over the cache's current entries. This iterator doesn't throw
   * `ConcurrentModificationException`, but if new entries are added while iterating, those new
   * entries will not be returned by the iterator. If existing entries are removed during iteration,
   * they will be absent (unless they were already returned).
   *

   */
  public static <T extends @Nullable Object> boolean isInOrder(
      Iterable<? extends T> iterable, Comparator<T> comparator) {
    checkNotNull(comparator);
    Iterator<? extends T> it = iterable.iterator();
    if (it.hasNext()) {
      T prev = it.next();
      while (it.hasNext()) {
        T next = it.next();
        if (comparator.compare(prev, next) > 0) {
          return false;
        }

      @Override
      public UnmodifiableIterator<E> iterator() {
        Iterable<E> incidentEdges =
            (selfLoopCount == 0)
                ? Iterables.concat(inEdgeMap.keySet(), outEdgeMap.keySet())
                : Sets.union(inEdgeMap.keySet(), outEdgeMap.keySet());
        return Iterators.unmodifiableIterator(incidentEdges.iterator());
      }

      @Override
      public int size() {

    offerAll(elements.iterator());
  }

  /**
   * Adds each member of {@code elements} as a candidate for the top {@code k} elements. This
   * operation takes amortized linear time in the length of {@code elements}. The iterator is
   * consumed after this operation completes.
   *
   * <p>If all input data to this {@code TopKSelector} is in a single {@code Iterator}, prefer

import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.Iterator;
import java.util.NoSuchElementException;
import org.jspecify.annotations.Nullable;

/**
 * Note this class is a copy of {@link com.google.common.collect.AbstractIterator} (for dependency
 * reasons).
 */
@GwtCompatible
abstract class AbstractIterator<T extends @Nullable Object> implements Iterator<T> {
  private State state = State.NOT_READY;