Comparator<? super E> comparator, Iterator<? extends E> elements) {
    checkNotNull(comparator);
    return new Builder<E>(comparator).addAll(elements).build();
  }

  /**
   * Returns an immutable sorted multiset containing the given elements sorted by the given {@code
   * Comparator}. This method iterates over {@code elements} at most once.
   *

   * that approach would not lead to an infinite loop.
   *
   * @since 7.0
   */
  protected @Nullable V standardRemove(@Nullable Object key) {
    Iterator<Entry<K, V>> entryIterator = entrySet().iterator();
    while (entryIterator.hasNext()) {
      Entry<K, V> entry = entryIterator.next();
      if (Objects.equals(entry.getKey(), key)) {
        V value = entry.getValue();
        entryIterator.remove();

      @Override
      public Iterator<T> iterator() {
        if (iterable instanceof List) {
          List<T> list = (List<T>) iterable;
          int toSkip = Math.min(list.size(), numberToSkip);
          return list.subList(toSkip, list.size()).iterator();
        }
        Iterator<T> iterator = iterable.iterator();

        Iterators.advance(iterator, numberToSkip);

        /*

        });

        // When: Create iterator with rejecting filter
        NetServerEnumIterator iterator = new NetServerEnumIterator(parent, treeHandle, "*", 0, nameFilter);

        // Then: Iterator should have no elements
        assertFalse(iterator.hasNext());

        // Cleanup
        iterator.close();
    }

    @Test
    @DisplayName("Iterator should handle filter that throws CIFSException")

    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      StringBuilder sb = new StringBuilder();
      Iterator<String> iterator = components.iterator();
      if (iterator.hasNext()) {
        sb.append(iterator.next().toString());
        while (iterator.hasNext()) {
          sb.append(DELIMITER_STRING);
          sb.append(iterator.next());
        }
      }
      dummy ^= sb.toString().length();
    }
    return dummy;
  }

   * contains(). Verify that these sets are consistent with the elements of their iterator.
   */
  @CanIgnoreReturnValue
  static <T> Set<T> sanityCheckSet(Set<T> set) {
    assertThat(set).hasSize(Iterators.size(set.iterator()));
    for (Object element : set) {
      assertThat(set).contains(element);
    }
    assertThat(set).doesNotContain(new Object());

        assertEquals(2, set.size());
        Iterator<Entry<String, String>> iterator = set.iterator();
        assertNotNull(iterator);
        assertTrue(iterator.hasNext(), "Expected " + iterator + ".hasNext() to return true");
        assertTrue(iterator.hasNext(), "Expected " + iterator + ".hasNext() to return true");
        Entry<String, String> entry = iterator.next();
        assertNotNull(entry);

    assertNextThrows(iterator);

    /* Checks the case where a later element throws an exception. */

    list = Lists.newArrayList(1, 2);
    iterator = peekingIterator(new ThrowsAtEndIterator<Integer>(list));
    assertTrue(iterator.hasNext());
    iterator.next();
    assertTrue(iterator.hasNext());
    iterator.next();
    assertNextThrows(iterator);
  }

  private void assertNextThrows(Iterator<?> iterator) {

      @Override
      protected Iterator<E> newTargetIterator() {
        resetCollection();
        return collection.iterator();
      }

      @Override
      protected void verify(List<E> elements) {
        expectContents(elements);
      }
    }.test();
  }

  public void testIteratorNoSuchElementException() {
    Iterator<E> iterator = collection.iterator();
    while (iterator.hasNext()) {

                    boolean notified = false;
                    final Iterator<Entry<Long, Response>> iterator = this.response_map.entrySet().iterator();
                    while (iterator.hasNext()) {
                        final Response resp = iterator.next().getValue();
                        resp.exception(ex);
                        iterator.remove();
                        notified = true;

                    }