SampleElements<E> samples = gen.samples();
      return new SampleElements<>(
          Multisets.immutableEntry(samples.e0(), 3),
          Multisets.immutableEntry(samples.e1(), 4),
          Multisets.immutableEntry(samples.e2(), 1),
          Multisets.immutableEntry(samples.e3(), 5),
          Multisets.immutableEntry(samples.e4(), 2));
    }

    @Override
    public Set<Multiset.Entry<E>> create(Object... entries) {

    assertThat(builder.build().entries()).containsExactly(Maps.immutableEntry("key", "value"));
  }

  public void testBuilderWithExpectedKeysPositive() {
    ImmutableListMultimap.Builder<String, String> builder =
        ImmutableListMultimap.builderWithExpectedKeys(1);
    builder.put("key", "value");
    assertThat(builder.build().entries()).containsExactly(Maps.immutableEntry("key", "value"));
  }

      int count = entry.getCount();
      size += count;
      E element = checkNotNull(entry.getElement());
      delegateMap.put(element, count);
      if (!(entry instanceof Multisets.ImmutableEntry)) {
        entriesArray[i] = Multisets.immutableEntry(element, count);
      }
    }
    return new JdkBackedImmutableMultiset<>(delegateMap, asImmutableList(entriesArray), size);
  }

  private JdkBackedImmutableMultiset(

        .containsExactly(immutableEntry(4, "d"), immutableEntry(2, "b"))
        .inOrder();
    assertThat(diff1.entriesOnlyOnRight().entrySet()).contains(immutableEntry(6, "z"));
    assertThat(diff1.entriesInCommon().entrySet()).contains(immutableEntry(1, "a"));
    assertThat(diff1.entriesDiffering().entrySet())
        .containsExactly(
            immutableEntry(5, ValueDifferenceImpl.create("e", "g")),

            Entry<Range<Integer>, Integer> expectedEntry = null;
            if (range1.contains(i)) {
              expectedEntry = immutableEntry(range1, 1);
            } else if (range2.contains(i)) {
              expectedEntry = immutableEntry(range2, 2);
            }

            assertEquals(expectedEntry, rangeMap.getEntry(i));
          }
        }
      }
    }
  }

    @Override
    public SampleElements<Entry<String, Integer>> samples() {
      return new SampleElements<>(
          immutableEntry("bar", 1),
          immutableEntry("bar", 2),
          immutableEntry("foo", 3),
          immutableEntry("bar", 3),
          immutableEntry("cat", 2));
    }

    @Override
    public Collection<Entry<String, Integer>> create(Object... elements) {

 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package com.google.common.collect;

import static com.google.common.collect.Maps.immutableEntry;
import static java.util.Objects.requireNonNull;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;

    Iterator<Entry<E>> entryIterator = entrySet().iterator();
    if (!entryIterator.hasNext()) {
      return null;
    }
    Entry<E> entry = entryIterator.next();
    return Multisets.immutableEntry(entry.getElement(), entry.getCount());
  }

  @Override
  public @Nullable Entry<E> lastEntry() {
    return delegate().lastEntry();
  }

  /**

  public static <E extends @Nullable Object> Multiset.Entry<E> immutableEntry(
      @ParametricNullness E e, int n) {
    return new ImmutableEntry<>(e, n);
  }

  static class ImmutableEntry<E extends @Nullable Object> extends AbstractEntry<E>
      implements Serializable {
    @ParametricNullness private final E element;
    private final int count;

    ImmutableEntry(@ParametricNullness E element, int count) {

  public static <E extends @Nullable Object> Multiset.Entry<E> immutableEntry(
      @ParametricNullness E e, int n) {
    return new ImmutableEntry<>(e, n);
  }

  static class ImmutableEntry<E extends @Nullable Object> extends AbstractEntry<E>
      implements Serializable {
    @ParametricNullness private final E element;
    private final int count;

    ImmutableEntry(@ParametricNullness E element, int count) {