).encodeUtf8(),
    )
  }

  @Test
  fun multipleOperatorsShareOneFile() {
    val operatorA =
      FileOperator(
        randomAccessFile!!.getChannel(),
      )
    val operatorB =
      FileOperator(
        randomAccessFile!!.getChannel(),
      )
    val bufferA = Buffer()
    val bufferB = Buffer()
    bufferA.writeUtf8("Dodgson!\n")
    operatorA.write(0, bufferA, 9)

class Jdk8WithJettyBootPlatform(
  private val putMethod: Method,
  private val getMethod: Method,
  private val removeMethod: Method,
  private val clientProviderClass: Class<*>,
  private val serverProviderClass: Class<*>,
) : Platform() {
  override fun configureTlsExtensions(
    sslSocket: SSLSocket,
    hostname: String?,
    protocols: List<Protocol>,
  ) {
    val names = alpnProtocolNames(protocols)

    try {

    val serverRoot =
      HeldCertificate
        .Builder()
        .certificateAuthority(1)
        .build()
    val serverIntermediate =
      HeldCertificate
        .Builder()
        .certificateAuthority(0)
        .signedBy(serverRoot)
        .build()
    val serverCertificate =
      HeldCertificate
        .Builder()
        .signedBy(serverIntermediate)
        .build()
    val server =

    mockWebServer.dispatcher = dispatcher
    val url = mockWebServer.url("/").toUrl()
    val conn = url.openConnection() as HttpURLConnection
    conn.responseCode // Force the connection to hit the "server".
    // Make sure our dispatcher got the request.
    assertThat(requestsMade.size).isEqualTo(1)
  }

  @Test
  fun outOfOrderResponses() {
    val firstResponseCode = AtomicInteger()
    val secondResponseCode = AtomicInteger()

@Testcontainers
class BasicProxyTest {
  @Container
  val mockServer: MockServerContainer =
    MockServerContainer(MOCKSERVER_IMAGE)
      .withNetworkAliases("mockserver")

  @Test
  fun testOkHttpDirect() {
    testRequest {
      val client = OkHttpClient()

      val response =
        client
          .newCall(

import okio.FileSystem
import okio.Path.Companion.toPath

fun main(vararg args: String) {
  val data = loadIdnaMappingTableData()
  val file = generateMappingTableFile(data)
  file.writeTo(File(args[0]))
}

fun loadIdnaMappingTableData(): IdnaMappingTableData {
  val path = "/okhttp3/internal/idna/IdnaMappingTable.txt".toPath()
  val table =
    FileSystem.RESOURCES.read(path) {
      readPlainTextIdnaMappingTable()
    }

        this.description = stage.stageName.description
    }) {
    val specificBuildTypes: List<OsAwareBaseGradleBuildType>

    val performanceTests: List<PerformanceTestsPass>

    val functionalTests: List<OsAwareBaseGradleBuildType>

    val crossVersionTests: List<OsAwareBaseGradleBuildType>

    val docsTestTriggers: List<OsAwareBaseGradleBuildType>

    init {
        features {

class Http2Server(
  private val baseDirectory: File,
  private val sslSocketFactory: SSLSocketFactory,
) : Http2Connection.Listener() {
  private fun run() {
    val serverSocket = ServerSocket(8888)
    serverSocket.reuseAddress = true
    while (true) {
      var socket: Socket? = null
      try {
        socket = serverSocket.accept()
        val sslSocket = doSsl(socket)

  }

  companion object {
    private const val NO_CHUNK_YET = -1L

    private const val STATE_IDLE = 0 // Idle connections are ready to write request headers.
    private const val STATE_OPEN_REQUEST_BODY = 1
    private const val STATE_WRITING_REQUEST_BODY = 2
    private const val STATE_READ_RESPONSE_HEADERS = 3
    private const val STATE_OPEN_RESPONSE_BODY = 4
    private const val STATE_READING_RESPONSE_BODY = 5

    url: HttpUrl,
    header: String,
  ): List<Cookie> {
    val result = mutableListOf<Cookie>()
    var pos = 0
    val limit = header.length
    var pairEnd: Int
    while (pos < limit) {
      pairEnd = header.delimiterOffset(";,", pos, limit)
      val equalsSign = header.delimiterOffset('=', pos, pairEnd)
      val name = header.trimSubstring(pos, equalsSign)
      if (name.startsWith("$")) {