throws CIFSException {
        byte[] decompressed = decompress(compressedData, offset, length, algorithm);
        if (outputBuffer.length - outputOffset < decompressed.length) {
            throw new CIFSException("Output buffer too small");
        }
        System.arraycopy(decompressed, 0, outputBuffer, outputOffset, decompressed.length);
        return decompressed.length;
    }

    @Override

//   - BytesScanned => Number of bytes that have been processed before being uncompressed (if the file is compressed).
//   - BytesProcessed => Number of bytes that have been processed after being uncompressed (if the file is compressed).
//   - BytesReturned => Current number of bytes of records payload data returned by S3.
//
// For uncompressed files, BytesScanned and BytesProcessed are equal.
//
// Example:
//

    val response =
      response("https://httpbin.org/brotli", s.decodeHex()) {
        header("Content-Encoding", "br")
      }

    val uncompressed = brotliInterceptor.decompress(response)

    val responseString = uncompressed.body.string()
    assertThat(responseString).contains("\"brotli\": true,")
    assertThat(responseString).contains("\"Accept-Encoding\": \"br\"")
  }

  @Test

	CRC32 uint32

	// CompressedSize is the compressed size of the file in bytes.
	// If either the uncompressed or compressed size of the file
	// does not fit in 32 bits, CompressedSize is set to ^uint32(0).
	//
	// Deprecated: Use CompressedSize64 instead.
	CompressedSize uint32

	// UncompressedSize is the uncompressed size of the file in bytes.
	// If either the uncompressed or compressed size of the file

		// jar tool) don't properly set the storage method on directories
		// resulting in a file with compressed size > 0 but uncompressed size ==
		// 0. We still want to fail when a directory has associated uncompressed
		// data, but we are tolerant of cases where the uncompressed size is
		// zero but compressed size is not.
		if f.UncompressedSize64 != 0 {
			return &dirReader{ErrFormat}, nil
		} else {

    }

    @Test
    @DisplayName("Test LZ77+Huffman compression and decompression")
    public void testLZ77HuffmanCompression() throws CIFSException {
        byte[] compressed = compressionService.compress(testData, CompressionService.COMPRESSION_LZ77_HUFFMAN);
        assertNotNull(compressed);
        assertTrue(compressed.length > 0);

If there's no `gzip` in the header, it will not try to decompress the body.

That way, the same route class can handle gzip compressed or uncompressed requests.

{* ../../docs_src/custom_request_and_route/tutorial001_an_py310.py hl[9:16] *}

### Create a custom `GzipRoute` class { #create-a-custom-gziproute-class }

    server.enqueue(
      MockResponse
        .Builder()
        .setHeader("Content-Type", PLAIN)
        .body(Buffer().writeUtf8("Uncompressed"))
        .build(),
    )
    val response =
      client
        .newCall(
          request()
            .post("Uncompressed".toRequestBody())
            .gzip()
            .build(),
        ).execute()
    val responseBody = response.body

  fun request(): Request

  /**
   * Returns the size in bytes of all messages enqueued to be transmitted to the server. This
   * doesn't include framing overhead. If compression is enabled, uncompressed messages size
   * is used to calculate this value. It also doesn't include any bytes buffered by the operating
   * system or network intermediaries. This method returns 0 if no messages are waiting in the

			// the file needs a zip64 header. store maxint in both
			// 32 bit size fields (and offset later) to signal that the
			// zip64 extra header should be used.
			b.uint32(uint32max) // compressed size
			b.uint32(uint32max) // uncompressed size

			// append a zip64 extra block to Extra
			var buf [28]byte // 2x uint16 + 3x uint64
			eb := writeBuf(buf[:])
			eb.uint16(zip64ExtraID)
			eb.uint16(24) // size = 3x uint64