info: UrlResponseInfo,
          ) {
            println("onSucceeded ${info.headers.asMap}")
            completableFuture.complete(Response(info.httpStatusCode, info.negotiatedProtocol, buffer.readUtf8()))
          }

          override fun onFailed(
            request: UrlRequest,
            info: UrlResponseInfo?,
            error: HttpException,
          ) {

        ianaSuites.fromJavaName(it.javaName)
      },
  )
}

fun historicOkHttp(version: String): Client {
  val enabled =
    FileSystem.RESOURCES.read("okhttp_$version.txt".toPath()) {
      this.readUtf8().lines().filter { it.isNotBlank() }.map {
        SuiteId(id = null, name = it.trim())
      }
    }
  return Client(
    userAgent = "OkHttp",
    version = version,
    enabled = enabled,
  )
}

    id: String?,
    type: String?,
    data: Buffer,
  ) {
    if (data.size != 0L) {
      lastId = id
      data.skip(1L) // Leading newline.
      callback.onEvent(id, type, data.readUtf8())
    }
  }

  companion object {
    val options =
      Options.of(
        // 0
        "\r\n".encodeUtf8(),
        // 1
        "\r".encodeUtf8(),
        // 2

          throw ProtocolException("Malformed close payload length of 1.")
        } else if (bufferSize != 0L) {
          code = controlFrameBuffer.readShort().toInt()
          reason = controlFrameBuffer.readUtf8()
          val codeExceptionMessage = WebSocketProtocol.closeCodeExceptionMessage(code)
          if (codeExceptionMessage != null) throw ProtocolException(codeExceptionMessage)
        }

  get() = getEnv("OKHTTP_ROOT")!!.toPath()

fun String(vararg codePoints: Int): String {
  val buffer = Buffer()
  for (codePoint in codePoints) {
    buffer.writeUtf8CodePoint(codePoint)
  }
  return buffer.readUtf8()

  private val results = LinkedBlockingQueue<FutureTask<Void>>()

  fun receiveRequest(expected: String) =
    apply {
      actions += { stream ->
        val actual = stream.requestBody.readUtf8(expected.utf8Size())
        if (actual != expected) throw AssertionError("$actual != $expected")
      }
    }

  fun exhaustRequest() =
    apply {
      actions += { stream ->

    }
    return result.readUtf8()
  }

  fun readRelativeObjectIdentifier(): String {
    val result = Buffer()
    val dot = '.'.code.toByte().toInt()
    while (byteCount < limit) {
      if (result.size > 0) {
        result.writeByte(dot)
      }
      result.writeDecimalLong(readVariableLengthLong())
    }
    return result.readUtf8()
  }

        return null
      }

      if (dot < limit) {
        result.writeByte('.'.code)
        pos = dot + 1
      } else {
        break
      }
    }

    return result.readUtf8()
  }

  private fun encodeLabel(
    string: String,
    pos: Int,
    limit: Int,
    result: Buffer,
  ): Boolean {
    if (!string.requiresEncode(pos, limit)) {

    var chunkSizes: List<Int> = recordedRequest.chunkSizes
    var bodySize: Long = recordedRequest.bodySize
    var body: Buffer = recordedRequest.body
    var utf8Body: String = recordedRequest.body.readUtf8()
    var sequenceNumber: Int = recordedRequest.sequenceNumber
    var tlsVersion: TlsVersion? = recordedRequest.tlsVersion
    var handshake: Handshake? = recordedRequest.handshake
  }

  @Test @Ignore

      val path = okHttpRoot / "okhttp/src/test/resources/web-platform-test-toascii.json"
      return SYSTEM_FILE_SYSTEM.read(path) {
        Json.decodeFromString<List<WebPlatformToAsciiData>>(readUtf8())
      }
    }
  }