source.put("content", "Body");
        source.put("cache", "cached data");
        source.put("host", "example.com");

        final Set<String> excludeFields = Set.of("cache");
        final String json = new JsonIndexExportFormatter().format(source, excludeFields);

        assertFalse(json.contains("\"cache\""));
        assertTrue(json.contains("\"host\": \"example.com\""));
    }

  long size();

  /**
   * Returns a current snapshot of this cache's cumulative statistics, or a set of default values if
   * the cache is not recording statistics. All statistics begin at zero and never decrease over the
   * lifetime of the cache.
   *
   * <p><b>Warning:</b> this cache may not be recording statistical data. For example, a cache

   * default, OkHttp will perform lazy initialization upon the first usage of the cache.
   */
  @Throws(IOException::class)
  fun initialize() {
    cache.initialize()
  }

  /**
   * Closes the cache and deletes all of its stored values. This will delete all files in the cache
   * directory including files that weren't created by the cache.
   */

   * loaded entries; it will never contain null keys or values.
   *
   * <p>Caches loaded by a {@link CacheLoader} will issue a single request to {@link
   * CacheLoader#loadAll} for all keys which are not already present in the cache. All entries
   * returned by {@link CacheLoader#loadAll} will be stored in the cache, over-writing any

    assertThat(cache.size()).isEqualTo(MAX_SIZE);
    CacheTesting.processPendingNotifications(cache);
    assertThat(removalListener.getCount()).isEqualTo(MAX_SIZE);
    CacheTesting.checkValidState(cache);
  }

  /**
   * With an unlimited-size cache with maxWeight of 0, entries weighing 0 should still be cached.
   * Entries with positive weight should not be cached (nor dump existing cache).
   */

    for (LoadingCache<Object, Object> cache : caches()) {
      // don't let the entries get GCed
      List<Entry<Object, Object>> unused = warmUp(cache);
      assertThat(cache.size()).isEqualTo(WARMUP_SIZE);
      assertMapSize(cache.asMap(), WARMUP_SIZE);
      checkValidState(cache);
    }
  }

  public void testContainsKey_found() {
    for (LoadingCache<Object, Object> cache : caches()) {
      // don't let the entries get GCed

// This interface provides methods for creating new statements, retrieving all cache keys,
// getting cached statements, setting cached statements, and deleting cached statements.
type Store interface {
	// New creates a new Stmt object and caches it.
	// Parameters:
	//   ctx: The context for the request, which can carry deadlines, cancellation signals, etc.

    - name: Cache Gradle Modules
      uses: actions/cache@v5
      with:
        path: |
          ~/.gradle/caches/modules-2/
          ~/.gradle/caches/build-cache-1/
          ~/.gradle/caches/signatures/
          ~/.gradle/caches/keyrings/
        key: ${{ runner.os }}-gradle-cache-${{ hashFiles('gradle/wrapper/gradle-wrapper.properties') }}

        String[] fields = { "cache1", "cache2", "cache3" };
        queryFieldConfig.setCacheResponseFields(fields);

        String[] result = queryFieldConfig.getCacheResponseFields();
        assertSame(fields, result);
    }

    @Test
    public void test_setCacheResponseFields() {
        String[] fields = { "cache1", "cache2", "cache3" };
        queryFieldConfig.setCacheResponseFields(fields);

      assertThat(cache.getUnchecked(key)).isSameInstanceAs(value);
      assertThat(cache.asMap().isEmpty()).isFalse();
      cache.invalidateAll();
      assertThat(cache.size()).isEqualTo(0);
      assertThat(cache.asMap().isEmpty()).isTrue();
      assertThat(cache.asMap().containsKey(key)).isFalse();
      assertThat(cache.asMap().containsValue(value)).isFalse();
    }
  }

  public void testKeySetEntrySetValues() {