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

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

	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,

}

// Create adds a file to the zip file using the provided name.
// It returns a [Writer] to which the file contents should be written.
// The file contents will be compressed using the [Deflate] method.
// The name must be a relative path: it must not start with a drive
// letter (e.g. C:) or leading slash, and only forward slashes are
// allowed. To create a directory instead of a file, add a trailing

[ZIP specification]: https://support.pkware.com/pkzip/appnote
*/
package zip

import (
	"io/fs"
	"path"
	"time"
)

// Compression methods.
const (
	Store   uint16 = 0 // no compression
	Deflate uint16 = 8 // DEFLATE compressed
)

const (
	fileHeaderSignature      = 0x04034b50
	directoryHeaderSignature = 0x02014b50
	directoryEndSignature    = 0x06054b50
	directory64LocSignature  = 0x07064b50

    client.listener.assertTextMessage(message)
  }

  @Test
  fun messagesCompressedWhenConfigured() {
    val headers = headersOf("Sec-WebSocket-Extensions", "permessage-deflate")
    client.initWebSocket(random, responseHeaders = headers)
    server.initWebSocket(random, responseHeaders = headers)
    val message = repeat('a', RealWebSocket.DEFAULT_MINIMUM_DEFLATE_SIZE.toInt())

    }

    /**
     * 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);

    }

    @Test
    public void testConstructorWithNullUrl() {
        // URL can be null with the two-argument constructor
        CurlRequest request = new CurlRequest(Method.DELETE, null);

        assertEquals(Method.DELETE, request.method());
        assertEquals("UTF-8", request.encoding());
        assertEquals(1024 * 1024, request.threshold());
        assertNull(request.proxy());
        assertNull(request.body());

        .build()
    assertThat(head.method).isEqualTo("HEAD")
    assertThat(head.body).isNull()

    val delete =
      Request
        .Builder()
        .url("http://localhost/api")
        .delete()
        .build()
    assertThat(delete.method).isEqualTo("DELETE")
    assertThat(delete.body!!.contentLength()).isEqualTo(0L)

    val post =
      Request
        .Builder()

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