queue.remove();
        }
      }
    }

    private static final class Event {
      private final Object event;
      private final Iterator<Subscriber> subscribers;

      private Event(Object event, Iterator<Subscriber> subscribers) {
        this.event = event;
        this.subscribers = subscribers;
      }
    }
  }

      }

      int oldCount = values.size();
      if (occurrences >= oldCount) {
        values.clear();
      } else {
        Iterator<V> iterator = values.iterator();
        for (int i = 0; i < occurrences; i++) {
          iterator.next();
          iterator.remove();
        }
      }
      return oldCount;
    }

    @Override
    public void clear() {
      multimap.clear();

        () -> {
          Iterator<String> iterator = values.iterator();
          iterator.next();
          iterator.remove();
        });

    Set<Entry<Integer, String>> entries = unmod.entrySet();
    assertThrows(
        UnsupportedOperationException.class,
        () -> {
          Iterator<Entry<Integer, String>> iterator = entries.iterator();
          iterator.next();

import java.io.InputStream;
import java.util.Iterator;
import org.jspecify.annotations.Nullable;

/**
 * An {@link InputStream} that concatenates multiple substreams. At most one stream will be open at
 * a time.
 *
 * @author Chris Nokleberg
 * @since 1.0
 */
@J2ktIncompatible
@GwtIncompatible
final class MultiInputStream extends InputStream {

  private final Iterator<? extends ByteSource> it;

    return delegateList().equals(obj);
  }

  @Override
  public int hashCode() {
    return delegateList().hashCode();
  }

  @Override
  public UnmodifiableIterator<E> iterator() {
    return Iterators.unmodifiableIterator(delegateList().iterator());
  }

  @Override
  public boolean contains(@Nullable Object object) {
    return object != null && delegateList().contains(object);
  }

  @Override

 *
 * <p>The ordering of the row and column keys provided when the table is constructed determines the
 * iteration ordering across rows and columns in the table's views. None of the view iterators
 * support {@link Iterator#remove}. If the table is modified after an iterator is created, the
 * iterator remains valid.
 *
 * <p>This class requires less memory than the {@link HashBasedTable} and {@link TreeBasedTable}

    }

    @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

    assertEqualInOrder(expected, multimap().values());
  }

  @CollectionFeature.Require(SUPPORTS_ITERATOR_REMOVE)
  @CollectionSize.Require(ONE)
  public void testValuesIteratorRemove() {
    Iterator<V> valuesItr = multimap().values().iterator();
    valuesItr.next();
    valuesItr.remove();
    assertTrue(multimap().isEmpty());
  }

        Set set = project1.getArtifacts();
        assertNotNull(set, "No artifacts");
        assertFalse(set.isEmpty(), "No Artifacts");
        Iterator iter = set.iterator();
        assertTrue(set.size() == 4, "Set size should be 4, is " + set.size());

        while (iter.hasNext()) {
            Artifact artifact = (Artifact) iter.next();

    private static void removeMatchingRepository(Iterable<RemoteRepository> repositories, final String id) {
        Iterator iterator = repositories.iterator();
        while (iterator.hasNext()) {
            RemoteRepository next = (RemoteRepository) iterator.next();
            if (next.getId().equals(id)) {
                iterator.remove();
            }
        }
    }

    @Override
    public ModelResolver newCopy() {