public val failHandshake: Boolean
  public val onRequestStart: SocketEffect?
  public val doNotReadRequestBody: Boolean
  public val onRequestBody: SocketEffect?
  public val onResponseStart: SocketEffect?
  public val onResponseBody: SocketEffect?
  public val onResponseEnd: SocketEffect?
  public val shutdownServer: Boolean

  public val headersDelayNanos: Long
  public val bodyDelayNanos: Long
  public val trailersDelayNanos: Long

    open val paramName: String
      get() = override.paramName ?: name.replaceFirstChar { it.lowercase(getDefault()) }
  }

  class DelayingSocketFactory(
    val onConnect: Socket.(timeout: Int) -> Unit = {},
    val onRead: Socket.() -> Unit = {},
    val onWrite: Socket.() -> Unit = {},
  ) : DelegatingSocketFactory(getDefault()) {
    override fun createSocket(): Socket {

      )
    }
  }

  @Test
  fun byteStringEmpty() {
    val body = body("")
    assertThat(body.byteString()).isEqualTo(ByteString.EMPTY)
  }

  @Test
  fun byteStringSeesBom() {
    val body = body("efbbbf68656c6c6f")
    val actual = body.byteString()
    val expected: ByteString = "efbbbf68656c6c6f".decodeHex()
    assertThat(actual).isEqualTo(expected)
  }

        override val currentFile: File,

        override val currentSourceRoot: File

    ) : ApiSourceFile()
}


internal
data class JavaSourceQuery<T : Any?>(
    val defaultValue: T,
    val visitor: GenericVisitor<T, Unit?>
)


internal
class SourcesRepository(

    private
    val sourceRoots: List<File>,

    private
    val compilationClasspath: List<File>

@Timeout(60)
@Tag("Slow")
@Burst
class DiskLruCacheTest(
  subject: Subject = Subject.System,
) {
  private val baseFilesystem: FileSystem = subject.create()
  private val filesystem = FaultyFileSystem(baseFilesystem)
  private val windows = subject.windows

  @TempDir
  lateinit var cacheDirFile: File
  private val cacheDir: Path
    get() =
      when (baseFilesystem) {
        is FakeFileSystem -> "/cache".toPath()

        .build(),
    )
    val startNanos = System.nanoTime()
    val connection = server.url("/").toUrl().openConnection()
    connection.doOutput = true
    connection.getOutputStream().write("ABCDEF".toByteArray(UTF_8))
    val inputStream = connection.getInputStream()
    assertThat(inputStream.read()).isEqualTo(-1)
    val elapsedNanos = System.nanoTime() - startNanos

        .setBody("ABCDEF")
        .setBodyDelay(1, TimeUnit.SECONDS),
    )
    val startNanos = System.nanoTime()
    val connection = server.url("/").toUrl().openConnection()
    val inputStream = connection.getInputStream()
    assertThat(inputStream.read()).isEqualTo('A'.code)
    val elapsedNanos = System.nanoTime() - startNanos
    val elapsedMillis = TimeUnit.NANOSECONDS.toMillis(elapsedNanos)

  @RegisterExtension
  val platform = PlatformRule()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  @StartStop
  val server1 = MockWebServer()

  @StartStop
  val server2 = MockWebServer()

  private var eventRecorder = EventRecorder()

  private val handshakeCertificates = platform.localhostHandshakeCertificates()

  val dns = FakeDns()

  /** Returns the service that will be used to resolve IP addresses for hostnames. */
  @get:JvmName("dns") val dns: Dns,
  /** Returns the socket factory for new connections. */
  @get:JvmName("socketFactory") val socketFactory: SocketFactory,
  /** Returns the SSL socket factory, or null if this is not an HTTPS address. */
  @get:JvmName("sslSocketFactory") val sslSocketFactory: SSLSocketFactory?,

    override val timestampNs: Long,
    val route: Route,
    val call: Call,
    val exception: IOException,
  ) : ConnectionEvent() {
    override fun closes(event: ConnectionEvent): Boolean = event is ConnectStart && call == event.call && route == event.route
  }

  data class ConnectEnd(
    override val timestampNs: Long,
    override val connection: Connection,
    val route: Route,
    val call: Call,