* Read a connection-level ping from the peer. `ack` indicates this is a reply. The data
     * in `payload1` and `payload2` opaque binary, and there are no rules on the content.
     */
    fun ping(
      ack: Boolean,
      payload1: Int,
      payload2: Int,
    )

    /**
     * The peer tells us to stop creating streams. It is safe to replay streams with

    file!!.channel.force(false)

    // This file is complete.
    synchronized(this@Relay) {
      complete = true
    }

    upstream?.closeQuietly()
    upstream = null
  }

  fun metadata(): ByteString = metadata

  /**
   * Returns a new source that returns the same bytes as upstream. Returns null if this relay has
   * been closed and no further sources are possible. In that case callers should retry after

    derWriter.write("test", tagClass = DerHeader.TAG_CLASS_UNIVERSAL, tag = 30L) {
      derWriter.writeUtf8("a".repeat(201))
    }

    assertThat(buffer.readByteString(3)).isEqualTo("1e81c9".decodeHex())
    assertThat(buffer.readUtf8()).isEqualTo("a".repeat(201))
  }

  @Test fun `decode primitive bit string`() {
    val buffer =
      Buffer()

    val cache = Cache(cacheFs, "cache".toPath(), (100 * 1024).toLong())
    val cachedClient = bootstrapClient.newBuilder().cache(cache).build()
    val cachedDns = buildLocalhost(cachedClient, false)

    repeat(2) {
      server.enqueue(
        dnsResponse(
          "0000818000010003000000000567726170680866616365626f6f6b03636f6d0000010001c00c000500010" +

    server.listener.assertFailure()
  }

  @Test
  fun protocolErrorInCloseResponseClosesConnection() {
    client.webSocket!!.close(1000, "Hello")
    server.processNextFrame()
    // Not closed until close reply is received.
    assertThat(client.closed).isFalse()

    // Manually write an invalid masked close frame.
    server.sink.write("888760b420bb635c68de0cd84f".decodeHex()).emit()

    }
  }

  @Test
  fun singlePart() {
    val expected =
      """
      |--123
      |
      |Hello, World!
      |--123--
      |
      """.trimMargin().replace("\n", "\r\n")
    val body =
      MultipartBody.Builder("123")
        .addPart("Hello, World!".toRequestBody(null))
        .build()
    assertThat(body.boundary).isEqualTo("123")

  @Test
  fun closeReasonMaximumLength() {
    webServer.enqueue(
      MockResponse.Builder()
        .webSocketUpgrade(serverListener)
        .build(),
    )
    val clientReason = repeat('C', 123)
    val serverReason = repeat('S', 123)
    val webSocket: WebSocket = newWebSocket()
    val server = serverListener.assertOpen()
    clientListener.assertOpen()
    webSocket.close(1000, clientReason)

import kotlin.test.assertFailsWith
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import okhttp3.MediaType.Companion.toMediaTypeOrNull
import okhttp3.TestUtil.repeat
import okhttp3.testing.Flaky
import okio.BufferedSink
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Timeout

          }
        sink.writeShort(id)
        sink.writeInt(settings[i])
      }
      sink.flush()
    }
  }

  /**
   * Send a connection-level ping to the peer. `ack` indicates this is a reply. The data in
   * `payload1` and `payload2` opaque binary, and there are no rules on the content.
   */
  @Throws(IOException::class)
  fun ping(
    ack: Boolean,
    payload1: Int,
    payload2: Int,

    peer.sendFrame().settings(settings1)
    peer.acceptFrame() // ACK
    peer.sendFrame().ping(false, 2, 0)
    peer.acceptFrame() // PING
    peer.play()

    // Play it back.
    val connection =
      Http2Connection.Builder(true, TaskRunner.INSTANCE)
        .socket(peer.openSocket())
        .pushObserver(Http2ConnectionTest.IGNORE)
        .listener(realConnection)