}

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testSetValue() {
    for (Entry<K, V> entry : getMap().entrySet()) {
      if (entry.getKey().equals(k0())) {
        assertEquals("entry.setValue() should return the old value", v0(), entry.setValue(v3()));
        break;
      }
    }
    expectReplacement(entry(k0(), v3()));
  }

  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testSetValue() {
    for (Entry<K, V> entry : getMap().entrySet()) {
      if (entry.getKey().equals(k0())) {
        assertEquals("entry.setValue() should return the old value", v0(), entry.setValue(v3()));
        break;
      }
    }
    expectReplacement(entry(k0(), v3()));
  }

                            .stream()
                            .filter(p -> Pattern.compile(p.getValue()).matcher(kv.getValue()).find())
                            .map(p -> "- " + p.getKey() + " on line " + kv.getKey() + " of " + path)
                    )
                    .collect(Collectors.toList())
            );
        }
        if (failures.isEmpty() == false) {

            }).forEach(e -> {
                if (logger.isDebugEnabled()) {
                    logger.debug("system.properties: setProperty({}, {})", e.getKey(), e.getValue());
                }
                System.setProperty(e.getKey(), e.getValue());
            });
        }
    }

    /**
     * Updates the application configuration.
     *

      assertThat(entryOne.getKey()).isEqualTo(keyOne);
      assertEquals(hashOne, entryOne.getHash());
      assertThat(entryOne.getNext()).isNull();
      assertThat(copyOne.getValue()).isEqualTo(valueOne);

      InternalEntry<Object, Object, ?> copyTwo = segment.copyForTesting(entryTwo, copyOne);
      assertThat(copyTwo.getKey()).isEqualTo(keyTwo);
      assertEquals(hashTwo, copyTwo.getHash());

      assertThat(entryOne.getKey()).isEqualTo(keyOne);
      assertEquals(hashOne, entryOne.getHash());
      assertThat(entryOne.getNext()).isNull();
      assertThat(copyOne.getValue()).isEqualTo(valueOne);

      InternalEntry<Object, Object, ?> copyTwo = segment.copyForTesting(entryTwo, copyOne);
      assertThat(copyTwo.getKey()).isEqualTo(keyTwo);
      assertEquals(hashTwo, copyTwo.getHash());

    /**
     * Adds an entry to the built multimap.
     *
     * @since 11.0
     */
    @CanIgnoreReturnValue
    public Builder<K, V> put(Entry<? extends K, ? extends V> entry) {
      return put(entry.getKey(), entry.getValue());
    }

    /**
     * Adds entries to the built multimap.
     *
     * @since 19.0
     */
    @CanIgnoreReturnValue

                    }

                    final CrawlingInfoParam entity = new CrawlingInfoParam();
                    entity.setCrawlingInfoId(crawlingInfo.getId());
                    entity.setKey(list.get(2));
                    entity.setValue(list.get(3));
                    entity.setCreatedTime(formatter.parse(list.get(4)).getTime());

    super(delegate);

    ImmutableMap.Builder<V, K> builder = ImmutableMap.builder();
    for (Entry<K, V> entry : delegate.entrySet()) {
      builder.put(entry.getValue(), entry.getKey());
    }
    ImmutableMap<V, K> backwardMap = builder.build();
    this.inverse = new RegularImmutableBiMap<V, K>(backwardMap, this);
  }

  public void testPutDuplicateValue() {
    List<Entry<K, V>> entries = copyToList(multimap().entries());

    for (Entry<K, V> entry : entries) {
      resetContainer();

      K k = entry.getKey();
      V v = entry.getValue();

      List<V> values = multimap().get(k);
      List<V> expectedValues = copyToList(values);

      assertTrue(multimap().put(k, v));
      expectedValues.add(v);