@JvmStatic
    fun parseAll(
      url: HttpUrl,
      headers: Headers,
    ): List<Cookie> {
      val cookieStrings = headers.values("Set-Cookie")
      var cookies: MutableList<Cookie>? = null

      for (i in 0 until cookieStrings.size) {
        val cookie = parse(url, cookieStrings[i]) ?: continue
        if (cookies == null) cookies = mutableListOf()
        cookies.add(cookie)

    internal var encodedPassword = ""
    internal var host: String? = null
    internal var port = -1
    internal val encodedPathSegments = mutableListOf<String>("")
    internal var encodedQueryNamesAndValues: MutableList<String?>? = null
    internal var encodedFragment: String? = null

    /**
     * @param scheme either "http" or "https".
     */
    fun scheme(scheme: String) =
      apply {
        when {

    assertThat(buffer.size).isEqualTo(150)
    val synStream = peer.takeFrame()
    assertThat(synStream.type).isEqualTo(Http2.TYPE_HEADERS)
    for (i in 0..2) {
      val windowUpdateStreamIds: MutableList<Int?> = ArrayList(2)
      for (j in 0..1) {
        val windowUpdate = peer.takeFrame()
        assertThat(windowUpdate.type).isEqualTo(Http2.TYPE_WINDOW_UPDATE)
        windowUpdateStreamIds.add(windowUpdate.streamId)

      .isEqualTo(1)
    assertThat(server2.takeRequest().exchangeIndex, "Expected connection reuse")
      .isEqualTo(1)
  }

  @Test
  fun redirectWithProxySelector() {
    val proxySelectionRequests: MutableList<URI> = ArrayList()
    client =
      client
        .newBuilder()
        .proxySelector(
          object : ProxySelector() {
            override fun select(uri: URI): List<Proxy> {

    server.enqueue(MockResponse(body = "DEF"))
    // Enqueue an additional response that show if we burnt a good prior response.
    server.enqueue(
      MockResponse(body = "XXX"),
    )
    val connections: MutableList<RealConnection?> = ArrayList()
    val localClient =
      client
        .newBuilder()
        .eventListener(
          object : EventListener() {
            override fun connectionAcquired(

          .build(),
      )
    assertThat(conditionalRequest.headers["If-Modified-Since"])
      .isEqualTo(lastModifiedDate)
  }

  @Test
  fun testPublicPathConstructor() {
    val events: MutableList<String> = ArrayList()
    fileSystem.createDirectories(cache.directoryPath)
    fileSystem.createDirectories(cache.directoryPath)
    val loggingFileSystem: FileSystem =
      object : ForwardingFileSystem(fileSystem) {

        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .inTunnel()
        .build(),
    )
    server.enqueue(MockResponse())
    val challengeSchemes: MutableList<String?> = ArrayList()
    val credential = basic("jesse", "password1")
    client =
      client
        .newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),