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`() {
    val deflater = MessageDeflater(false)

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

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

    if (perMessageDeflate && data.size >= minimumDeflateSize) {
      val messageDeflater =
        this.messageDeflater
          ?: MessageDeflater(noContextTakeover).also { this.messageDeflater = it }
      messageDeflater.deflate(messageBuffer)
      b0 = b0 or B0_FLAG_RSV1
    }
    val dataSize = messageBuffer.size
    sinkBuffer.writeByte(b0)

    var b1 = 0
    if (isClient) {
      b1 = b1 or B1_FLAG_MASK
    }

          builder.setProperty(
            Constants.COMPRESSION,
            when (entryCompression) {
              ZipEntryCompression.STORED -> Jar.Compression.STORE.name
              else -> Jar.Compression.DEFLATE.name
            },
          )
        }

        bundleJar.updateModified(archiveFile.lastModified(), "time of Jar task generated jar")
        bundleJar.manifest = Manifest()

    }

    @Test
    public void testCompressionMethod() {
        CurlRequest request = new CurlRequest(Method.GET, "https://example.com");
        String compression = "deflate";

        CurlRequest result = request.compression(compression);

        assertSame(request, result); // Fluent API
    }

    @Test
    public void testSslSocketFactoryMethod() {

"src/compress/bzip2/testdata/pass-random1.bz2", "src/compress/bzip2/testdata/pass-random2.bin", "src/compress/bzip2/testdata/pass-random2.bz2", "src/compress/bzip2/testdata/pass-sawtooth.bz2", "src/compress/bzip2/testdata/random.data.bz2", "src/compress/flate/deflate.go", "src/compress/flate/deflate_test.go", "src/compress/flate/deflatefast.go", "src/compress/flate/dict_decoder.go", "src/compress/flate/dict_decoder_test.go", "src/compress/flate/example_test.go", "src/compress/flate/flate_test.go", "src/compre...

        });
        req.compression("deflate");

        // ## Act ##
        try (CurlResponse response = req.execute()) {
            // ## Assert ##
            Map<String, List<String>> props = mockHolder[0].getRecordedRequestProperties();
            assertTrue("Accept-Encoding header should be set", props.containsKey("Accept-Encoding"));
            assertEquals("deflate", props.get("Accept-Encoding").get(0));
        }

      Header(RESPONSE_STATUS, "400"),
      Header(RESPONSE_STATUS, "404"),
      Header(RESPONSE_STATUS, "500"),
      Header("accept-charset", ""),
      Header("accept-encoding", "gzip, deflate"),
      Header("accept-language", ""),
      Header("accept-ranges", ""),
      Header("accept", ""),
      Header("access-control-allow-origin", ""),
      Header("age", ""),
      Header("allow", ""),

      }
    }

    streamsToClose?.forEach { stream ->
      ignoreIoExceptions {
        stream.close(streamCode, cause)
      }
    }

    // Close the writer to release its resources (such as deflaters).
    ignoreIoExceptions {
      writer.close()
    }

    // Cancel the socket to break out the reader thread, which will clean up after itself.
    ignoreIoExceptions {
      socket.cancel()
    }