super.put(entry);
      return this;
    }

    @CanIgnoreReturnValue
    @Override
    public Builder<K, V> putAll(Map<? extends K, ? extends V> map) {
      return putAll(map.entrySet());
    }

    @CanIgnoreReturnValue
    @Override
    public Builder<K, V> putAll(Iterable<? extends Entry<? extends K, ? extends V>> entries) {
      for (Entry<? extends K, ? extends V> entry : entries) {
        put(entry);

        }
        validateFields(body, 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);

     *
     * @since 3.3
     */
    @Input
    public Map<String, String> getProperties() {
        ImmutableMap.Builder<String, String> propertiesBuilder = ImmutableMap.builder();
        propertiesBuilder.putAll(properties);
        try {
            for (Map.Entry<String, Callable<String>> e : deferredProperties.entrySet()) {
                propertiesBuilder.put(e.getKey(), e.getValue().call());
            }

    }

    public CrawlerClientFactory getParent() {
        return factory;
    }

    @Override
    public void setInitParameterMap(final Map<String, Object> params) {
        this.params.putAll(params);
    }

    public void initParameterMap() {
        factory.setInitParameterMap(params);
    }

    @Override
    public void init() {
        factory.init();
    }

    @Override

 * the 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.
 *

                return b;
            } else if (b.isEmpty()) {
                return a;
            } else {
                return ImmutableSortedMap.<K, V>naturalOrder()
                    .putAll(a)
                    .putAll(b)
                    .build();
            }
        }
    }

  },

  /**
   * The entry itself was not actually removed, but its value was replaced by the user. This can
   * result from the user invoking {@link Cache#put}, {@link LoadingCache#refresh}, {@link Map#put},
   * {@link Map#putAll}, {@link ConcurrentMap#replace(Object, Object)}, or {@link
   * ConcurrentMap#replace(Object, Object, Object)}.
   */
  REPLACED {
    @Override
    boolean wasEvicted() {
      return false;
    }
  },

        result.load(new ByteArrayInputStream(outstr.toByteArray()))
        result == [added: 'value']
    }

    Properties props(Map map) {
        Properties props = new Properties()
        props.putAll(map)
        return props
    }

    Action action(Closure c) {
        new ClosureBackedAction(c)
    }

    List<V> valuesToPut = Arrays.asList(v0(), v1(), v0());

    for (K k : sampleKeys()) {
      resetContainer();

      Set<V> expectedValues = copyToSet(multimap().get(k));

      multimap().putAll(k, valuesToPut);
      expectedValues.addAll(valuesToPut);

      assertGet(k, expectedValues);
    }
  }

            }
            systemProperties.putAll(SystemPropertiesHandler.getSystemProperties(new File(determineRootDir(connectionParameters), "gradle.properties")));
            systemProperties.putAll(SystemPropertiesHandler.getSystemProperties(new File(determineRealUserHomeDir(connectionParameters), "gradle.properties")));
            return systemProperties;