validateFields(form.doc, v -> throwValidationError(v, this::asEditHtml));
        verifyToken(this::asEditHtml);
        getDoc(form).ifPresent(entity -> {
            try {
                entity.putAll(fessConfig.convertToStorableDoc(form.doc));

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

          .put(UnsupportedOperationException.class, e -> e instanceof UnsupportedOperationException)
          .put(VerifyException.class, e -> e instanceof VerifyException)
          .putAll(PlatformSpecificExceptionBatch.PLATFORM.exceptions())
          .buildOrThrow();

  private ReflectionFreeAssertThrows() {}

    Table<String, Integer, @NonNull C> other = HashBasedTable.create();
    other.put("foo", 1, cellValue('d'));
    other.put("bar", 2, cellValue('e'));
    other.put("cat", 2, cellValue('f'));
    table.putAll(other);
    assertEquals((Character) 'd', table.get("foo", 1));
    assertEquals((Character) 'b', table.get("bar", 1));
    assertEquals((Character) 'c', table.get("foo", 3));

    if (supportsPut) {
      int initialSize = map.size();
      map.putAll(mapToPut);
      assertEquals(valueToPut, map.get(keyToPut));
      assertTrue(map.containsKey(keyToPut));
      assertTrue(map.containsValue(valueToPut));
      assertEquals(initialSize + 1, map.size());
    } else {
      assertThrows(UnsupportedOperationException.class, () -> map.putAll(mapToPut));
    }
    assertInvariants(map);
  }

        factory.setInitParameterMap(paramMap);

        final Map<String, String> clientConfigMap = getConfigParameterMap(ConfigName.CLIENT);
        if (clientConfigMap != null) {
            paramMap.putAll(clientConfigMap);
        }

        // robots txt enabled
        if (paramMap.get(Param.Client.ROBOTS_TXT_ENABLED) == null) {

    public static void loadConfigParams(final Map<String, Object> paramMap, final String configParam) {
        final Map<String, String> map = ParameterUtil.parse(configParam);
        if (!map.isEmpty()) {
            paramMap.putAll(map);
        }
    }

    /**
     * Creates a configuration parameter map.
     *
     * @param configParameters the configuration parameters
     * @return the configuration parameter map
     */

  /** Test throwing ConcurrentModificationException when a sublist's ancestor's delegate changes. */
  public void testSublistConcurrentModificationException() {
    ListMultimap<String, Integer> multimap = create();
    multimap.putAll("foo", asList(1, 2, 3, 4, 5));
    List<Integer> list = multimap.get("foo");
    assertThat(multimap.get("foo")).containsExactly(1, 2, 3, 4, 5).inOrder();
    List<Integer> sublist = list.subList(0, 5);

          .put(UnsupportedOperationException.class, e -> e instanceof UnsupportedOperationException)
          .put(VerifyException.class, e -> e instanceof VerifyException)
          .putAll(PlatformSpecificExceptionBatch.PLATFORM.exceptions())
          .buildOrThrow();

  private ReflectionFreeAssertThrows() {}

   *
   * @deprecated unsupported operation
   * @throws UnsupportedOperationException always
   */
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public void putAll(Map<? extends TypeToken<? extends @NonNull B>, ? extends B> map) {
    throw new UnsupportedOperationException("Please use putInstance() instead.");
  }

  @Override

   *
   * @since 22.0
   */
  void putCoalescing(Range<K> range, V value);

  /** Puts all the associations from {@code rangeMap} into this range map (optional operation). */
  void putAll(RangeMap<K, ? extends V> rangeMap);

  /** Removes all associations from this range map (optional operation). */
  void clear();

  /**