factory.close()
  }

  inner class FakePlan(
    val id: Int,
  ) : RoutePlanner.Plan {
    var planningThrowable: Throwable? = null
    var canceled = false
    var connectState = ConnectState.READY
    val connection =
      factory.newConnection(
        pool = pool,
        route = factory.newRoute(address),
        idleAtNanos = defaultConnectionIdleAtNanos,
      )
    var retry: FakePlan? = null

    require(length < bytesOut.size - lastFrame.start)

    // Move everything from bytesOut into a new buffer.
    val fullBuffer = Buffer()
    bytesOut.read(fullBuffer, bytesOut.size)

    // Copy back all but what we're truncating.
    fullBuffer.read(bytesOut, lastFrame.start + length)
    outFrames.add(OutFrame(lastFrame.sequence, lastFrame.start, true))
    return writer
  }

              TimeUnit.SECONDS,
              SynchronousQueue(),
              threadFactory("$okHttpName Dispatcher", false),
            )
        }
        return executorServiceOrNull!!
      }

  /** Ready async calls in the order they'll be run. */
  private val readyAsyncCalls = ArrayDeque<AsyncCall>()

  /** Running asynchronous calls. Includes canceled calls that haven't finished yet. */

    val source = relay.newSource()
    val sourceBuffer = Buffer()
    assertThat(source!!.read(sourceBuffer, 5)).isEqualTo(5)
    assertThat(sourceBuffer.readUtf8()).isEqualTo("abcde")
    assertThat(source.read(sourceBuffer, 1024)).isEqualTo(8)
    assertThat(sourceBuffer.readUtf8()).isEqualTo("fghijklm")
    assertThat(source.read(sourceBuffer, 1024)).isEqualTo(-1)
    assertThat(sourceBuffer.size).isEqualTo(0)
    source.close()

            request: UrlRequest,
            info: UrlResponseInfo,
          ) {
            println("onResponseStarted ${info.headers.asMap} ${info.negotiatedProtocol}")
            request.read(ByteBuffer.allocateDirect(4096 * 8))
          }

          override fun onReadCompleted(
            request: UrlRequest,
            info: UrlResponseInfo,
            byteBuffer: ByteBuffer,
          ) {

name: docs

on:
  push:
    branches:
      - master
  pull_request:
    types: [opened, labeled, unlabeled, synchronize]

permissions:
  contents: read

env:
  GRADLE_OPTS: "-Dorg.gradle.jvmargs=-Xmx4g -Dorg.gradle.daemon=false -Dkotlin.incremental=false"

jobs:
  test_docs:
    permissions:
      checks: write # for actions/upload-artifact
    runs-on: ubuntu-latest

      ConnectionSpec.COMPATIBLE_TLS.cipherSuites!!.map {
        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",

    }

    systemProperty("okhttp.platform", platform)
    systemProperty("junit.jupiter.extensions.autodetection.enabled", "true")
  }

  // https://publicobject.com/2023/04/16/read-a-project-file-in-a-kotlin-multiplatform-test/
  tasks.withType<Test>().configureEach {
    environment("OKHTTP_ROOT", rootDir)
  }

  if (platform == "jdk8alpn") {

name: containers

on:
  push:
    branches:
      - master
  pull_request:
    types: [opened, labeled, unlabeled, synchronize]

permissions:
  contents: read

env:
  GRADLE_OPTS: "-Dorg.gradle.jvmargs=-Xmx4g -Dorg.gradle.daemon=false -Dkotlin.incremental=false"

jobs:
  test_containers:
    permissions:
      checks: write # for actions/upload-artifact
    runs-on: ubuntu-latest

    }
  }

  private fun acceptCommand(
    fromAddress: InetAddress,
    fromSource: BufferedSource,
    fromSink: BufferedSink,
  ) {
    // Read the command.
    val version = fromSource.readByte() and 0xff
    if (version != VERSION_5) throw ProtocolException("unexpected version: $version")

    val command = fromSource.readByte() and 0xff