"Trailers cannot be read because the state is $state"
    }
    return trailers
  }

  override fun flushRequest() {
    socket.sink.flush()
  }

  override fun finishRequest() {
    socket.sink.flush()
  }

  /** Returns bytes of a request header for sending on an HTTP transport. */
  fun writeRequest(
    headers: Headers,
    requestLine: String,
  ) {

/** Closes this, ignoring any checked exceptions.  */
internal fun ServerSocket.closeQuietly() {
  try {
    close()
  } catch (rethrown: RuntimeException) {
    throw rethrown
  } catch (_: Exception) {
  }
}

internal fun Long.toHexString(): String = java.lang.Long.toHexString(this)

internal fun Int.toHexString(): String = Integer.toHexString(this)

internal fun <T> readFieldOrNull(
  instance: Any,

     */
    private fun BaseGradleBuildType.getSubProjectSplitName() = largeSubProjectRegex.find(this.name)!!.groupValues[1]

    private fun BaseGradleBuildType.getGradleTasks(): String {
        val runnerStep = this.steps.items.find { it.name == "GRADLE_RUNNER" } as GradleBuildStep
        return runnerStep.tasks!!
    }

    private fun BaseGradleBuildType.getGradleParams(): String {

	public final fun requireClientAuth ()V
	public final fun setBodyLimit (J)V
	public final fun setDispatcher (Lokhttp3/mockwebserver/Dispatcher;)V
	public final fun setProtocolNegotiationEnabled (Z)V
	public final fun setProtocols (Ljava/util/List;)V
	public final fun setServerSocketFactory (Ljavax/net/ServerSocketFactory;)V
	public final fun shutdown ()V
	public final fun start ()V
	public final fun start (I)V

        }
    }

    private
    fun containsFailedTest(taskPath: String): Boolean {
        return testTaskPathToBinaryResultsDir[taskPath]?.let { containsFailedTest(it.get()) } == true
    }

    private
    fun addExecutedTaskPath(taskPath: String) {
        projectPathToExecutedTaskPaths.add(taskPathToProjectPath(taskPath), taskPath)
    }

    private
    fun addFailedTaskPath(taskPath: String) {

  }

  @Test
  fun stringWithDefaultCharsetAdded() {
    val contentType = "text/plain".toMediaType()
    val body = "\u0800".toRequestBody(contentType)
    assertThat(body.contentType()).isEqualTo("text/plain; charset=utf-8".toMediaType())
    assertThat(body.contentLength()).isEqualTo(3)
    assertThat(bodyToHex(body)).isEqualTo("e0a080")
  }

  @Test
  fun stringWithNonDefaultCharsetSpecified() {

  }

  @Test fun basicChallenge() {
    val headers =
      Headers
        .Builder()
        .add("WWW-Authenticate: Basic realm=\"protected area\"")
        .build()
    assertThat(headers.parseChallenges("WWW-Authenticate"))
      .isEqualTo(listOf(Challenge("Basic", mapOf("realm" to "protected area"))))
  }

  @Test fun basicChallengeWithCharset() {
    val headers =

    fail("")
  }

  override fun settings(
    clearPrevious: Boolean,
    settings: Settings,
  ) {
    fail("")
  }

  override fun ackSettings() {
    fail("")
  }

  override fun ping(
    ack: Boolean,
    payload1: Int,
    payload2: Int,
  ) {
    fail("")
  }

  override fun goAway(
    lastGoodStreamId: Int,
    errorCode: ErrorCode,
    debugData: ByteString,
  ) {

        }
    }

    @Test
    fun `from non-null accepting to null accepting is not breaking`() {

        checkBinaryCompatibleKotlin(
            v1 = """
                class Source(some: String) {
                    fun foo(bar: String) {}
                }
                operator fun Source.invoke(arg: String) {}
            """,
            v2 = """

  }

  @Test
  fun fragmentNonAscii() {
    val url = "http://host/#Σ".toHttpUrl()
    assertThat(url.toUri().toString()).isEqualTo("http://host/#Σ")
  }

  @Test
  fun fragmentPercentEncodedNonAscii() {
    val url = "http://host/#%C2%80".toHttpUrl()
    assertThat(url.toUri().toString()).isEqualTo("http://host/#%C2%80")
  }

  @Test
  fun fragmentPercentEncodedPartialCodePoint() {