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

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)

    assertNull(
        "putIfAbsent(existingKeyWithNullValue, value) should return null",
        getMap().putIfAbsent(getKeyForNullValue(), v3()));
    assertEquals("Map should now contain the new value", v3(), getMap().get(getKeyForNullValue()));
  }

        v3(),
        getMap()
            .merge(
                getKeyForNullValue(),
                v3(),
                (oldV, newV) -> {
                  throw new AssertionFailedError(
                      "Should not call merge function if key was mapped to null");
                }));
    expectReplacement(entry(getKeyForNullValue(), v3()));
  }

  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_KEYS})

  public void testContains_keyWithNullValueContained() {
    initMapWithNullValue();
    assertTrue(
        "containsKey(keyForNullValue) should return true",
        getMap().containsKey(getKeyForNullValue()));
  }

  public void testContains_wrongType() {
    try {
      // noinspection SuspiciousMethodCalls
      assertFalse(
          "containsKey(wrongType) should return false or throw",

        getMap().put(getKeyForNullValue(), null));
    expectContents(createArrayWithNullValue());
  }

  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUES})
  @CollectionSize.Require(absent = ZERO)
  public void testPut_replaceNullValueWithNonNullSupported() {
    Entry<K, V> newEntry = entry(getKeyForNullValue(), v3());
    initMapWithNullValue();

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(ALLOWS_NULL_VALUES)
  public void testContainsEntryWithNullValuePresent() {
    initMultimapWithNullValue();
    assertContains(multimap().entries(), mapEntry(getKeyForNullValue(), (V) null));
  }

  @MapFeature.Require(ALLOWS_NULL_VALUE_QUERIES)
  public void testContainsEntryWithNullValueAbsent() {
    assertFalse(multimap().entries().contains(mapEntry(k0(), null)));
  }

  }

  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUES})
  @CollectionSize.Require(absent = ZERO)
  public void testPutDuplicateValue_null() {
    initMultimapWithNullValue();
    assertFalse(multimap().put(getKeyForNullValue(), null));
    expectContents(createArrayWithNullValue());
  }

  }

  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUES})
  @CollectionSize.Require(absent = ZERO)
  public void testPutDuplicateValue_null() {
    initMultimapWithNullValue();
    assertFalse(multimap().put(getKeyForNullValue(), null));
    expectContents(createArrayWithNullValue());
  }

  public void testGetOrDefault_presentMappedToNull() {
    initMapWithNullValue();
    assertNull(
        "getOrDefault(mappedToNull, default) should return null",
        getMap().getOrDefault(getKeyForNullValue(), v3()));
  }

  public void testGet_wrongType() {
    try {
      assertEquals(
          "getOrDefault(wrongType, default) should return default or throw",
          v3(),

    array[nullKeyLocation] = entry(null, oldEntry.getValue());
    return array;
  }

  protected V getValueForNullKey() {
    return getEntryNullReplaces().getValue();
  }

  protected K getKeyForNullValue() {
    return getEntryNullReplaces().getKey();
  }

  private Entry<K, V> getEntryNullReplaces() {
    Iterator<Entry<K, V>> entries = getSampleElements().iterator();