public void testAsMapEntrySetReflectsPutSameKey() {
    resetContainer(Helpers.mapEntry(k0(), v0()), Helpers.mapEntry(k0(), v3()));

    Set<Entry<K, Collection<V>>> asMapEntrySet = multimap().asMap().entrySet();
    Collection<V> valueCollection = Iterables.getOnlyElement(asMapEntrySet).getValue();
    assertContentsAnyOrder(valueCollection, v0(), v3());
    assertTrue(multimap().put(k0(), v4()));

    Collection<V> vs = values;
    return (vs != null) ? vs : (values = new Values(this));
  }

  Set<Entry<K, V>> entrySet;

  @Override
  public Set<Entry<K, V>> entrySet() {
    // does not impact recency ordering
    Set<Entry<K, V>> es = entrySet;
    return (es != null) ? es : (entrySet = new EntrySet(this));
  }

  /**

        return of();
      case 1:
        Entry<? extends K, ? extends V> entry = getOnlyElement(map.entrySet());
        return ImmutableMap.<K, V>of(entry.getKey(), entry.getValue());
      default:
        Map<K, V> orderPreservingCopy = Maps.newLinkedHashMap();
        for (Entry<? extends K, ? extends V> e : map.entrySet()) {
          orderPreservingCopy.put(checkNotNull(e.getKey()), checkNotNull(e.getValue()));
        }

   */
  ALLOWS_NULL_VALUE_QUERIES,
  ALLOWS_NULL_VALUES(ALLOWS_NULL_VALUE_QUERIES),
  /**
   * The map does not throw {@code NullPointerException} on calls such as {@code
   * entrySet().contains(null)} or {@code entrySet().remove(null)}
   */
  ALLOWS_NULL_ENTRY_QUERIES,
  /**
   * The map does not throw {@code NullPointerException} on any {@code null} queries.
   *
   * @see #ALLOWS_NULL_KEY_QUERIES

        final HttpServletRequest req = (HttpServletRequest) request;
        final String servletPath = req.getServletPath();
        for (final Map.Entry<String, String> entry : encodingMap.entrySet()) {
            final String path = entry.getKey();
            if (servletPath.startsWith(path)) {
                req.setCharacterEncoding(entry.getValue());

        Map<Integer, TestResolvedDependency> dependenciesById = [:]
        for (Map.Entry entry : treeStructure.entrySet()) {
            Integer id = entry.getKey() as Integer
            dependenciesById.put(id, new TestResolvedDependency())
        }
        for (Map.Entry entry : treeStructure.entrySet()) {
            Integer id = entry.getKey() as Integer
            dependenciesById.get(id).children = entry.getValue().collect {

        assertThat(navigableMap.headMap(key, inclusive).entrySet())
            .containsExactlyElementsIn(expected.headMap(key, inclusive).entrySet())
            .inOrder();
        assertThat(navigableMap.tailMap(key, inclusive).entrySet())
            .containsExactlyElementsIn(expected.tailMap(key, inclusive).entrySet())
            .inOrder();

    }

    public static <K, V> StreamOf<Map.Entry<K, V>> stream(final Map<K, V> map) {
        return new StreamOf<>(() -> map != null ? map.entrySet().stream() : Collections.<K, V> emptyMap().entrySet().stream());
    }

    public static class StreamOf<T> {

        private final Supplier<Stream<T>> supplier;

        public StreamOf(final Supplier<Stream<T>> supplier) {

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

        ImmutableMap.Builder<String, String> changedBuilder = ImmutableMap.builder();
        for (Map.Entry<String, ValueSnapshot> entry : current.entrySet()) {
            String propertyName = entry.getKey();
            ValueSnapshot currentSnapshot = entry.getValue();
            ValueSnapshot previousSnapshot = previous.get(propertyName);