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)

        .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

}

// PopHealStatusJSON - Called by heal-status API. It fetches the heal
// status results from global state and returns its JSON
// representation. The clientToken helps ensure there aren't
// conflicting clients fetching status.
func (ahs *allHealState) PopHealStatusJSON(hpath string,
	clientToken string) ([]byte, APIErrorCode,
) {
	// fetch heal state for given path
	h, exists := ahs.getHealSequence(hpath)
	if !exists {

    server.enqueue(MockResponse.Builder().body("def").build())
    val client =
      clientTestRule
        .newClientBuilder()
        .proxy(socksProxy.proxy())
        .build()
    val request1 = Request.Builder().url(server.url("/")).build()
    val response1 = client.newCall(request1).execute()
    assertThat(response1.body.string()).isEqualTo("abc")

    val response = client.newCall(request).execute()
    assertThat(response.body.string()).isEqualTo("b")
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(1)
  }

  @Test
  fun connectionsNotReusedWithRedirectIfDiscardingResponseIsSlow() {
    client =
      client
        .newBuilder()

  private fun enableProtocol(protocol: Protocol) {
    enableTls()
    client =
      client
        .newBuilder()
        .protocols(listOf(protocol, Protocol.HTTP_1_1))
        .build()
    server1.protocols = client.protocols
    server2.protocols = client.protocols
  }

  private fun enableTls() {
    client =
      client
        .newBuilder()
        .sslSocketFactory(

* Adicionar um **Esquema JSON** para a resposta, na *operação de rota* do OpenAPI.
    * Isso será usado pela **documentação automática**.
    * Também será usado por ferramentas de geração automática de código do cliente.

Mas o mais importante:

    val proxySelector: ProxySelector = client.proxySelector
    val cookieJar: CookieJar = client.cookieJar
    val cache: Cache? = client.cache
    val socketFactory: SocketFactory = client.socketFactory
    val sslSocketFactory: SSLSocketFactory = client.sslSocketFactory
    val hostnameVerifier: HostnameVerifier = client.hostnameVerifier
    val certificatePinner: CertificatePinner = client.certificatePinner

import okhttp3.Request

fun main() {
  val client =
    OkHttpClient
      .Builder()
      .addInterceptor(BrotliInterceptor)
      .build()

  sendRequest("https://httpbin.org/brotli", client)
  sendRequest("https://httpbin.org/gzip", client)
}

private fun sendRequest(
  url: String,
  client: OkHttpClient,
) {
  val req = Request.Builder().url(url).build()

  client.newCall(req).execute().use {