* iterator tests.
   *
   * @return the new container instance
   * @param newValue the new container instance
   */
  @CanIgnoreReturnValue
  protected C resetContainer(C newValue) {
    container = newValue;
    return container;
  }

  /**
   * @see #expectContents(java.util.Collection)
   * @param elements expected contents of {@link #container}

  }

  @CanIgnoreReturnValue
  @Override
  @SuppressWarnings("nullness") // https://github.com/jspecify/jdk/issues/118
  public boolean replace(K key, V oldValue, V newValue) {
    return delegate().replace(key, oldValue, newValue);
  }

        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.

    V oldValue = table.get(row, column);
    if (oldValue == null) {
      table.put(row, column, value);
    } else {
      V newValue = mergeFunction.apply(oldValue, value);
      if (newValue == null) {
        table.remove(row, column);
      } else {
        table.put(row, column, newValue);
      }
    }
  }

  private TableCollectors() {}

    // different value
    assertThat(segment.replace(key, hash, oldValue, newValue)).isFalse();
    assertThat(segment.count).isEqualTo(1);
    assertThat(segment.get(key, hash)).isSameInstanceAs(newValue);

    // cleared
    entry.setValueReference(oldValueRef);
    assertThat(segment.get(key, hash)).isSameInstanceAs(oldValue);
    oldValueRef.clear();

    // different value
    assertThat(segment.replace(key, hash, oldValue, newValue)).isFalse();
    assertThat(segment.count).isEqualTo(1);
    assertThat(segment.get(key, hash)).isSameInstanceAs(newValue);

    // cleared
    entry.setValueReference(oldValueRef);
    assertThat(segment.get(key, hash)).isSameInstanceAs(oldValue);
    oldValueRef.clear();

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

        try {
          V newValue = valueLoader.call();
          // TODO(b/147136275): Perform a null check on the result.
          localCache.put(key, newValue);
          return newValue;
        } catch (Exception e) {
          throw new ExecutionException(e);
        }
      }
    }

    @Override

    Integer oldValue = map.putInstance(Integer.class, new Integer(7));
    assertEquals(5, (int) oldValue);

    Integer newValue = map.getInstance(Integer.class);
    assertEquals(7, (int) newValue);

    // Won't compile: map.putInstance(Double.class, new Long(42));
  }

  public void testNull() {

            String value1 = fessConfig.get(testKey);
            assertEquals(initialValue, value1);

            // Change system property
            String newValue = "changed";
            System.setProperty(Constants.FESS_CONFIG_PREFIX + testKey, newValue);

            // Get value again - in real FessConfigImpl it would be cached,
            // but our test implementation always checks system properties

    }

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