}

  public void testIteratorPastEndException() {
    MinMaxPriorityQueue<Integer> mmHeap = MinMaxPriorityQueue.create();
    mmHeap.addAll(Lists.newArrayList(1, 2));
    Iterator<Integer> it = mmHeap.iterator();
    assertTrue("Iterator has reached end prematurely", it.hasNext());
    it.next();
    it.next();
    assertThrows(NoSuchElementException.class, () -> it.next());
  }

        this.result = result;
        this.artifacts = Collections.unmodifiableSet(artifacts);
    }

    @Override
    public Iterator<Artifact> iterator() {
        return artifacts.iterator();
    }

    @Override
    public int size() {
        return artifacts.size();
    }

    @Override
    public DependencyResolutionResult getResult() {

    StringBuilder builder = new StringBuilder();
    Iterator<String> iterator = splitter.split(builder).iterator();

    builder.append("A,");
    assertThat(iterator.next()).isEqualTo("A");
    builder.append("B,");
    assertThat(iterator.next()).isEqualTo("B");
    builder.append("C");
    assertThat(iterator.next()).isEqualTo("C");
    assertFalse(iterator.hasNext());
  }

      return original.size();
    }

    @Override
    public Collection<V> values() {
      return original.values();
    }

    @Override
    Iterator<Cell<C, R, V>> cellIterator() {
      return Iterators.transform(original.cellSet().iterator(), Tables::transposeCell);
    }

    @Override
    @GwtIncompatible // Spliterator
    Spliterator<Cell<C, R, V>> cellSpliterator() {

  }

  @Override
  public TestSubjectGenerator<? extends Iterable<E>> getInnerGenerator() {
    return collectionGenerator;
  }

  @Override
  public Iterator<E> get() {
    return collectionGenerator.createTestSubject().iterator();
  }

            MutableClassToInstanceMap::checkedEntry);
      }

      @Override
      public Iterator<Entry<Class<? extends @NonNull B>, B>> iterator() {
        return new TransformedIterator<
            Entry<Class<? extends @NonNull B>, B>, Entry<Class<? extends @NonNull B>, B>>(
            delegate().iterator()) {
          @Override
          Entry<Class<? extends @NonNull B>, B> transform(

    this.map = map;
  }

  @Override
  public int size() {
    return map.size();
  }

  @Override
  public UnmodifiableIterator<V> iterator() {
    return new UnmodifiableIterator<V>() {
      final UnmodifiableIterator<Entry<K, V>> entryItr = map.entrySet().iterator();

      @Override
      public boolean hasNext() {
        return entryItr.hasNext();
      }

      @Override
      public V next() {

  public void testAddAtIndexConcurrentWithIteration() {
    assertThrows(
        ConcurrentModificationException.class,
        () -> {
          Iterator<E> iterator = collection.iterator();
          getList().add(0, e3());
          iterator.next();
        });
  }

  @ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
  public void testAddAtIndex_unsupportedNotPresent() {

  }

  @Override
  UnmodifiableIterator<Entry<K, V>> entryIterator() {
    return new UnmodifiableIterator<Entry<K, V>>() {
      final Iterator<? extends Entry<K, ? extends ImmutableCollection<V>>> asMapItr =
          map.entrySet().iterator();
      @Nullable K currentKey = null;
      Iterator<V> valueItr = emptyIterator();

      @Override
      public boolean hasNext() {
        return valueItr.hasNext() || asMapItr.hasNext();

    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