- uses: actions/setup-python@v5
        with:
          python-version: '3.9'
      - name: Setup uv
        uses: astral-sh/setup-uv@v6
        with:
          version: "0.4.15"
          enable-cache: true
          cache-dependency-glob: |
            requirements**.txt
            pyproject.toml
      - run: uv pip install -r requirements-github-actions.txt
      - uses: actions/download-artifact@v5
        with:

        uses: actions/setup-python@v5
        with:
          python-version: "3.11"
      - name: Setup uv
        uses: astral-sh/setup-uv@v6
        with:
          version: "0.4.15"
          enable-cache: true
          cache-dependency-glob: |
            requirements**.txt
            pyproject.toml
      - name: Install Dependencies
        run: uv pip install -r requirements-github-actions.txt
      # Allow debugging with tmate

  }

  private fun enableCache(): Cache? {
    cache = makeCache()
    client = client.newBuilder().cache(cache).build()
    return cache
  }

  private fun makeCache(): Cache {
    val cacheDir = File.createTempFile("cache-", ".dir")
    cacheDir.delete()
    return Cache(cacheDir, (1024 * 1024).toLong())
  }

  companion object {

        this.maxContentLength = maxContentLength;
        return this;
    }

    /**
     * Sets the cache file size threshold in bytes.
     *
     * @param cacheFileSize the cache file size to set
     * @return this builder instance for method chaining
     */
    public ExtractorBuilder cacheFileSize(final int cacheFileSize) {

                }
            }
        }
    }

    /**
     * Resolve an array of SIDs using a cache and at most one MSRPC request.
     * <p>
     * This method will attempt
     * to resolve SIDs using a cache and cache the results of any SIDs that
     * required resolving with the authority. SID cache entries are currently not
     * expired because under normal circumstances SID information never changes.
     *

        assertEquals(threadCount * operationsPerThread, releases.get());

        // Verify cache statistics
        String stats = BufferCache.getCacheStatistics();
        assertNotNull(stats, "Cache statistics should be available");
        System.out.println("Buffer Cache Stats: " + stats);
    }

    /**
     * Test encryption context performance without synchronization bottlenecks
     */

    Object key = new Object();
    Object value = new Object();
    LoadingCache<Object, Object> cache =
        builder.build(CacheLoader.from(Suppliers.ofInstance(value)));
    assertSame(value, cache.getUnchecked(key));
    assertEquals(0, cache.size());
    assertFalse(cache.asMap().containsKey(key));
  }

  public void testCacheBuilderFrom_string() {
    CacheBuilder<?, ?> fromString =

        key = virtualHostHelper.getVirtualHostKey();
        assertEquals("", key); // Still empty due to caching

        // Test caching by calling again - should return cached value
        key = virtualHostHelper.getVirtualHostKey();
        assertEquals("", key); // Still cached value
    }

    public void test_getVirtualHostKey_withCaching() {
        ComponentUtil.setFessConfig(new FessConfig.SimpleImpl() {

     * Gets the fields that are included in cache search responses.
     *
     * @return array of field names for cache search responses
     */
    public String[] getCacheResponseFields() {
        return cacheResponseFields;
    }

    /**
     * Sets the fields that are included in cache search responses.
     *
     * @param cacheResponseFields array of field names for cache search responses
     */

    assertThat(cache.requestCount()).isEqualTo(1)
    assertThat(cache.networkCount()).isEqualTo(1)
    assertThat(cache.hitCount()).isEqualTo(0)
    val call2 = client.newCall(Request(server.url("/")))
    val response2 = call2.execute()
    assertThat(response2.body.string()).isEqualTo("A")
    assertThat(cache.requestCount()).isEqualTo(2)
    assertThat(cache.networkCount()).isEqualTo(2)