import org.junit.Test

abstract class BaseOkHttpClientUnitTest {
  private lateinit var client: OkHttpClient

  @Before
  fun setUp() {
    client =
      OkHttpClient
        .Builder()
        .cache(Cache(FakeFileSystem(), "/cache".toPath(), 10_000_000))
        .build()
  }

  @Test
  fun testRequestExternal() {
    assumeNetwork()

    val request = Request("https://www.google.com/robots.txt".toHttpUrl())

        int lineNum = 0;
        for (final String line : values) {
            final Matcher matcher = pattern.matcher(line);
            if (matcher.matches()) {
                if (lineNum == 0) {
                    lineNum = Integer.parseInt(matcher.group(1));
                    list.clear();
                }
                list.add(matcher.group(2));
            } else {
                list.add(line);
            }

// reasons. Note that ZFS is effectively the default filesystem on illumos
// systems.
//
// One benefit of using DirectIO on Linux is that the page cache will not be
// polluted with single-access data. The ZFS read cache (ARC) is scan-resistant
// so there is no risk of polluting the entire cache with data accessed once.
// Another goal of DirectIO is to minimize the mutation of data by the kernel

                /*
                 * NOTE: This is a sanity check of the cache hit. If the cached parent POM was locally resolved, the
                 * child's <relativePath> should point at that parent, too. If it doesn't, we ignore the cache and
                 * resolve externally, to mimic the behavior if the cache didn't exist in the first place. Otherwise,
                 * the cache would obscure a bad POM.
                 */

g(a,c,d){if(c||(c=b),l)return c.createElement(a);d||(d=f(c));var e;return e=d.cache[a]?d.cache[a].cloneNode():p.test(a)?(d.cache[a]=d.createElem(a)).cloneNode():d.createElem(a),!e.canHaveChildren||o.test(a)||e.tagUrn?e:d.frag.appendChild(e)}function h(a,c){if(a||(a=b),l)return a.createDocumentFragment();c=c||f(a);for(var e=c.frag.cloneNode(),g=0,h=d(),i=h.length;i>g;g++)e.createElement(h[g]);return e}function i(a,b){b.cache||(b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,...

  }
}


final String buildCacheUrl = System.getProperty('org.elasticsearch.build.cache.url')
final boolean buildCachePush = Boolean.valueOf(System.getProperty('org.elasticsearch.build.cache.push', 'false'))

if (buildCacheUrl) {
  final Map<String, String> buildCacheCredentials = vault.logical()
    .read("secret/elasticsearch-ci/gradle-build-cache")
    .getData()
  gradle.settingsEvaluated { settings ->
    settings.buildCache {

            JAVA15_HOME=$HOME/.java/openjdk15
      - shell: |
          #!/usr/local/bin/runbld --redirect-stderr

      assertThat(response!!.networkResponse).isNull()
    }

  /** Asserts that the current response didn't use the cache.  */
  fun assertNoCacheResponse() =
    apply {
      assertThat(response!!.cacheResponse).isNull()
    }

  /**
   * Asserts that the current response used the cache and returns the cache response.
   */
  fun cacheResponse(): RecordedResponse {
    val cacheResponse = response!!.cacheResponse!!

 */
public interface SidResolver {

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

        uses: actions/setup-python@v6
        with:
          python-version: ${{ matrix.python-version }}
      - name: Setup uv
        uses: astral-sh/setup-uv@v7
        with:
          enable-cache: true
          cache-dependency-glob: |
            pyproject.toml
            uv.lock
      - name: Install Dependencies
        run: uv sync --no-dev --group tests --extra all