val deflated = deflater.deflate(goldenValue)
    assertThat(deflated.size).isLessThan(goldenValue.size)
    val inflated = inflater.inflate(deflated)

    assertThat(inflated).isEqualTo(goldenValue)
  }

  @Test fun `inflate deflate empty message`() {
    val deflater = MessageDeflater(false)
    val inflater = MessageInflater(false)

    val goldenValue = "".encodeUtf8()

    }

    /**
     * Compresses data using LZ77 algorithm (implemented using Java's Deflater).
     */
    private byte[] compressLZ77(byte[] data, int offset, int length) throws CIFSException {
        try {
            Deflater deflater = new Deflater(COMPRESSION_LEVEL, false);
            deflater.setInput(data, offset, length);
            deflater.finish();

            ByteArrayOutputStream baos = new ByteArrayOutputStream(length);

 * Sec-WebSocket-Extensions: permessage-deflate; client_no_context_takeover
 * Sec-WebSocket-Extensions: permessage-deflate; server_max_window_bits="15"
 * Sec-WebSocket-Extensions: permessage-deflate; server_max_window_bits=15
 * Sec-WebSocket-Extensions: permessage-deflate; server_no_context_takeover
 * Sec-WebSocket-Extensions: permessage-deflate; server_no_context_takeover;
 *     client_no_context_takeover

  }

  @Test
  fun emptyParameters() {
    assertThat(parse("permessage-deflate;"))
      .isEqualTo(WebSocketExtensions(perMessageDeflate = true))
  }

  @Test
  fun repeatedPerMessageDeflate() {
    assertThat(parse("permessage-deflate, permessage-deflate; server_no_context_takeover"))
      .isEqualTo(
        WebSocketExtensions(
          perMessageDeflate = true,
          serverNoContextTakeover = true,

    successfulExtensions("permessage-deflate")
  }

  @Test
  @Throws(Exception::class)
  fun compressedMessagesNoClientContextTakeover() {
    successfulExtensions("permessage-deflate; client_no_context_takeover")
  }

  @Test
  @Throws(Exception::class)
  fun compressedMessagesNoServerContextTakeover() {
    successfulExtensions("permessage-deflate; server_no_context_takeover")
  }

                        "host": "testserver",
                        "traceparent": "123",
                        "x_tag": [],
                        "accept": "*/*",
                        "accept-encoding": "gzip, deflate",
                        "connection": "keep-alive",
                        "user-agent": "testclient",
                        "save-data": "true",
                        "if-modified-since": "yesterday",

    val response =
      response("https://example.com/", s) {
        header("Content-Encoding", "deflate")
      }

    val decompressed = zstdInterceptor.decompress(response)
    assertThat(decompressed.header("Content-Encoding")).isEqualTo("deflate")

    val responseString = decompressed.body.string()
    assertThat(responseString).isEqualTo("hello unknown algorithm world")
  }

) : Closeable {
  private val deflatedBytes = Buffer()

  // Lazily-created.
  private var inflater: Inflater? = null
  private var inflaterSource: InflaterSource? = null

  /** Inflates [buffer] in place as described in RFC 7692 section 7.2.2. */
  @Throws(IOException::class)
  fun inflate(buffer: Buffer) {
    require(deflatedBytes.size == 0L)

    val inflater =
      this.inflater

    }

    val recorded = server.takeRequest()
    assertThat(recorded.headers["Accept"]).isEqualTo("text/plain")
    assertThat(recorded.headers["Accept-Encoding"]).isEqualTo("gzip, x-gzip, deflate")
    assertThat(recorded.headers["User-Agent"]!!).startsWith("Apache-HttpClient/")
  }

   * structures.
   *
   * We make such subtle calls in [okhttp3.internal.ws.MessageInflater] because we try to read a
   * compressed stream that is terminated in a web socket frame even though the DEFLATE stream is
   * not terminated.
   *
   * Use this method to create a degenerate Okio Buffer where each byte is in a separate segment of
   * the internal list.
   */
  @JvmStatic