int bucket = Hashing.smear(hash) & mask;
      ImmutableEntry<E> bucketHead = hashTable[bucket];
      ImmutableEntry<E> newEntry;
      if (bucketHead == null) {
        boolean canReuseEntry =
            entry instanceof ImmutableEntry && !(entry instanceof NonTerminalEntry);
        newEntry =
            canReuseEntry ? (ImmutableEntry<E>) entry : new ImmutableEntry<E>(element, count);
      } else {

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

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

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

    @Override
    @SuppressWarnings("unchecked")

        new Builder<String, Integer>().put(immutableEntry("one", 1)).build();
    assertEquals(asList(1), multimap.get("one"));
  }

  public void testBuilder_withImmutableEntryAndNullContents() {
    Builder<String, Integer> builder = new Builder<>();
    assertThrows(
        NullPointerException.class, () -> builder.put(immutableEntry("one", (Integer) null)));

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

    assertThat(map.entrySet())
        .containsExactly(immutableEntry("one", 1), immutableEntry("three", 3))
        .inOrder();
  }

  public void testHeadMapExclusive() {
    Map<String, Integer> map =
        ImmutableSortedMap.of("one", 1, "two", 2, "three", 3).headMap("three", false);
    assertThat(map.entrySet()).containsExactly(immutableEntry("one", 1));
  }

  public void testTailMapInclusive() {

    @Override
    public SampleElements<Entry<Country, String>> samples() {
      return new SampleElements<>(
          immutableEntry(Country.CANADA, "DOLLAR"),
          immutableEntry(Country.CHILE, "PESO"),
          immutableEntry(Country.UK, "POUND"),
          immutableEntry(Country.JAPAN, "YEN"),
          immutableEntry(Country.SWITZERLAND, "FRANC"));
    }

    @SuppressWarnings("unchecked")
    @Override

                        keys ->
                            path.create(transform(keys, key -> immutableEntry(key, new Object()))),
                        keys ->
                            path.create(transform(keys, key -> immutableEntry(new Object(), key))),
                        keys -> path.create(transform(keys, key -> immutableEntry(key, key)))))
            .collect(toImmutableList()),
        n -> n * log(n),
        ImmutableList.of(