private TransCallNamedPipeResponse response;
    private byte[] outputBuffer;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        outputBuffer = new byte[1024];
        response = new TransCallNamedPipeResponse(mockConfig, outputBuffer);
    }

    @Test
    void testConstructor() {
        assertNotNull(response);
        // Verify that the outputBuffer is stored properly

		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, () -> {

	go func() {
		defer wg.Done()

		tot := 0
		defer func() {
			ch <- tot
		}()

		serverConn, err := server.Accept()
		if err != nil {
			t.Error(err)
			return
		}

		buf := make([]byte, 1024)
		for {
			n, err := serverConn.Read(buf)
			tot += n
			if err == io.EOF {
				return
			}
			if err != nil {
				t.Error(err)
				return
			}
		}
	}()

        info.endOfFile = 1024;

        assertEquals("test.txt", info.getName());
        assertEquals(SmbFile.TYPE_FILESYSTEM, info.getType());
        assertEquals(SmbFile.ATTR_ARCHIVE, info.getAttributes());
        assertEquals(1672531200000L, info.createTime());
        assertEquals(1672617600000L, info.lastModified());
        assertEquals(1024, info.length());
    }

    @Test

    // request headers.
    // 431 "Request Header Fields Too Large"
    val largeHeaders =
      Headers
        .Builder()
        .apply {
          repeat(32) {
            add("name-$it", "value-$it-" + "0".repeat(1024))
          }
        }.build()
    val call2 =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .headers(largeHeaders)
          .build(),

            ensureOpen();
            final TransTransactNamedPipe req = new TransTransactNamedPipe(pipe.fid, b, off, len);
            if (dcePipe) {
                req.maxDataCount = 1024;
            }
            pipe.send(req, new TransTransactNamedPipeResponse(pipe));
        }
    }

    assertThrows(FileNotFoundException.class, () -> Files.map(file));
  }

  public void testMap_readWrite() throws IOException {
    // Test data
    int size = 1024;
    byte[] expectedBytes = new byte[size];
    byte[] bytes = newPreFilledByteArray(1024);

    // Setup
    File file = createTempFile();
    Files.write(bytes, file);

    Random random = new Random();
    random.nextBytes(expectedBytes);

        when(request.split()).thenReturn(nextRequest);
        when(request.allowChain(nextRequest)).thenReturn(true);
        when(request.createCancel()).thenReturn(nextRequest);
        when(request.size()).thenReturn(1024);
        when(request.getOverrideTimeout()).thenReturn(5000);

        // When & Then
        assertTrue(request.isResponseAsync());
        assertEquals(nextRequest, request.getNext());

                    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