Entry<K, Collection<V>> entry = sortedMap().ceilingEntry(key);
      return (entry == null) ? null : wrapEntry(entry);
    }

    @Override
    public @Nullable K ceilingKey(@ParametricNullness K key) {
      return sortedMap().ceilingKey(key);
    }

    @Override
    public @Nullable Entry<K, Collection<V>> higherEntry(@ParametricNullness K key) {

  }

  private static <K, V> Map<K, V> newHashMap(
      Collection<? extends Entry<? extends K, ? extends V>> entries) {
    HashMap<K, V> map = new HashMap<>();
    for (Entry<? extends K, ? extends V> entry : entries) {
      map.put(entry.getKey(), entry.getValue());
    }
    return map;
  }

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

  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 =

		return
	}

	// Check for abandoned entries.
	found := make(map[string]struct{}, len(d.Cache))

	// Mark all children recursively
	var mark func(entry dataUsageEntry)
	mark = func(entry dataUsageEntry) {
		for k := range entry.Children {
			found[k] = struct{}{}
			if ch, ok := d.Cache[k]; ok {
				mark(ch)
			}
		}
	}
	found[top] = struct{}{}
	mark(*topE)

        @Override
        public boolean apply(Entry<String, Integer> entry) {
          return !Objects.equals(entry.getKey(), "badkey") && entry.getValue() != 55556;
        }
      };

  public MultimapsFilterEntriesAsMapTest() {
    super(true, true, false);
  }

  private Multimap<String, Integer> createMultimap() {
    Multimap<String, Integer> unfiltered = HashMultimap.create();

                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 {

        for (final Entry<String, Map<String, CacheEntry<DfsReferralDataInternal>>> entry : domains.entrySet()) {
            log.trace("Domain " + entry.getKey());
            for (final Entry<String, CacheEntry<DfsReferralDataInternal>> entry2 : entry.getValue().entrySet()) {
                log.trace("  Root " + entry2.getKey());
                if (entry2.getValue().map != null) {

          contents.add(entry.getElement());
        }
      }
      return ((Multiset<E>) gen.create(contents.toArray())).entrySet();
    }

    @SuppressWarnings("unchecked")
    @Override
    public Multiset.Entry<E>[] createArray(int length) {
      return (Multiset.Entry<E>[]) new Multiset.Entry<?>[length];
    }

    @Override

                  @Override
                  protected Map<String, String> create(Entry<String, String>[] entries) {
                    Map<String, String> map = CompactLinkedHashMap.create();
                    for (Entry<String, String> entry : entries) {
                      map.put(entry.getKey(), entry.getValue());
                    }
                    return map;
                  }
                })