public E element() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.element();
    }

    @Override
    public Iterator<E> iterator() {
      // We explicitly don't lock for iterator()
      assertFalse(Thread.holdsLock(mutex));
      return delegate.iterator();
    }

    @Override
    public int size() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.size();
    }

          @Override
          public UnmodifiableIterator<EndpointPair<N>> iterator() {
            if (graph.isDirected()) {
              return Iterators.unmodifiableIterator(
                  Iterators.concat(
                      Iterators.transform(
                          graph.predecessors(node).iterator(),
                          (N predecessor) -> EndpointPair.ordered(predecessor, node)),

    this.outEdgeToNode = checkNotNull(outEdgeToNode);
    this.targetNode = checkNotNull(targetNode);
  }

  @Override
  public UnmodifiableIterator<E> iterator() {
    Iterator<? extends Entry<E, ?>> entries = outEdgeToNode.entrySet().iterator();
    return new AbstractIterator<E>() {
      @Override
      protected @Nullable E computeNext() {
        while (entries.hasNext()) {

	var paxHdrs map[string]string
	var gnuLongName, gnuLongLink string

	// Externally, Next iterates through the tar archive as if it is a series of
	// files. Internally, the tar format often uses fake "files" to add meta
	// data that describes the next file. These meta data "files" should not
	// normally be visible to the outside. As such, this loop iterates through
	// one or more "header files" until it finds a "normal file".

  }

  @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());

    }

    @Override
    public SortedMultiset<E> descendingMultiset() {
      return new StandardDescendingMultiset() {

        @Override
        Iterator<Entry<E>> entryIterator() {
          return backingMultiset.descendingMultiset().entrySet().iterator();
        }
      };
    }

    @Override
    public NavigableSet<E> elementSet() {
      return new StandardElementSet();
    }

    @Override

            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());

      }

      @Override
      public Iterator<Entry<E>> iterator() {
        return entryIterator();
      }

      @Override
      public int size() {
        return forwardMultiset().entrySet().size();
      }
    }
    return new EntrySetImpl();
  }

  @Override
  public Iterator<E> iterator() {
    return Multisets.iteratorImpl(this);
  }

  @Override

    assertEquals(rangeSet.asDescendingSetOfRanges().isEmpty(), rangeSet.isEmpty());
    assertEquals(!rangeSet.asRanges().iterator().hasNext(), rangeSet.isEmpty());
    assertEquals(!rangeSet.asDescendingSetOfRanges().iterator().hasNext(), rangeSet.isEmpty());

    List<Range<C>> asRanges = ImmutableList.copyOf(rangeSet.asRanges());

    // test that connected ranges are coalesced

package com.google.common.collect.testing;

import com.google.common.annotations.GwtCompatible;
import java.util.Iterator;

/**
 * Creates iterators to be tested.
 *
 * @param <E> the element type of the iterator.
 * @author George van den Driessche
 */
@GwtCompatible
public interface TestIteratorGenerator<E> {
  Iterator<E> get();