}

  @Test fun clientEmptyClose() {
    clientWriter.writeClose(0, null)
    assertData("888060b420bb")
  }

  @Test fun clientCloseWithCode() {
    clientWriter.writeClose(1001, null)
    assertData("888260b420bb635d")
  }

  @Test fun clientCloseWithCodeAndReason() {
    clientWriter.writeClose(1001, "Hello".encodeUtf8())
    assertData("888760b420bb635d68de0cd84f")
  }

  }

  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(

  private var serverSocket: ServerSocket? = null
  private var socket: Socket? = null

  fun setClient(client: Boolean) {
    if (this.client == client) return
    this.client = client
    writer = Http2Writer(bytesOut, client)
  }

  fun acceptFrame() {
    frameCount++
  }

  /** Maximum length of an outbound data frame.  */
  fun maxOutboundDataLength(): Int = writer.maxDataLength()

  @AfterEach
  fun after() {
    assertThat(callbacks).isEmpty()
  }

  @Test
  fun multiline() {
    consumeEvents(
      """
      |data: YHOO
      |data: +2
      |data: 10
      |
      |
      """.trimMargin(),
    )
    assertThat(callbacks.remove()).isEqualTo(Event(null, null, "YHOO\n+2\n10"))
  }

  @Test
  fun multilineCr() {
    consumeEvents(
      """

     */
    fun connection(): Connection?

    fun call(): Call

    fun connectTimeoutMillis(): Int

    fun withConnectTimeout(
      timeout: Int,
      unit: TimeUnit,
    ): Chain

    fun readTimeoutMillis(): Int

    fun withReadTimeout(
      timeout: Int,
      unit: TimeUnit,
    ): Chain

    fun writeTimeoutMillis(): Int

}

private fun convertArgument(argument: FirEnumEntrySymbol, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
    return firSymbolBuilder.buildSymbol(argument)
}

private fun convertArgument(argument: FirRegularClassSymbol, firSymbolBuilder: KtSymbolByFirBuilder): Any? {
    return firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(argument)
}

        get() = KtFe10PackageSymbol(FqName.ROOT, analysisContext)

    override fun getFileSymbol(psi: KtFile): KtFileSymbol {
        return KtFe10FileSymbol(psi, analysisContext)
    }

    override fun getScriptSymbol(psi: KtScript): KtScriptSymbol {
        return KtFe10PsiScriptSymbol(psi, analysisContext)
    }

    override fun getParameterSymbol(psi: KtParameter): KtVariableLikeSymbol {
        return when {

 */
internal fun FirBasedSymbol<*>.isInvokeFunction() =
    (this as? FirNamedFunctionSymbol)?.fir?.name == OperatorNameConventions.INVOKE

fun FirFunctionCall.getCalleeSymbol(): FirBasedSymbol<*>? =
    calleeReference.getResolvedSymbolOfNameReference()

fun FirFunctionCall.getCandidateSymbols(): Collection<FirBasedSymbol<*>> =
    calleeReference.getCandidateSymbols()

  override fun callEnd(call: Call) {
    logWithTime("callEnd")

    delegate.callEnd(call)
  }

  override fun callFailed(
    call: Call,
    ioe: IOException,
  ) {
    logWithTime("callFailed: $ioe")

    delegate.callFailed(call, ioe)
  }

  override fun canceled(call: Call) {
    logWithTime("canceled")

    delegate.canceled(call)
  }

  override fun satisfactionFailure(

          .toDouble(),
      )
        .isCloseTo(elapsedMs.toDouble(), 100.0)
    }

    return result
  }

  fun recordedEventTypes() = eventSequence.map { it.name }

  fun clearAllEvents() {
    while (eventSequence.isNotEmpty()) {
      takeEvent()
    }
  }

  private fun logEvent(e: ConnectionEvent) {
    if (e.connection != null) {