val request = Request.Builder().url(server.url("/")).build()

    client.newCall(request).execute().use { response ->
      assertEquals(200, response.code)
    }

    client.connectionPool.evictAll()
    assertEquals(0, client.connectionPool.connectionCount())

    client.newCall(request).execute().use { response ->
      assertEquals(200, response.code)
    }

      .build()

  @JvmStatic
  fun providers(
    client: OkHttpClient,
    http2Only: Boolean,
    workingOnly: Boolean,
    getOnly: Boolean,
  ): List<DnsOverHttps> =
    buildList {
      add(buildGoogle(client))
      if (!getOnly) {
        add(buildGooglePost(client))
      }
      add(buildCloudflare(client))
      add(buildCloudflareIp(client))
      if (!getOnly) {

        body = "ABC.2",
      ),
    )
    client =
      client
        .newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).hostnameVerifier(nullHostnameVerifier)
        .build()
    val request = Request(server.url("/"))
    val response1: Response = client.newCall(request).execute()

        Properties props = new Properties();
        props.setProperty("jcifs.smb.client.useMultiChannel", "true");
        props.setProperty("jcifs.smb.client.maxChannels", "6");
        props.setProperty("jcifs.smb.client.channelBindingPolicy", "required");
        props.setProperty("jcifs.smb.client.loadBalancingStrategy", "least_loaded");
        props.setProperty("jcifs.smb.client.channelHealthCheckInterval", "15");

      ),
    )
    server!!.enqueue(MockResponse())
    val dns = FakeDns()
    dns["fakeurl"] = client.dns.lookup(server!!.hostName)
    dns["www.fakeurl"] = client.dns.lookup(server!!.hostName)
    client =
      client
        .newBuilder()
        .dns(dns)
        .build()
    val call =
      client.newCall(
        Request
          .Builder()
          .url("http://fakeurl:" + server!!.port)

        value = props.getProperty("jcifs.smb.client.username");
        if (value != null) {
            this.defaultUserName = value;
        }

        value = props.getProperty("jcifs.smb.client.password");
        if (value != null) {
            this.defaultPassword = value;
        }

        value = props.getProperty("jcifs.smb.client.domain");
        if (value != null) {

    OkHttpClient client = new OkHttpClient();

    sendRequest(client, "https://google.com/robots.txt");
  }

  private void sendRequest(OkHttpClient client, String url) throws IOException {
    Request request = new Request.Builder()
            .url(url)
            .build();
    try (Response response = client.newCall(request).execute()) {

 *    cache.
 *
 * Sometimes a request will result in a conditional cache hit. If the cache contains a stale copy of
 * the response, the client will issue a conditional `GET`. The server will then send either
 * the updated response if it has changed, or a short 'not modified' response if the client's copy
 * is still valid. Such responses increment both the network count and hit count.
 *

        .message("Intercepted!")
        .body("abc".toResponseBody("text/plain; charset=utf-8".toMediaType()))
        .build()
    client =
      client
        .newBuilder()
        .addInterceptor(Interceptor { chain: Interceptor.Chain? -> interceptorResponse })
        .build()
    val response = client.newCall(request).execute()
    assertThat(response).isSameInstanceAs(interceptorResponse)
  }

  @Test

     *
     * Property {@code jcifs.smb.client.capabilities} (int)
     *
     * @return custom capabilities
     */
    int getCapabilities();

    /**
     *
     *
     * Property {@code jcifs.smb.client.flags2} (int)
     *
     * @return custom flags2
     */
    int getFlags2();

    /**
     *
     * Property {@code jcifs.smb.client.ssnLimit} (int, 250)
     *