@MapFeature.Require(SUPPORTS_PUT)
  public void testComputeIfAbsent_supportedAbsent() {
    assertEquals(
        "computeIfAbsent(notPresent, function) should return new value",
        v3(),
        getMap()
            .computeIfAbsent(
                k3(),
                k -> {
                  assertEquals(k3(), k);
                  return v3();
                }));
    expectAdded(e3());
  }

        getMap()
            .computeIfPresent(
                null,
                (k, v) -> {
                  throw new AssertionFailedError();
                }));
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  public void testComputeIfPresent_unsupportedAbsent() {
    try {
      getMap()
          .computeIfPresent(
              k3(),

constraints.URL.message = {item} is geen geldige URL.
constraints.Required.message = {item} is vereist.
constraints.TypeInteger.message = {item} moet een getal zijn.
constraints.TypeLong.message = {item} moet een getal zijn.
constraints.TypeFloat.message = {item} moet een getal zijn.
constraints.TypeDouble.message = {item} moet een getal zijn.
constraints.TypeAny.message = {item} kan niet worden geconverteerd naar {propertyType}.

  @MapFeature.Require(SUPPORTS_PUT)
  public void testAbsent() {
    assertEquals(
        "Map.merge(absent, value, function) should return value",
        v3(),
        getMap()
            .merge(
                k3(),
                v3(),
                (oldV, newV) -> {
                  throw new AssertionFailedError(

    assertTrue("containsKey(present) should return true", getMap().containsKey(k0()));
  }

  public void testContains_no() {
    assertFalse("containsKey(notPresent) should return false", getMap().containsKey(k3()));
  }

  @MapFeature.Require(ALLOWS_NULL_KEY_QUERIES)
  public void testContains_nullNotContainedButAllowed() {
    assertFalse("containsKey(null) should return false", getMap().containsKey(null));
  }

    RangeMapEntry(Range<K> range, V value) {
      super(range, value);
    }

    boolean contains(K value) {
      return getKey().contains(value);
    }

    Cut<K> getLowerBound() {
      return getKey().lowerBound;
    }

    Cut<K> getUpperBound() {
      return getKey().upperBound;
    }
  }

  @Override
  public @Nullable V get(K key) {
    Entry<Range<K>, V> entry = getEntry(key);

    getMap().forcePut(null, v1());

    expectContents(mapEntry((K) null, v1()));

    assertFalse(getMap().containsValue(v0()));

    assertTrue(getMap().containsValue(v1()));
    assertTrue(getMap().inverse().containsKey(v1()));
    assertNull(getMap().inverse().get(v1()));
    assertEquals(v1(), getMap().get(null));
    assertEquals(1, getMap().size());
  }

        docMap.put("banana", "value3");

        Set<Map.Entry<String, Object>> entrySet = docMap.entrySet();
        assertEquals(4, entrySet.size());

        String[] keys = entrySet.stream().map(Map.Entry::getKey).toArray(String[]::new);

        boolean langFirst = "lang".equals(keys[0]);
        assertTrue("lang should be first or sorted normally", langFirst || Arrays.asList(keys).contains("lang"));

        // don't let the new entry get GCed
        warmed.add(entryOf(entry.getKey(), newValue));
        Object newKey = new Object();
        assertNull(cache.asMap().put(newKey, entry.getValue()));
        // this getUnchecked() call shouldn't be a cache miss; verified below
        assertEquals(newValue, cache.getUnchecked(entry.getKey()));

        public int compare(Entry<AnEnum, String> left, Entry<AnEnum, String> right) {
          return left.getKey().compareTo(right.getKey());
        }
      }.sortedCopy(insertionOrder);
    }
  }

  public static class ImmutableMapValuesAsSingletonSetGenerator
      implements TestMapGenerator<String, Collection<Integer>> {

    @Override
    public SampleElements<Entry<String, Collection<Integer>>> samples() {