*
   * @throws UnsupportedOperationException if this range set does not support the {@code add}
   *     operation
   */
  void add(Range<C> range);

  /**
   * Removes the specified range from this {@code RangeSet} (optional operation). After this
   * operation, if {@code range.contains(c)}, {@code this.contains(c)} will return {@code false}.
   *
   * <p>If {@code range} is empty, this is a no-op.

    return appendTo(appendable, parts.iterator());
  }

  /**
   * Appends the string representation of each of {@code parts}, using the previously configured
   * separator between each, to {@code appendable}.
   *
   * @since 11.0
   */
  @CanIgnoreReturnValue
  public <A extends Appendable> A appendTo(A appendable, Iterator<?> parts) throws IOException {
    checkNotNull(appendable);

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

/**
 * An iterator that does not support {@link #remove}.
 *
 * <p>{@code UnmodifiableIterator} is used primarily in conjunction with implementations of {@link
 * ImmutableCollection}, such as {@link ImmutableList}. You can, however, convert an existing

 *   <li>The {@code copyOf} methods will sometimes recognize that the actual copy operation is
 *       unnecessary; for example, {@code copyOf(copyOf(anArrayList))} should copy the data only
 *       once. This reduces the expense of habitually making defensive copies at API boundaries.
 *       However, the precise conditions for skipping the copy operation are undefined.

          final Method getAllStatesMethod =
              getOnlyElement(asList(ConcurrentlyMutatedList.class.getDeclaredMethods()));

          final Iterator<ListFrobber> remainingActions = actionsToPerformConcurrently.iterator();

          final Set<List<Integer>> allStates = new HashSet<>();

          @Override
          public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        });

        // 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")

    }
    return new RegularImmutableList<E>(elements, length);
  }

  ImmutableList() {}

  // This declaration is needed to make List.iterator() and
  // ImmutableCollection.iterator() consistent.
  @Override
  public UnmodifiableIterator<E> iterator() {
    return listIterator();
  }

  @Override
  public UnmodifiableListIterator<E> listIterator() {
    return listIterator(0);
  }

    } else {
      return RegularImmutableMultiset.create(entries);
    }
  }

  ImmutableMultiset() {}

  @Override
  public UnmodifiableIterator<E> iterator() {
    Iterator<Entry<E>> entryIterator = entrySet().iterator();
    return new UnmodifiableIterator<E>() {
      int remaining;
      @Nullable E element;

      @Override
      public boolean hasNext() {

import com.google.common.annotations.GwtCompatible;
import com.google.errorprone.annotations.DoNotCall;
import java.util.ListIterator;
import org.jspecify.annotations.Nullable;

/**
 * A list iterator that does not support {@link #remove}, {@link #add}, or {@link #set}.
 *
 * @since 7.0
 * @author Louis Wasserman
 */
@GwtCompatible
public abstract class UnmodifiableListIterator<E extends @Nullable Object>

 *   <li>The {@code copyOf} methods will sometimes recognize that the actual copy operation is
 *       unnecessary; for example, {@code copyOf(copyOf(anArrayList))} should copy the data only
 *       once. This reduces the expense of habitually making defensive copies at API boundaries.
 *       However, the precise conditions for skipping the copy operation are undefined.