val cookieStrings = mutableListOf<String>()
    for (cookie in cookies) {
      cookieStrings.add(cookieToString(cookie, true))
    }
    val multimap = mapOf("Set-Cookie" to cookieStrings)
    try {
      cookieHandler.put(url.toUri(), multimap)
    } catch (e: IOException) {
      Platform.get().log("Saving cookies failed for " + url.resolve("/...")!!, WARN, e)
    }
  }

  override fun loadForRequest(url: HttpUrl): List<Cookie> {

    assertMethodPermitsRequestBody("DELETE")
    assertMethodForbidsRequestBody("HEAD")
    assertMethodPermitsRequestBody("OPTIONS")
    assertMethodPermitsRequestBody("POST")
    assertMethodPermitsRequestBody("PUT")
    assertMethodPermitsRequestBody("TRACE")
    assertMethodPermitsRequestBody("PATCH")
    assertMethodPermitsNoRequestBody("GET")
    assertMethodPermitsNoRequestBody("DELETE")

  }

  @Test fun taskFailsWithUncheckedException() {
    queue.schedule("task", TimeUnit.MILLISECONDS.toNanos(100)) {
      log.put("failing task running")
      throw RuntimeException("boom!")
    }

    queue.schedule("task", TimeUnit.MILLISECONDS.toNanos(200)) {
      log.put("normal task running")
      return@schedule -1L
    }

    queue.idleLatch().await(500, TimeUnit.MILLISECONDS)

    assertThat(post.method).isEqualTo("POST")
    assertThat(post.body).isEqualTo(body)

    val put = Request.Builder().url("http://localhost/api").put(body).build()
    assertThat(put.method).isEqualTo("PUT")
    assertThat(put.body).isEqualTo(body)

    val patch = Request.Builder().url("http://localhost/api").patch(body).build()
    assertThat(patch.method).isEqualTo("PATCH")

      contentLength: Long = -1L,
    ): ResponseBody = commonAsResponseBody(contentType, contentLength)

    @JvmStatic
    @Deprecated(
      message = "Moved to extension function. Put the 'content' argument first to fix Java",
      replaceWith =
        ReplaceWith(
          expression = "content.toResponseBody(contentType)",
          imports = ["okhttp3.ResponseBody.Companion.toResponseBody"],

          val editCountBefore = editCount
          yieldUntil { nanoTime >= waitUntil || editCount > editCountBefore }
        }
      }
    }

    override fun put(element: T) {
      taskRunner.lock.withLock {
        delegate.put(element)
        editCount++
      }
    }

    override fun iterator() = error("unsupported")

    override fun offer(e: T) = error("unsupported")

fun Request.Builder.commonDelete(body: RequestBody?): Request.Builder = method("DELETE", body)

fun Request.Builder.commonPut(body: RequestBody): Request.Builder = method("PUT", body)

fun Request.Builder.commonPatch(body: RequestBody): Request.Builder = method("PATCH", body)

fun Request.Builder.commonMethod(
  method: String,
  body: RequestBody?,
): Request.Builder =
  apply {

              ConnectResult(plan, throwable = e)
            }
          // Only post a result if this hasn't since been canceled.
          if (plan in tcpConnectsInFlight) {
            connectResults.put(connectResult)
          }
          return -1L
        }
      },
    )
    return null
  }

  private fun awaitTcpConnect(
    timeout: Long,
    unit: TimeUnit,
  ): ConnectResult? {

          fileSystem.source(this@asRequestBody).use { source -> sink.writeAll(source) }
        }
      }
    }

    @JvmStatic
    @Deprecated(
      message = "Moved to extension function. Put the 'content' argument first to fix Java",
      replaceWith =
        ReplaceWith(
          expression = "content.toRequestBody(contentType)",
          imports = ["okhttp3.RequestBody.Companion.toRequestBody"],

        val clientProviderClass = Class.forName("$alpnClassName\$ClientProvider", true, null)
        val serverProviderClass = Class.forName("$alpnClassName\$ServerProvider", true, null)
        val putMethod = alpnClass.getMethod("put", SSLSocket::class.java, providerClass)
        val getMethod = alpnClass.getMethod("get", SSLSocket::class.java)
        val removeMethod = alpnClass.getMethod("remove", SSLSocket::class.java)