private lateinit var originalDefault: TimeZone

  @BeforeEach
  fun setUp() {
    originalDefault = TimeZone.getDefault()
    // The default timezone should affect none of these tests: HTTP specified GMT, so we set it to
    // something else.
    TimeZone.setDefault(TimeZone.getTimeZone("America/Los_Angeles"))
  }

  @AfterEach
  @Throws(Exception::class)
  fun tearDown() {
    TimeZone.setDefault(originalDefault)
  }

  var scheme = ""
  var username = ""
  var password: String? = null
  var host = ""
  var port = ""
  var path = ""
  var query = ""
  var fragment = ""

  fun expectParseFailure() = scheme.isEmpty()

  private operator fun set(
    name: String,
    value: String,
  ) {
    when (name) {
      "s" -> scheme = value
      "u" -> username = value
      "pass" -> password = value

import okhttp3.Headers.Companion.headersOf
import org.junit.jupiter.api.Test

class HeadersKotlinTest {
  @Test fun getOperator() {
    val headers = headersOf("a", "b", "c", "d")
    assertThat(headers["a"]).isEqualTo("b")
    assertThat(headers["c"]).isEqualTo("d")
    assertThat(headers["e"]).isNull()
  }

  @Test fun iteratorOperator() {
    val headers = headersOf("a", "b", "c", "d")

object EventSources {
  @Deprecated(
    message = "required for binary-compatibility!",
    level = DeprecationLevel.HIDDEN,
  )
  @JvmStatic
  fun createFactory(client: OkHttpClient) = createFactory(client as Call.Factory)

  @JvmStatic
  fun createFactory(callFactory: Call.Factory): EventSource.Factory {
    return EventSource.Factory { request, listener ->
      val actualRequest =

  @Throws(SignatureException::class)
  fun checkSignature(issuer: PublicKey): Boolean {
    val signedData = CertificateAdapters.tbsCertificate.toDer(tbsCertificate)

    return Signature.getInstance(tbsCertificate.signatureAlgorithmName).run {
      initVerify(issuer)
      update(signedData.toByteArray())
      verify(signatureValue.byteString.toByteArray())
    }
  }

  fun toX509Certificate(): X509Certificate {

    }
  }

  override fun equals(other: Any?): Boolean =
    other is AndroidCertificateChainCleaner &&
      other.trustManager === this.trustManager

  override fun hashCode(): Int = System.identityHashCode(trustManager)

  companion object {
    @SuppressSignatureCheck
    fun buildIfSupported(trustManager: X509TrustManager): AndroidCertificateChainCleaner? {

    @get:OutputFile
    abstract val manifestFile: RegularFileProperty

    @TaskAction
    fun generate() {
        ReproduciblePropertiesWriter.store(createProperties(), manifestFile.get().asFile)
    }

    private
    fun createProperties() = Properties().also { properties ->
        properties["runtime"] = runtime.get().joinToString(",")

    return true
  }

  private fun requestIsOneShot(
    e: IOException,
    userRequest: Request,
  ): Boolean {
    val requestBody = userRequest.body
    return (requestBody != null && requestBody.isOneShot()) ||
      e is FileNotFoundException
  }

  private fun isRecoverable(
    e: IOException,
    requestSendStarted: Boolean,
  ): Boolean {

     * response cache won't be used.
     */
    private fun hasConditions(request: Request): Boolean =
      request.header("If-Modified-Since") != null || request.header("If-None-Match") != null
  }

  companion object {
    /** Returns true if [response] can be stored to later serve another request. */
    fun isCacheable(
      response: Response,
      request: Request,
    ): Boolean {

  }

  override fun doExtensiveHealthChecks(): Boolean {
    return chain.request.method != "GET"
  }

  override fun isCanceled(): Boolean {
    return call.isCanceled()
  }

  override fun candidateConnection(): RealConnection? {
    return call.connection
  }

  override fun proxySelectStart(url: HttpUrl) {
    eventListener.proxySelectStart(call, url)
  }

  override fun proxySelectEnd(