final String key = LaFunctions.u(e.getKey());
            stream(e.getValue()).of(stream -> stream.filter(StringUtil::isNotBlank)
                    .forEach(s -> pagingQueryList.add("fields." + key + "=" + LaFunctions.u(s))));
        });
        form.as.entrySet().stream().filter(e -> e.getValue() != null).forEach(e -> {
            final String key = LaFunctions.u(e.getKey());

        request.getParameterMap().entrySet().stream().forEach(entry -> {
            if (entry.getValue().length > 1) {
                curlRequest.param(entry.getKey(), String.join(",", entry.getValue()));
            } else if (entry.getValue().length == 1) {
                curlRequest.param(entry.getKey(), entry.getValue()[0]);
            }
        });
        try (final CurlResponse curlResponse = curlRequest.onConnect((req, con) -> {

          RangeMap<Integer, Integer> expected = TreeRangeMap.create();
          for (Entry<Range<Integer>, Integer> entry : rangeMap.asMapOfRanges().entrySet()) {
            if (entry.getKey().isConnected(subRange)) {
              expected.put(entry.getKey().intersection(subRange), entry.getValue());
            }
          }
          RangeMap<Integer, Integer> subRangeMap = rangeMap.subRangeMap(subRange);

  }

  @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()));
  }

  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);

            if (pos == current) {
                newClientMap.put(Pattern.compile(regex), client);
                added = true;
            }
            newClientMap.put(entry.getKey(), entry.getValue());
            current++;
        }
        if (!added) {
            newClientMap.put(Pattern.compile(regex), client);
        }
        clientMap = newClientMap;
    }

                }
                System.setProperty(e.getKey(), e.getValue());
            });
        }
    }

    public String updateConfiguration() {
        final StringBuilder buf = new StringBuilder();
        updateConfigListenerMap.entrySet().stream().forEach(e -> {
            buf.append(e.getKey()).append(": ");
            try {

            Collections.sort(list, (o1, o2) -> {
                final String k1 = o1.getKey();
                if (LANG_KEY.equals(k1)) {
                    return -1;
                }
                final String k2 = o2.getKey();
                if (LANG_KEY.equals(k2)) {
                    return -1;
                }
                return k1.compareTo(k2);

                    for (String className : entry.getValue()) {
                        warning.append("    * " + className + "\n");
                    }
                    getLogger().warn(warning.toString());
                }
                mappingFileWriter.print(entry.getKey());
                mappingFileWriter.print(":");