clientListener.assertClosed(1000, "")
    serverListener.assertClosed(1000, "")
  }

  @Test
  fun wsScheme() {
    assumeNotWindows()
    websocketScheme("ws")
  }

  @Test
  fun wsUppercaseScheme() {
    websocketScheme("WS")
  }

  @Test
  fun wssScheme() {
    webServer.useHttps(handshakeCertificates.sslSocketFactory())
    client =
      client
        .newBuilder()

                final String scheme = paramMap.get(CRAWLER_WEB_AUTH + "." + webAuthName + ".scheme");

                final AuthScheme authScheme = getAuthScheme(paramMap, webAuthName, scheme);
                final AuthScope authScope = getAuthScope(webAuthName, scheme, paramMap);
                final Credentials credentials = getCredentials(webAuthName, scheme, paramMap);

    assertThat(challenges.size).isEqualTo(1)
    assertThat(challenges[0].scheme).isEqualTo("Digest")
    assertThat(challenges[0].realm).isEqualTo("myrealm")
    assertThat(challenges[0].authParams)
      .isEqualTo(mapOf("realm" to "myrealm"))
  }

  @Test fun testDigestChallengeWithoutAuthParams() {
    // Scheme only.
    val headers =
      Headers
        .Builder()

      .isEqualTo("http://username:password@host/path?query#fragment")
  }

  @Test
  fun toUriFragmentSpecialCharacters() {
    val url =
      HttpUrl
        .Builder()
        .scheme("http")
        .host("host")
        .fragment("=[]:;\"~|?#@^/$%*")
        .build()
    assertThat(url.toString()).isEqualTo("http://host/#=[]:;\"~|?#@^/$%25*")
    assertThat(url.toUri().toString())

    val parse: CacheControl = CacheControl.parse(Headers.of())
  }

  @Test @Disabled
  fun challenge() {
    val challenge = Challenge("", mapOf("" to ""))
    val scheme: String = challenge.scheme()
    val authParams: Map<String?, String> = challenge.authParams()
    val realm: String? = challenge.realm()
    val charset: Charset = challenge.charset()
  }

  @Test @Disabled

     */
    public void setSoTimeout(final Integer soTimeout) {
        this.soTimeout = soTimeout;
    }

    /**
     * Sets the map of authentication scheme providers.
     * @param authSchemeProviderMap The map of authentication scheme providers.
     */
    public void setAuthSchemeProviderMap(final Map<String, AuthSchemeProvider> authSchemeProviderMap) {
        this.authSchemeProviderMap = authSchemeProviderMap;

        "GET",
        ":scheme",
        "http",
        ":path",
        "/",
        ":authority",
        "www.example.com",
      ),
    )
  }

  private fun secondRequestWithoutHuffman() {
    bytesIn.writeByte(0x82) // == Indexed - Add ==
    // idx = 2 -> :method: GET
    bytesIn.writeByte(0x86) // == Indexed - Add ==
    // idx = 7 -> :scheme: http

/** Returns true if an HTTP request for this URL and [other] can reuse a connection. */
internal fun HttpUrl.canReuseConnectionFor(other: HttpUrl): Boolean =
  host == other.host &&
    port == other.port &&
    scheme == other.scheme

internal fun EventListener.asFactory() = EventListener.Factory { this }

/**
 * Reads until this is exhausted or the deadline has been reached. This is careful to not extend the

 * **Cache**: directory
 * **CacheControl**: immutable, maxAgeSeconds, maxStaleSeconds, minFreshSeconds, mustRevalidate,
   noCache, noStore, noTransform, onlyIfCached, sMaxAgeSeconds
 * **Challenge**: authParams, charset, realm, scheme
 * **CipherSuite**: javaName
 * **ConnectionSpec**: cipherSuites, supportsTlsExtensions, tlsVersions
 * **Cookie**: domain, expiresAt, hostOnly, httpOnly, name, path, persistent, value
 * **Dispatcher**: executorService

    builder.add("", "pin1", "pin2")
  }

  @Test
  fun challenge() {
    var challenge = Challenge("", mapOf("" to ""))
    challenge = Challenge("", "")
    val scheme: String = challenge.scheme
    val authParams: Map<String?, String> = challenge.authParams
    val realm: String? = challenge.realm
    val charset: Charset = challenge.charset