*
 * <p>A graph is composed of a set of nodes and a set of edges connecting pairs of nodes.
 *
 * <p>There are three primary interfaces provided to represent graphs. In order of increasing
 * complexity they are: {@link Graph}, {@link ValueGraph}, and {@link Network}. You should generally
 * prefer the simplest interface that satisfies your use case. See the <a

            @Override
            public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
                // This may cause IOException due to OpenSearch XContent complexity
                builder.startObject();
                builder.field("string", "test");
                builder.endObject();
                return builder;
            }
        };

        try {

   */

  private final transient @Nullable Object hashTable;
  @VisibleForTesting final transient @Nullable Object[] alternatingKeysAndValues;
  private final transient int size;

  /*
   * We have some considerable complexity in these create methods because of
   * Builder.buildKeepingLast(). The same Builder might be called with buildKeepingLast() and then
   * buildOrThrow(), or vice versa. So in particular, if we modify alternatingKeysAndValues to

    }

    if (requestMethod != "GET" && requestMethod != "QUERY") {
      // Don't cache non-GET and non-QUERY responses. We're technically allowed to cache HEAD
      // requests and some POST requests, but the complexity of doing so is high and the benefit
      // is low.
      return null
    }

    if (response.hasVaryAll()) {
      return null
    }

    val entry = Entry(response)

   * its capacity threshold.
   *
   * The Least Recently Used page replacement algorithm was chosen due to its simplicity, high hit
   * rate, and ability to be implemented with O(1) time complexity. The initial LRU implementation
   * operates per-segment rather than globally for increased implementation simplicity. We expect
   * the cache hit rate to be similar to that of a global LRU algorithm.
   */

        Map<String, String> complexObject = new HashMap<>();
        complexObject.put("nested", "value");

        dataStoreParams.put("complexKey", complexObject);
        assertEquals(complexObject, dataStoreParams.get("complexKey"));

        String asString = dataStoreParams.getAsString("complexKey");
        assertNotNull(asString);
        assertTrue(asString.contains("nested"));
    }

    // Test overwriting existing values