for (Entry<K, V> entry : getSampleElements()) {
      expected.add(entry.getValue());
    }
    assertEqualIgnoringOrder(expected, multimap().values());
  }

  @CollectionFeature.Require(KNOWN_ORDER)
  public void testValuesInOrder() {
    List<V> expected = new ArrayList<>();
    for (Entry<K, V> entry : getOrderedElements()) {
      expected.add(entry.getValue());
    }
    assertEqualInOrder(expected, multimap().values());
  }

        return parent.remove(toCamelCase(key), value);
    }

    @Override
    public boolean replace(final K key, final V oldValue, final V newValue) {
        if (parent.replace(key, oldValue, newValue)) {
            return true;
        }
        return parent.replace(key, oldValue, newValue);
    }

    @Override
    public V replace(final K key, final V value) {
        // use original key

    stream.writeInt(multimap.asMap().size());
    for (Map.Entry<K, Collection<V>> entry : multimap.asMap().entrySet()) {
      stream.writeObject(entry.getKey());
      stream.writeInt(entry.getValue().size());
      for (V value : entry.getValue()) {
        stream.writeObject(value);
      }
    }
  }

  /**
   * Populates a multimap by reading an input stream, as part of deserialization. See {@link

    Iterator<Entry<K, V>> iterator = multimap().entries().iterator();
    Entry<K, V> entry = iterator.next();
    K key = entry.getKey();
    V value = entry.getValue();
    multimap().removeAll(key);
    assertEquals(key, entry.getKey());
    assertEquals(value, entry.getValue());
  }

        ValueSource basedirValueSource = new PrefixedValueSourceWrapper(
                new AbstractValueSource(false) {

                    @Override
                    public Object getValue(String expression) {
                        if (projectDir != null && "basedir".equals(expression)) {
                            return projectDir.getAbsolutePath();
                        }

    assertThrows(
        IllegalArgumentException.class,
        () -> Stream.of(mapEntry("one", 1), mapEntry("one", 11)).collect(collector));
  }

  public void testToImmutableSortedMapMerging() {
    Collector<Entry<String, Integer>, ?, ImmutableSortedMap<String, Integer>> collector =
        toImmutableSortedMap(Entry::getKey, Entry::getValue, Integer::sum);

        expectedHashCode,
        getMap().hashCode());
  }

  private static int hash(Entry<?, ?> e) {
    return (e.getKey() == null ? 0 : e.getKey().hashCode())
        ^ (e.getValue() == null ? 0 : e.getValue().hashCode());
  }

                    V newValue = (oldValue == null) ? e.getValue() : remapping.merge(oldValue, e.getValue());
                    if (newValue == null) {
                        remove(key);
                    } else if (newValue != oldValue) {
                        map.put(key, newValue);
                    }
                }
            } else {

      @Override
      public boolean hasNext() {
        return entryItr.hasNext();
      }

      @Override
      public V next() {
        return entryItr.next().getValue();
      }
    };
  }

  @Override
  public boolean contains(@Nullable Object object) {
    return object != null && Iterators.contains(iterator(), object);
  }

  @Override

        final File basedir = context.getProjectDirectory();

        if (basedir != null) {
            interpolator.addValueSource(new AbstractValueSource(false) {
                @Override
                public Object getValue(String expression) {
                    if ("basedir".equals(expression) || "project.basedir".equals(expression)) {
                        return basedir.getAbsolutePath();
                    }