return parent.remove(toCamelCase(key), value);
    }

    @Override
    public boolean replace(final K key, final V oldValue, final V newValue) {
        if (parent.replace(key, oldValue, newValue)) {
            return true;
        }
        return parent.replace(key, oldValue, newValue);
    }

    @Override
    public V replace(final K key, final V value) {
        // use original key

    }

    @Override
    @Nullable V getValue(int index) {
      return at(index, columnIndex);
    }

    @Override
    @Nullable V setValue(int index, @Nullable V newValue) {
      return set(index, columnIndex, newValue);
    }
  }

  /**
   * Returns an immutable set of the valid column keys, including those that are associated with
   * null values only.
   *

        if (!escape) {
            return value;
        }

        String newValue = value;
        for (final String element : Constants.RESERVED) {
            final String replacement = element.replaceAll("(.)", "\\\\$1");
            newValue = newValue.replace(element, replacement);
        }
        return newValue;
    }

    /**
     * Builds the complete query string from the configured parameters.

      long oldValue;
      long newValue;
      do {
        oldValue = data.get(longIndex);
        newValue = oldValue | mask;
        if (oldValue == newValue) {
          return false;
        }
      } while (!data.compareAndSet(longIndex, oldValue, newValue));

      // We turned the bit on, so increment bitCount.
      bitCount.increment();

      V value = localCache.get(key);
      if (value != null) {
        return value;
      }

      try {
        V newValue = valueLoader.call();
        localCache.put(key, newValue);
        return newValue;
      } catch (Exception e) {
        throw new ExecutionException(e);
      }
    }

    @Override
    public @Nullable V getIfPresent(Object key) {

        .apply {
          for (i in 0 until url.querySize) {
            val parameterName = url.queryParameterName(i)
            val newValue = if (parameterName in queryParamsNameToRedact) "██" else url.queryParameterValue(i)

            addEncodedQueryParameter(parameterName, newValue)
          }
        }.toString()
    }

    private fun logHeader(
      headers: Headers,
      i: Int,
    ) {

     *
     * @param key the key under which to store the session data, must not be {@code null}
     * @param oldValue the expected data currently associated with the key, may be {@code null}
     * @param newValue the data to associate with the key, may be {@code null} to remove the mapping
     * @return {@code true} if the key mapping was successfully updated from the old value to the new value,

   */
  private void replaceValueInEntry(int entry, @ParametricNullness V newValue, boolean force) {
    checkArgument(entry != ABSENT);
    int newValueHash = Hashing.smearedHash(newValue);
    int newValueIndex = findEntryByValue(newValue, newValueHash);
    if (newValueIndex != ABSENT) {
      if (force) {
        removeEntryValueHashKnown(newValueIndex, newValueHash);

    return (K) keys[index];
  }

  int getValue(int index) {
    checkElementIndex(index, size);
    return values[index];
  }

  void setValue(int index, int newValue) {
    checkElementIndex(index, size);
    values[index] = newValue;
  }

  Entry<K> getEntry(int index) {
    checkElementIndex(index, size);
    return new MapEntry(index);
  }

        assertEquals(true, builder.initialSettings.get("key3"));

        // Test overwriting existing setting
        builder.addInitialSettings("key1", "newValue1");
        assertEquals(3, builder.initialSettings.size());
        assertEquals("newValue1", builder.initialSettings.get("key1"));
    }

    @Test
    public void testAddInitialSettingsWithNullValue() {
        // Test adding null value