assertEquals(1, keys.count(k1()));
    assertEquals(3, keys.size());
    assertContainsAllOf(keys, k0(), k1());
    assertContainsAllOf(
        keys.entrySet(), Multisets.immutableEntry(k0(), 2), Multisets.immutableEntry(k1(), 1));
  }

  @MapFeature.Require(ALLOWS_NULL_KEY_QUERIES)
  public void testKeysCountAbsentNullKey() {
    assertEquals(0, multimap().keys().count(null));
  }

        .containsExactly(immutableEntry("foo", 1), immutableEntry("quux", 3))
        .inOrder();
  }

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

    map.remove("quux");
    assertThat(map.entrySet())
        .containsExactly(immutableEntry("foo", 1), immutableEntry("bar", 2))

    public SampleElements<Entry<Class, Impl>> samples() {
      return new SampleElements<>(
          immutableEntry((Class) One.class, new Impl(1)),
          immutableEntry((Class) Two.class, new Impl(2)),
          immutableEntry((Class) Three.class, new Impl(3)),
          immutableEntry((Class) Four.class, new Impl(4)),
          immutableEntry((Class) Five.class, new Impl(5)));
    }

    @Override
    @SuppressWarnings("unchecked")

    assertTrue(entries.contains(immutableEntry("a", true)));
    assertTrue(entries.contains(Maps.<String, @Nullable Boolean>immutableEntry("b", null)));
    assertTrue(
        entries.contains(Maps.<@Nullable String, @Nullable Boolean>immutableEntry(null, null)));

    assertFalse(entries.contains(Maps.<String, @Nullable Boolean>immutableEntry("c", null)));

            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));
          }
        }
      }
    }
  }

    assertFalse(entries.contains(Maps.immutableEntry("foo", singletonList(1))));
    assertFalse(entries.remove(Maps.immutableEntry("foo", singletonList(1))));
    assertFalse(entries.contains(Maps.immutableEntry("foo", new LinkedHashSet<>(asList(1, 2)))));
    assertFalse(entries.remove(Maps.immutableEntry("foo", new LinkedHashSet<>(asList(1, 2)))));
    assertFalse(entries.contains(Maps.immutableEntry("foo", singleton(2))));

    assertTrue(entrySet.contains(immutableEntry(10, 'X')));
    assertTrue(entrySet.contains(immutableEntry(20, 'X')));
    assertFalse(entrySet.contains(immutableEntry(15, 'X')));
    entrySet = row.tailMap(15).entrySet();
    assertFalse(entrySet.contains(immutableEntry(10, 'X')));
    assertTrue(entrySet.contains(immutableEntry(20, 'X')));
    assertFalse(entrySet.contains(immutableEntry(15, 'X')));
  }

            Maps.<@Nullable String, Integer>immutableEntry(null, 7),
            Maps.<@Nullable String, Integer>immutableEntry(null, 3),
            Maps.<@Nullable String, Integer>immutableEntry(null, 1),
            Maps.<String, @Nullable Integer>immutableEntry("tree", null),
            immutableEntry("tree", 0),
            immutableEntry("google", 6),
            immutableEntry("google", 2))
        .inOrder();
  }

    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();
  }

  /**

    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"));
  }