LDP	11(R0), (R1, R2)    // 1b2c0091610b40a9
	LDP	1024(R0), (R1, R2)  // 1b001091610b40a9
	LDP.W	8(R0), (R1, R2)     // 0188c0a9
	LDP.P	8(R0), (R1, R2)     // 0188c0a8
	LDP	(RSP), (R1, R2)     // e10b40a9
	LDP	8(RSP), (R1, R2)    // e18b40a9
	LDP	-8(RSP), (R1, R2)   // e18b7fa9
	LDP	11(RSP), (R1, R2)   // fb2f0091610b40a9
	LDP	1024(RSP), (R1, R2) // fb031091610b40a9
	LDP.W	8(RSP), (R1, R2)    // e18bc0a9

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

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

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

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

        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

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

    this.isUserTypeFast = isUserTypeFast;
    this.random = checkNotNull(random);
    this.hitRate = hitRate;
    this.size = size;

    this.valuesInSet = createData();
    this.queries = createQueries(valuesInSet, 1024);
  }

  Set<Element> getValuesInSet() {
    return valuesInSet;
  }

  Element[] getQueries() {
    return queries;
  }

  private Element[] createQueries(Set<Element> elementsInSet, int numQueries) {

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