return frequency;
    }

    @Override
    Iterator<E> elementIterator() {
      return Multisets.elementIterator(entryIterator());
    }

    @Override
    Iterator<Entry<E>> entryIterator() {
      Iterator<Map.Entry<E, Integer>> backingEntries = backingMap.entrySet().iterator();
      return new UnmodifiableIterator<Multiset.Entry<E>>() {
        @Override

        return DescendingMultiset.this;
      }

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

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

  @Override
  public Iterator<E> iterator() {
    return Multisets.iteratorImpl(this);
  }

  @Override

                @Override
                public Iterator<Entry<String, String>> iterator() {
                  return new Iterator<Entry<String, String>>() {

                    final Iterator<Entry<String, String>> iterator = map.entrySet().iterator();

                    @Override
                    public void remove() {
                      iterator.remove();
                    }

      }

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

      @Override
      public int size() {
        return forwardMultiset().entrySet().size();
      }
    }
    return new EntrySetImpl();
  }

  @Override
  public Iterator<E> iterator() {
    return Multisets.iteratorImpl(this);
  }

  @Override

     */
    public IteratorEnumeration(final Iterator<T> iterator) {
        assertArgumentNotNull("iterator", iterator);
        this.iterator = iterator;
    }

    /**
     * Creates an {@link IteratorEnumeration}.
     *
     * @param iterable the iterable object (must not be {@literal null})
     */
    public IteratorEnumeration(final Iterable<T> iterable) {

    @Override
    Multiset<E> multiset() {
      return AbstractMultiset.this;
    }

    @Override
    public Iterator<E> iterator() {
      return elementIterator();
    }
  }

  abstract Iterator<E> elementIterator();

  @LazyInit private transient @Nullable Set<Entry<E>> entrySet;

  @Override
  public Set<Entry<E>> entrySet() {

  public void testEntrySet_iteratorRemovePropagates() {
    Iterator<Multiset.Entry<E>> iterator = getMultiset().entrySet().iterator();
    assertTrue(
        "non-empty multiset.entrySet() iterator.hasNext() returned false", iterator.hasNext());
    assertEquals(
        "multiset.entrySet() iterator.next() returned incorrect entry",
        Multisets.immutableEntry(e0(), 1),
        iterator.next());
    assertFalse(

    Iterator<E> iterator = collection.iterator();
    assertSetCount(e3(), 1);
    assertThrows(ConcurrentModificationException.class, iterator::next);
  }

  @CollectionFeature.Require({SUPPORTS_ADD, FAILS_FAST_ON_CONCURRENT_MODIFICATION})
  public void testSetCountZeroToOneConcurrentWithEntrySetIteration() {
    Iterator<Entry<E>> iterator = getMultiset().entrySet().iterator();

      this.multiset = multiset;
    }

    @Override
    final SortedMultiset<E> multiset() {
      return multiset;
    }

    @Override
    public Iterator<E> iterator() {
      return Multisets.elementIterator(multiset().entrySet().iterator());
    }

    @Override
    public Comparator<? super E> comparator() {
      return multiset().comparator();
    }

    @Override

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.
 *