assertThrows(UnsupportedOperationException.class, () -> multimapView.put("baz", 3));
    assertThrows(
        UnsupportedOperationException.class, () -> multimapView.putAll("baz", singleton(3)));
    assertThrows(UnsupportedOperationException.class, () -> multimapView.putAll(multimap));
    assertThrows(
        UnsupportedOperationException.class,
        () -> multimapView.replaceValues("foo", Collections.<Integer>emptySet()));

        validateFields(body.doc, this::throwValidationErrorApi);
        body.crudMode = CrudMode.CREATE;
        final Map<String, Object> doc = getDoc(body).map(entity -> {
            try {
                entity.putAll(fessConfig.convertToStorableDoc(body.doc));

                final String newId = ComponentUtil.getCrawlingInfoHelper().generateId(entity);
                entity.put(fessConfig.getIndexFieldId(), newId);

    @Override
    public void putAll(RangeMap<K, ? extends V> rangeMap) {
      if (rangeMap.asMapOfRanges().isEmpty()) {
        return;
      }
      Range<K> span = rangeMap.span();
      checkArgument(
          subRange.encloses(span),
          "Cannot putAll rangeMap with span %s into a subRangeMap(%s)",
          span,
          subRange);
      TreeRangeMap.this.putAll(rangeMap);
    }

    @Override

/**
 * @since 3.2.3
 */
public class SystemProperties {
    /**
     * Thread-safe System.properties copy implementation.
     */
    public static void addSystemProperties(Properties props) {
        props.putAll(getSystemProperties());
    }

    /**
     * Returns a copy of {@link System#getProperties()} in a thread-safe manner.
     *
     * @return {@link System#getProperties()} obtained in a thread-safe manner.
     */

    multimap.put("foo", 3);
    multimap.put("bar", 1);
    multimap.putAll("foo", asList(-1, 2, 4));
    multimap.putAll("bar", asList(2, 3));
    multimap.put("foo", 1);
    TreeMultimap<String, Integer> copy =
        TreeMultimap.create(StringLength.COMPARATOR, DECREASING_INT_COMPARATOR);
    copy.putAll(multimap);
    assertEquals(multimap, copy);

 * methods of the delegate. For example, overriding {@link #put} alone <i>will not</i> change the
 * behavior of {@link #putAll}, which can lead to unexpected behavior. In this case, you should
 * override {@code putAll} as well, either providing your own implementation, or delegating to the
 * provided {@code standardPutAll} method.
 *

      assertTrue(Thread.holdsLock(mutex));
      return delegate.put(rowKey, columnKey, value);
    }

    @Override
    public void putAll(Table<? extends R, ? extends C, ? extends V> table) {
      assertTrue(Thread.holdsLock(mutex));
      delegate.putAll(table);
    }

    @Override
    public @Nullable V remove(Object rowKey, Object columnKey) {
      assertTrue(Thread.holdsLock(mutex));

        newMap.putAll(map);
        return newMap;
      }
    },
    MapMakerStrongKeysWeakValues {
      @Override
      public <K extends Comparable<K>, V> Map<K, V> create(Map<K, V> map) {
        ConcurrentMap<K, V> newMap = new MapMaker().weakValues().makeMap();
        checkState(newMap instanceof MapMakerInternalMap);
        newMap.putAll(map);
        return newMap;
      }
    },

   *
   * {@snippet :
   * static final Multimap<String, Integer> STRING_TO_INTEGER_MULTIMAP =
   *     new ImmutableMultimap.Builder<String, Integer>()
   *         .put("one", 1)
   *         .putAll("several", 1, 2, 3)
   *         .putAll("many", 1, 2, 3, 4, 5)
   *         .build();
   * }
   *
   * <p>Builder instances can be reused; it is safe to call {@link #build} multiple times to build

    // Test #putAll(K, Collection<V>)
    try {
      multimap.putAll(sampleKey, sampleValueAsCollection);
      fail("putAll(K, Iterable) succeeded on unmodifiable multimap");
    } catch (UnsupportedOperationException expected) {
    }
    assertMultimapRemainsUnmodified(multimap, originalEntries);

    // Test #putAll(Multimap<K, V>)