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

    val goldenValue = "".encodeUtf8()

    val deflated = deflater.deflate(goldenValue)
    assertThat(deflated).isEqualTo("00".decodeHex())
    val inflated = inflater.inflate(deflated)

    assertThat(inflated).isEqualTo(goldenValue)
  }

  @Test fun `inflate deflate with 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,

		var compressedContent []byte
		if f.method == Deflate {
			var buf bytes.Buffer
			w, err := flate.NewWriter(&buf, flate.BestSpeed)
			if err != nil {
				t.Fatalf("flate.NewWriter err = %v", err)
			}
			_, err = w.Write(f.content)
			if err != nil {
				t.Fatalf("flate Write err = %v", err)
			}
			err = w.Close()
			if err != nil {
				t.Fatalf("flate Writer.Close err = %v", err)
			}

 * 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

	// Override the default Deflate compressor with a higher compression level.

	// Create a buffer to write our archive to.
	buf := new(bytes.Buffer)

	// Create a new zip archive.
	w := zip.NewWriter(buf)

	// Register a custom Deflate compressor.
	w.RegisterCompressor(zip.Deflate, func(out io.Writer) (io.WriteCloser, error) {
		return flate.NewWriter(out, flate.BestCompression)
	})

    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")
  }

	compressors.Store(Deflate, Compressor(func(w io.Writer) (io.WriteCloser, error) { return newFlateWriter(w), nil }))

	decompressors.Store(Store, Decompressor(io.NopCloser))
	decompressors.Store(Deflate, Decompressor(newFlateReader))
}

// RegisterDecompressor allows custom decompressors for a specified method ID.
// The common methods [Store] and [Deflate] are built in.

    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")
  }

    assertThat(recorded.headers["Accept"]).isEqualTo("text/plain")
    assertThat(
      recorded.headers["Accept-Encoding"]?.split(", ").orEmpty(),
    ).containsExactlyInAnyOrder(
      "gzip",
      "x-gzip",
      "deflate",
    )
    assertThat(recorded.headers["User-Agent"]!!).startsWith("Apache-HttpClient/")
  }

	h := FileHeader{
		Name:   filename,
		Method: Deflate,
		Extra:  []byte(ts.Format(time.RFC3339Nano)), // missing tag and len, but Extra is best-effort parsing
	}
	h.SetModTime(ts)

	testValidHeader(&h, t)
}

func TestHeaderTooShort(t *testing.T) {
	h := FileHeader{
		Name:   "foo.txt",
		Method: Deflate,