)
          } else if (gzippedLength != null) {
            logger.log("--> END ${request.method} (${buffer.size}-byte, $gzippedLength-gzipped-byte body)")
          } else {
            logger.log(buffer.readString(charset))
            logger.log("--> END ${request.method} (${requestBody.contentLength()}-byte body)")
          }
        }
      }

      getResponse(newRequest("/")).use { response ->
        readAscii(response.body.byteStream(), Int.MAX_VALUE)
      }
    }
  }

  /**
   * This test checks whether connections are gzipped by default. This behavior in not required by
   * the API, so a failure of this test does not imply a bug in the implementation.
   */
  @Test
  fun gzipEncodingEnabledByDefault() {
    server.enqueue(

      if (!skipCommasAndWhitespace() && !exhausted()) return // Expected ',' or EOF.
    }
    result.add(Challenge(schemeName, parameters))
  }
}

/** Returns true if any commas were skipped. */
private fun Buffer.skipCommasAndWhitespace(): Boolean {
  var commaFound = false
  loop@ while (!exhausted()) {
    when (this[0]) {
      ','.code.toByte() -> {
        // Consume ','.
        readByte()

      .assertLogEqual("Accept-Encoding: gzip")
      .assertLogMatch(Regex("""User-Agent: okhttp/.+"""))
      .assertLogEqual("")
      .assertLogEqual("--> END POST (12-byte, 32-gzipped-byte body)")
      .assertLogMatch(Regex("""<-- 200 OK $url \(\d+ms\)"""))
      .assertLogEqual("Content-Type: text/plain; charset=utf-8")
      .assertLogMatch(Regex("""Content-Length: \d+"""))
      .assertLogEqual("")

        .build()
    executeSynchronously("/").assertBody("abcabcabc")
  }

  @Test
  fun rangeHeaderPreventsAutomaticGzip() {
    val gzippedBody = gzip("abcabcabc")

    // Enqueue a gzipped response. Our request isn't expecting it, but that's okay.
    server.enqueue(
      MockResponse.Builder()
        .code(HttpURLConnection.HTTP_PARTIAL)
        .body(gzippedBody)

    // TODO: checkState open or half-closed (local) or raise STREAM_CLOSED
    val inFinished = flags and FLAG_END_STREAM != 0
    val gzipped = flags and FLAG_COMPRESSED != 0
    if (gzipped) {
      throw IOException("PROTOCOL_ERROR: FLAG_COMPRESSED without SETTINGS_COMPRESS_DATA")
    }

    val padding = if (flags and FLAG_PADDED != 0) source.readByte() and 0xff else 0

          server.hostName + ":" + server.port,
        )
        assertThat(networkRequest.header("Accept-Encoding")).isNotNull()

        // The network response also has everything, including the raw gzipped content.
        val networkResponse = chain.proceed(networkRequest)
        assertThat(networkResponse.header("Content-Encoding")).isEqualTo("gzip")
        networkResponse
      }
    client =

        header("Content-Encoding", "gzip")
      }

    val uncompressed = uncompress(response)

    val responseString = uncompressed.body.string()
    assertThat(responseString).contains("\"gzipped\": true,")
    assertThat(responseString).contains("\"Accept-Encoding\": \"br,gzip\"")
  }

  @Test
  fun testNoUncompress() {
    val response = response("https://httpbin.org/brotli", "XXXX".encodeUtf8())

  fun onHeaders(
    streamId: Int,
    responseHeaders: List<Header>,
    last: Boolean,
  ): Boolean

  /**
   * A chunk of response data corresponding to a pushed request.  This data must either be read or
   * skipped.
   *
   * @param streamId server-initiated stream ID: an even number.
   * @param source location of data corresponding with this stream ID.
   * @param byteCount number of bytes to read or skip from the source.

      return
    }

    when (message.type) {
      JsseDebugMessage.Type.Setup, JsseDebugMessage.Type.Encrypted, JsseDebugMessage.Type.Plaintext -> {
        println(message.message + " (skipped output)")
      }
      else -> println(message)
    }
  }

  fun enableJsseDebugLogging(debugHandler: (JsseDebugMessage) -> Unit = this::quietDebug): Closeable {
    System.setProperty("javax.net.debug", "")