implements TestSetGenerator<Entry<K, V>> {

    public EntriesGenerator(
        OneSizeTestContainerGenerator<SetMultimap<K, V>, Entry<K, V>> multimapGenerator) {
      super(multimapGenerator);
    }

    @Override
    public Set<Entry<K, V>> create(Object... elements) {
      return (Set<Entry<K, V>>) super.create(elements);
    }
  }

  public void testImmutableEntrySerialization() {
    Cell<String, Integer, Character> entry = immutableCell("foo", 1, 'a');
    SerializableTester.reserializeAndAssert(entry);
  }

  public void testImmutableEntryToString() {
    Cell<String, Integer, Character> entry = immutableCell("foo", 1, 'a');
    assertEquals("(foo,1)=a", entry.toString());

    Cell<@Nullable String, @Nullable Integer, @Nullable Character> nullEntry =

    K key = entry.getKey();
    V value = entry.getValue();
    multimap().removeAll(key);
    assertEquals(key, entry.getKey());
    assertEquals(value, entry.getValue());
  }

        map.put(ConfigName.FIELD, fieldConfigMap);
        for (final Map.Entry<String, String> entry : ParameterUtil.parse(configParameters).entrySet()) {
            final String key = entry.getKey();
            if (key.startsWith(CONFIG_PREFIX)) {
                configConfigMap.put(key.substring(CONFIG_PREFIX.length()), entry.getValue());
            } else if (key.startsWith(CLIENT_PREFIX)) {

public class SortedMapNavigationTester<K, V> extends AbstractMapTester<K, V> {

  private SortedMap<K, V> navigableMap;
  private Entry<K, V> a;
  private Entry<K, V> c;

  @Override
  public void setUp() throws Exception {
    super.setUp();
    navigableMap = (SortedMap<K, V>) getMap();
    List<Entry<K, V>> entries =
        copyToList(
            getSubjectGenerator()

            ImmutableMap.ofEntries(entry(1, 2), entry(2, 3), entry(3, 1)),
            map(1, 2, 2, 3, 3, 1))
        .addEqualityGroup(
            ImmutableMap.of(1, 1, 2, 2, 3, 3, 4, 4),
            ImmutableMap.builder().put(1, 1).put(2, 2).put(3, 3).put(4, 4).buildOrThrow(),
            ImmutableMap.ofEntries(entry(1, 1), entry(2, 2), entry(3, 3), entry(4, 4)),
            map(1, 1, 2, 2, 3, 3, 4, 4))

                if (edge == null) { // no edges - don't need this vertex anymore
                    if (entry.equals(v)) { // unless it's an entry point.
                        // currently processing the entry point - it should not have any entry incident edges
                        res.getEntry().getMd().setWhy("This is a graph entry point. No links.");
                    } else {

  @Override
  protected void assertMoreInvariants(Map<K, V> map) {
    // TODO: can these be moved to MapInterfaceTest?
    for (Entry<K, V> entry : map.entrySet()) {
      assertEquals(entry.getKey() + "=" + entry.getValue(), entry.toString());
    }

    assertEquals("{" + joiner.join(map.entrySet()) + "}", map.toString());

    assertMapEquals(ImmutableBiMap.ofEntries(entry("one", 1), entry("two", 2)), "one", 1, "two", 2);
  }

  public void testOfEntriesNull() {
    Entry<@Nullable Integer, Integer> nullKey = entry(null, 23);
    assertThrows(
        NullPointerException.class,
        () -> ImmutableBiMap.ofEntries((Entry<Integer, Integer>) nullKey));
    Entry<Integer, @Nullable Integer> nullValue =

  public void testAsMapGet() {
    for (K key : sampleKeys()) {
      List<V> expectedValues = new ArrayList<>();
      for (Entry<K, V> entry : getSampleElements()) {
        if (entry.getKey().equals(key)) {
          expectedValues.add(entry.getValue());
        }
      }

      Collection<V> collection = multimap().asMap().get(key);
      if (expectedValues.isEmpty()) {