deflater.setInput(data, offset, length);
            deflater.finish();

            ByteArrayOutputStream baos = new ByteArrayOutputStream(length);
            byte[] buffer = new byte[1024];

            while (!deflater.finished()) {
                int compressedSize = deflater.deflate(buffer);
                baos.write(buffer, 0, compressedSize);
            }

            deflater.end();

	{dataBlocks: 4, onDisks: 8, offDisks: 0, blocksize: int64(blockSizeV2), data: int64(2 * blockSizeV2), offset: 11, length: int64(blockSizeV2) + 2*1024, algorithm: DefaultBitrotAlgorithm, shouldFail: false, shouldFailQuorum: false},             // 29

		key int
	}{
		{16},
		{64},
		{128},
		{256},
		{512},
		{1024},
	}
	for _, testCase := range cases {
		key := randString(testCase.key)
		b.Run("", func(b *testing.B) {
			b.SetBytes(1024)
			b.ReportAllocs()
			b.ResetTimer()
			for b.Loop() {
				crcHashMod(key, 16)
			}
		})
	}
}

func BenchmarkSipHash(b *testing.B) {
	cases := []struct {
		key int
	}{
		{16},
		{64},

    @BeforeEach
    public void setUp() {
        validator = new ServerResponseValidator();
    }

    @Test
    public void testValidBuffer() throws Exception {
        byte[] buffer = new byte[1024];
        validator.validateBuffer(buffer, 100, 2048);
        // Should pass without exception
    }

    @Test
    public void testNullBuffer() throws Exception {
        assertThrows(SmbException.class, () -> {

                    if (type == SmbConstants.TYPE_NAMED_PIPE) {
                        // Use fixed 1024 values for named pipes
                        request.setMinCount(1024);
                        request.setMaxCount(1024);
                        request.setRemaining(1024);
                    } else if (this.largeReadX) {
                        // Optimize large read requests

                        // Simulate the atomic byte tracking operation
                        long start = System.nanoTime();
                        mockBytesEncrypted.addAndGet(1024); // Simulate 1KB message
                        long end = System.nanoTime();

                        totalTime.addAndGet(end - start);
                        operations.incrementAndGet();
                    }

          .url(server.url("/"))
          .build(),
      )
    val response = call.execute()
    interruptLater(500)
    val responseBody = response.body.byteStream()
    val buffer = ByteArray(1024)
    assertFailsWith<IOException> {
      while (responseBody.read(buffer) != -1) {
      }
    }
    responseBody.close()
  }

  @Test
  fun forciblyStopDispatcher() {
    client =

        int contextPos = 192;
        SMBUtil.writeInt2(1, buffer, contextPos); // Context type
        SMBUtil.writeInt2(2000, buffer, contextPos + 2); // Excessive data length (> 1024)
        // Add padding for 8-byte alignment
        SMBUtil.writeInt2(0, buffer, contextPos + 4); // Reserved

        // The validation logic is implemented and verified through code inspection

     */
    @Test
    public void testInvalidBufferSizeRejection() {
        // Given - Buffers with various invalid sizes
        byte[] tooSmall = new byte[1024];
        byte[] tooLarge = new byte[SmbComTransaction.TRANSACTION_BUF_SIZE + 1];
        byte[] empty = new byte[0];

        // When - Try to release invalid buffers
        assertDoesNotThrow(() -> {

    @BeforeEach
    public void setUp() {
        compressionService = new DefaultCompressionService();

        // Create test data with patterns that should compress well
        testData = generateTestData(1024);
        largeTestData = generateTestData(8192);
    }

    @Test
    @DisplayName("Test supported algorithms")
    public void testSupportedAlgorithms() {