Map<String, String> analyzerMapping = new HashMap<>();
        analyzerMapping.put(FieldNames.ANALYZER_SETTINGS_TYPE, AnalyzerSettings.FIELD_ANALYZER_MAPPING);
        analyzerMapping.put(FieldNames.ANALYZER_SETTINGS_FIELD_NAME, field);
        analyzerMapping.put(FieldNames.ANALYZER_SETTINGS_CONTENTS_ANALYZER, "title_contents_analyzer");
        analyzerMapping.put(FieldNames.ANALYZER_SETTINGS_CONTENTS_READING_ANALYZER, "");
        runner.client()

 * have appeared. The differences include:
 *
 * <ul>
 *   <li>There is no need to populate an empty collection before adding an entry with {@link #put
 *       put}.
 *   <li>{@code get} never returns {@code null}, only an empty collection.
 *   <li>A key is contained in the multimap if and only if it maps to at least one value. Any

    }

    @Override
    public final V put(final String key, final V value) {
        return super.put(convertKey(key), value);
    }

    @Override
    public void putAll(final Map<? extends String, ? extends V> map) {
        for (final Map.Entry<? extends String, ? extends V> entry : map.entrySet()) {
            put(convertKey(entry.getKey()), entry.getValue());
        }
    }

    @Override

    if (map == null) {
      map = factory.get();
      backingMap.put(rowKey, map);
    }
    return map;
  }

  @CanIgnoreReturnValue
  @Override
  public @Nullable V put(R rowKey, C columnKey, V value) {
    checkNotNull(rowKey);
    checkNotNull(columnKey);
    checkNotNull(value);
    return getOrCreate(rowKey).put(columnKey, value);
  }

  @CanIgnoreReturnValue
  @Override

    //                                                                      ==============

    // GET /api/admin/duplicatehost/settings
    // PUT /api/admin/duplicatehost/settings
    /**
     * Returns list of duplicate host settings.
     * Supports both GET and PUT requests for retrieving paginated duplicate host configurations.
     *
     * @param body search parameters for filtering and pagination

        getInputs().property("rules", patterns);

        // add mandatory rules
        patterns.put("nocommit", "nocommit|NOCOMMIT");
        patterns.put("nocommit should be all lowercase or all uppercase", "((?i)nocommit)(?<!(nocommit|NOCOMMIT))");
        patterns.put("tab", "\t");
    }

    @InputFiles
    @PathSensitive(PathSensitivity.RELATIVE)
    @SkipWhenEmpty

     * Updates an existing role setting.
     *
     * @param body the role data to update
     * @return JSON response containing the updated role setting ID
     */
    // PUT /api/admin/role/setting
    @Execute
    public JsonResponse<ApiResult> put$setting(final EditBody body) {
        validateApi(body, messages -> {});
        body.crudMode = CrudMode.EDIT;
        final Role entity = getRole(body).orElseGet(() -> {

                    SortedMap<String, String> map = new SafeTreeMap<>();
                    for (Entry<String, String> entry : entries) {
                      map.put(entry.getKey(), entry.getValue());
                    }
                    return new StandardImplForwardingSortedMap<>(map);
                  }
                })
            .named(

        configureKotlinCompilerIoForWindowsSupport()
        val configuration = CompilerConfiguration().apply {

            put(CommonConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector)
            put(JVMConfigurationKeys.DISABLE_OPTIMIZATION, true)
            put(CommonConfigurationKeys.MODULE_NAME, "parser")

            configureKotlinCompilerForGradleBuild()

      ImmutableSortedMap.Builder<String, String> builder = ImmutableSortedMap.naturalOrder();
      for (Entry<String, String> entry : entries) {
        checkNotNull(entry);
        builder.put(entry.getKey(), entry.getValue());
      }
      return builder.build();
    }
  }

  public static class ImmutableSortedMapCopyOfEntriesGenerator
      extends TestStringSortedMapGenerator {
    @Override