val request = Request.Builder()
            .url("https://publicobject.com/helloworld.txt")
            .build()

        client.newCall(request).execute().use { response ->
          if (!response.isSuccessful) throw IOException("Unexpected code $response")

          for ((name, value) in response.headers) {
            println("$name: $value")
          }

          println(response.body!!.string())
        }

      fun run() {
        val request = Request.Builder()
            .url("https://publicobject.com/robots.txt")
            .build()

        client.newCall(request).execute().use { response ->
          if (!response.isSuccessful) throw IOException("Unexpected code $response")

          for (certificate in response.handshake!!.peerCertificates) {
            println(CertificatePinner.pin(certificate))
          }
        }
      }
    ```

    client =
      client.newBuilder()
        .readTimeout(1000, TimeUnit.MILLISECONDS)
        .build()
    val call = client.newCall(request)
    val response = call.execute()
    assertThat(response.isSuccessful).isTrue()
  }

  /**
   * We delay sending the last byte of the request body 1500 ms. The 1000 ms read timeout shouldn't
   * elapse because it shouldn't start until the request body is sent.
   */
  @Test

      Platform.get().log("Incorrect protocol: ${response.protocol}", Platform.WARN)
    }

    response.use {
      if (!response.isSuccessful) {
        throw IOException("response: " + response.code + " " + response.message)
      }

      val body = response.body

      if (body.contentLength() > MAX_RESPONSE_SIZE) {
        throw IOException(

  )
  fun code(): Int = code

  /**
   * Returns true if the code is in [200..300), which means the request was successfully received,
   * understood, and accepted.
   */
  val isSuccessful: Boolean = commonIsSuccessful

  @JvmName("-deprecated_message")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "message"),
    level = DeprecationLevel.ERROR,
  )

    ```java
    Headers headers = Headers.of(name1, value1, name2, value2, ...).
    ```

 *  New: Make the content-type header optional for request bodies.
 *  New: `Response.isSuccessful()` is a convenient API to check response codes.
 *  New: The response body can now be read outside of the callback. Response
    bodies must always be closed, otherwise they will leak connections!

    val response: Response = Response.Builder().build()
    val request: Request = response.request
    val protocol: Protocol = response.protocol
    val code: Int = response.code
    val successful: Boolean = response.isSuccessful
    val message: String = response.message
    val handshake: Handshake? = response.handshake
    val headersForName: List<String> = response.headers("")
    val header: String? = response.header("")

            """
            include(":failed-test-with-leftover")
            include(":successful-test-with-leftover")
            include(":failed-report-with-leftover")
            include(":flaky-test-with-leftover")
            include(":flaky-test-without-leftover")
            include(":successful-report")
            """.trimIndent()
        )

        fun File.writeFlakyTest(fail: Boolean) {

                    "summary": "Read Dict",
                    "operationId": "read_dict_dict_get",
                    "responses": {
                        "200": {
                            "description": "Successful Response",
                            "content": {
                                "application/json": {
                                    "schema": {"$ref": "#/components/schemas/Model"}

                    "responses": {
                        "200": {
                            "description": "Successful Response",
                            "content": {"application/json": {"schema": {}}},
                        }
                    },
                }
            },