data class Inline1(
    override val rangeStart: Int,
    private val mappedTo: ByteString,
  ) : MappedRange {
    val b1: Int
      get() {
        val b3bit8 = mappedTo[0] and 0x80 != 0
        return if (b3bit8) 123 else 122
      }

    val b2: Int
      get() = mappedTo[0] and 0x7f
  }

  data class Inline2(
    override val rangeStart: Int,
    private val mappedTo: ByteString,
  ) : MappedRange {
    val b1: Int

      getResponse(
        Request(
          url = server.url("/"),
          body = "123".toRequestBody(null),
        ),
      ),
    )
    val request1 = server.takeRequest()
    assertThat(request1.sequenceNumber).isEqualTo(0)
    val request2 = server.takeRequest()
    assertThat(request2.body.readUtf8()).isEqualTo("123")
    assertThat(request2.sequenceNumber).isEqualTo(0)
  }

  @Test

 * 80..95 : Offset by a fixed positive offset. The bottom 4 bits of b1 are the top 4 bits of the offset.
 *    119 : Ignored.
 *    120 : Valid.
 *    121 : Disallowed
 *    122 : Mapped inline to the sequence: [b2].
 *    123 : Mapped inline to the sequence: [b2a].
 *    124 : Mapped inline to the sequence: [b2, b3].
 *    125 : Mapped inline to the sequence: [b2a, b3].
 *    126 : Mapped inline to the sequence: [b2, b3a].

    // LCat embedded
    assertThat(stringPrep("\u0627abc\u0628")).isNull()

    // RandALCat not last.
    assertThat(stringPrep("\u0627123")).isNull()

    // RandALCat not first.
    assertThat(stringPrep("123\u0628")).isNull()
  }

    assertThat(response.cacheResponse!!.request.url).isEqualTo(request.url)
  }

  @Test
  fun postWithOverrideResponse() {
    val url = server.url("/abc?token=123")
    val cacheUrlOverride = url.newBuilder().removeAllQueryParameters("token").build()

    val request =
      Request.Builder()
        .url(url)
        .method("POST", "XYZ".toRequestBody())

        sink.writeUtf8(body)
      }
    }

    val expected =
      """
      |--123
      |
      |Quick
      |--123
      |
      |Brown
      |--123
      |
      |Fox
      |--123--
      |
      """.trimMargin().replace("\n", "\r\n")
    val body =
      MultipartBody.Builder("123")
        .addPart("Quick".toRequestBody(null))
        .addPart(StreamingBody("Brown"))

   *
   * @param code Status code as defined by
   *     [Section 7.4 of RFC 6455](http://tools.ietf.org/html/rfc6455#section-7.4).
   * @param reason Reason for shutting down, no longer than 123 bytes of UTF-8 encoded data (**not** characters) or null.
   * @throws IllegalArgumentException if [code] is invalid or [reason] is too long.
   */
  fun close(
    code: Int,
    reason: String?,
  ): Boolean

  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)

    assertThat(formEncode(95)).isEqualTo("_")
    assertThat(formEncode(96)).isEqualTo("%60")
    assertThat(formEncode(97)).isEqualTo("a")
    assertThat(formEncode(122)).isEqualTo("z")
    assertThat(formEncode(123)).isEqualTo("%7B")
    assertThat(formEncode(124)).isEqualTo("%7C")
    assertThat(formEncode(125)).isEqualTo("%7D")
    assertThat(formEncode(126)).isEqualTo("%7E")
    assertThat(formEncode(127)).isEqualTo("%7F")

    server.enqueue(
      MockResponse(
        headers =
          headersOf(
            "B",
            "123",
            "B",
            "234",
          ),
      ),
    )
    executeSynchronously("/", "A", "345", "A", "456")
      .assertCode(200)
      .assertHeader("B", "123", "234")
    val recordedRequest = server.takeRequest()