assertFalse(underlying.containsKey("b"));

    Iterator<String> keyIterator = keys.iterator();
    keyIterator.next();
    keyIterator.remove();
    assertFalse(underlying.containsKey("c"));

    Collection<String> values = map.values();
    values.remove("4");
    assertFalse(underlying.containsKey("d"));

    Iterator<String> valueIterator = values.iterator();
    valueIterator.next();
    valueIterator.remove();

        SmbFile parent = newParent();

        FileEntry invalid = entry(invalidName, SmbConstants.TYPE_SHARE);
        FileEntry valid = entry("ok", SmbConstants.TYPE_SHARE);
        Iterator<FileEntry> delegate = Arrays.asList(invalid, valid).iterator();

        ResourceFilter f = useFilter ? filter : null;
        if (useFilter) {
            when(filter.accept(any())).thenReturn(true);
        }

import com.google.common.collect.testing.features.CollectionFeature;
import java.lang.reflect.Method;
import java.util.Iterator;
import java.util.List;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
import org.junit.Ignore;

/**
 * Tester to make sure the {@code iterator().remove()} implementation of {@code Multiset} works when
 * there are multiple occurrences of elements.
 *

      @Override
      SortedMultiset<E> forwardMultiset() {
        return AbstractSortedMultiset.this;
      }

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

      @Override
      public Iterator<E> iterator() {
        return descendingIterator();
      }
    }
    return new DescendingMultisetImpl();
  }

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

/**
 * An iterator which forwards all its method calls to another iterator. Subclasses should override
 * one or more methods to modify the behavior of the backing iterator as desired per the <a
 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *

      }

      @Override
      Iterator<E> elementIterator() {
        throw new AssertionError("should never be called");
      }

      @Override
      Iterator<Entry<E>> entryIterator() {
        Iterator<? extends Entry<? extends E>> iterator1 = multiset1.entrySet().iterator();
        Iterator<? extends Entry<? extends E>> iterator2 = multiset2.entrySet().iterator();

      }

      @Override
      Iterator<E> elementIterator() {
        throw new AssertionError("should never be called");
      }

      @Override
      Iterator<Entry<E>> entryIterator() {
        Iterator<? extends Entry<? extends E>> iterator1 = multiset1.entrySet().iterator();
        Iterator<? extends Entry<? extends E>> iterator2 = multiset2.entrySet().iterator();

    Iterator<String> iterator = asList("a", "b", "a").iterator();
    List<String> list = ImmutableList.copyOf(iterator);
    assertEquals(asList("a", "b", "a"), list);
  }

  public void testCopyOf_iteratorContainingNull() {
    Iterator<@Nullable String> iterator =
        Arrays.<@Nullable String>asList("a", null, "b").iterator();
    assertThrows(

    KeySet(Map<K, Collection<V>> subMap) {
      super(subMap);
    }

    @Override
    public Iterator<K> iterator() {
      Iterator<Entry<K, Collection<V>>> entryIterator = map().entrySet().iterator();
      return new Iterator<K>() {
        @Nullable Entry<K, Collection<V>> entry;

        @Override
        public boolean hasNext() {
          return entryIterator.hasNext();

          return AsMap.this;
        }

        @Override
        public Iterator<Entry<K, Collection<V>>> iterator() {
          return new AbstractIterator<Entry<K, Collection<V>>>() {
            final Iterator<Entry<K, Collection<V>>> backingIterator =
                unfiltered.asMap().entrySet().iterator();

            @Override
            protected @Nullable Entry<K, Collection<V>> computeNext() {