Set<Entry<K, V>> entrySet = getMap().entrySet();
    Iterator<Entry<K, V>> entryItr = entrySet.iterator();
    assertEquals(e0(), entryItr.next());
    entryItr.remove();
    assertTrue(getMap().isEmpty());
    assertFalse(entrySet.contains(e0()));
  }

  public void testContainsEntryWithIncomparableKey() {
    try {

    Set<Entry<K, V>> entrySet = getMap().entrySet();
    Iterator<Entry<K, V>> entryItr = entrySet.iterator();
    assertEquals(e0(), entryItr.next());
    entryItr.remove();
    assertTrue(getMap().isEmpty());
    assertFalse(entrySet.contains(e0()));
  }

  public void testContainsEntryWithIncomparableKey() {
    try {

  abstract Iterator<Entry<E>> entryIterator();

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

  @Override
  public Set<Entry<E>> entrySet() {
    Set<Entry<E>> result = entrySet;
    return (result == null) ? entrySet = createEntrySet() : result;
  }

  Set<Entry<E>> createEntrySet() {
    return new Multisets.EntrySet<E>() {
      @Override
      Multiset<E> multiset() {

        "equals()"              | call(m -> Objects.equals(m, Collections.emptyMap()))  // Ensure that a real equals is invoked and not a Groovy helper
        "entrySet().size()"     | call(m -> m.entrySet().size())
        "entrySet().iterator()" | call(m -> m.entrySet().iterator())
        "keySet().size()"       | call(m -> m.keySet().size())
        "keySet().iterator()"   | call(m -> m.keySet().iterator())
    }

        when:
        def entrySet = map.entrySet()
        def removedForth = entrySet.remove(new AbstractMap.SimpleEntry<>("forth", "value4"))
        def removedFifthEmptyValue = entrySet.remove(new AbstractMap.SimpleEntry<>("fifth", ""))
        def removedFifthNullValue = entrySet.remove(new AbstractMap.SimpleEntry<>("fifth", null))
        def removedNull = entrySet.remove(new AbstractMap.SimpleEntry<>(null, null))

    assertThat(map.entrySet())
        .containsExactly(Maps.immutableEntry("foo", 1), Maps.immutableEntry("bar", 2))
        .inOrder();
  }

  public void testInsertionOrderAfterForcePut() {
    BiMap<String, Integer> map = HashBiMap.create();
    map.put("foo", 1);
    map.put("bar", 2);
    map.put("quux", 3);

    map.forcePut("quux", 1);
    assertThat(map.entrySet())

  public void testEntrySetMutationThrows() {
    map.putInstance(String.class, "test");
    assertEquals(TypeToken.of(String.class), map.entrySet().iterator().next().getKey());
    assertEquals("test", map.entrySet().iterator().next().getValue());
    assertThrows(
        UnsupportedOperationException.class, () -> map.entrySet().iterator().next().setValue(1));
  }

  public void testEntrySetToArrayMutationThrows() {

  /**
   * A sensible definition of {@link #firstEntry()} in terms of {@code entrySet().iterator()}.
   *
   * <p>If you override {@link #entrySet()}, you may wish to override {@link #firstEntry()} to
   * forward to this implementation.
   */
  @CheckForNull
  protected Entry<E> standardFirstEntry() {
    Iterator<Entry<E>> entryIterator = entrySet().iterator();
    if (!entryIterator.hasNext()) {
      return null;
    }

                        return reportAllAdded(visitor, current, propertyTitle);
                    case 1:
                        Map.Entry<String, S> previousEntry = previous.entrySet().iterator().next();
                        Map.Entry<String, S> currentEntry = current.entrySet().iterator().next();
                        return compareTrivialEntries(visitor, previousEntry, currentEntry, propertyTitle);
                    default:

    for (int i = 0; i < entries.size(); i++) {
      assertEqualInOrder(
          entries.subList(0, i), navigableMap.headMap(entries.get(i).getKey()).entrySet());
    }
  }

  public void testTailMap() {
    List<Entry<K, V>> entries =
        Helpers.copyToList(
            getSubjectGenerator()