@DisplayName("Should correctly calculate path offset from header start")
    void testPathOffsetCalculation() throws Exception {
        // Given
        byte[] buffer = new byte[512];
        int headerStart = 64;

        // When
        request.encode(buffer, headerStart);

        // Then
        int bodyOffset = headerStart + Smb2Constants.SMB2_HEADER_LENGTH;
        // Path offset should be relative to headerStart

    /**
     * Decodes a resource change notification message.
     */
    private void decodeResourceChangeMessage(NdrBuffer buf, WitnessNotificationMessage message) throws NdrException {
        // Timestamp (FILETIME - 64-bit)
        long timestamp = buf.dec_ndr_hyper();
        message.setTimestamp(timestamp);

        // Resource name
        String resourceName = decodeWideStringPointer(buf);

pkg crypto/sha3, func Sum224([]uint8) [28]uint8 #69982
pkg crypto/sha3, func Sum256([]uint8) [32]uint8 #69982
pkg crypto/sha3, func Sum384([]uint8) [48]uint8 #69982
pkg crypto/sha3, func Sum512([]uint8) [64]uint8 #69982
pkg crypto/sha3, func SumSHAKE128([]uint8, int) []uint8 #69982
pkg crypto/sha3, func SumSHAKE256([]uint8, int) []uint8 #69982
pkg crypto/sha3, method (*SHA3) AppendBinary([]uint8) ([]uint8, error) #69982

    }

    @Test
    @DisplayName("writeBytesWireFormat should write correct structure")
    void testWriteBytesWireFormat() {
        byte[] buffer = new byte[256];
        int offset = 64; // Start at offset to test proper indexing

        int written = request.writeBytesWireFormat(buffer, offset);

        // Verify bytes written
        assertEquals(24, written);

                        new Trans2SetFileInformationResponse(th.getConfig()), RequestParam.NO_RETRY);
            } else {
                // this is the original, COM_WRITE allows truncation but no 64 bit offsets
                final SmbComWriteResponse rsp = new SmbComWriteResponse(th.getConfig());
                th.send(new SmbComWrite(th.getConfig(), fh.getFid(), (int) (newLength & 0xFFFFFFFFL), 0, this.tmp, 0, 0), rsp,

            request.setOffset(1024L);
            request.setRemainingBytes(500);
            request.setWriteFlags(0x01);

            byte[] buffer = new byte[1024];
            int headerStart = 64; // Simulated header start

            // Execute
            int bytesWritten = request.writeBytesWireFormat(buffer, headerStart);

            // Verify structure

	VPTERNLOGD $64, Z0, Z7, K7, Z3                     // 62f3454f25d840
	VPTERNLOGD $64, Z6, Z7, K7, Z3                     // 62f3454f25de40
	VPTERNLOGD $64, 7(AX)(CX*4), Z7, K7, Z3            // 62f3454f259c880700000040
	VPTERNLOGD $64, 7(AX)(CX*1), Z7, K7, Z3            // 62f3454f259c080700000040
	VPTERNLOGD $64, Z0, Z9, K7, Z3                     // 62f3354f25d840

    private final AtomicLong totalAllocated;
    private final AtomicLong totalReleased;
    
    // Buffer pool configuration
    private final int initialSendBuffers = 32;
    private final int initialReceiveBuffers = 64;
    private final int sendBufferSize = 65536;      // 64KB
    private final int receiveBufferSize = 65536;   // 64KB
    
    public RdmaBufferManager(RdmaProvider provider) {
        this.provider = provider;

  public void testBitSize() {
    double fpp = 0.03;
    for (int i = 1; i < 10000; i++) {
      long numBits = BloomFilter.optimalNumOfBits(i, fpp);
      int arraySize = Ints.checkedCast(LongMath.divide(numBits, 64, RoundingMode.CEILING));
      assertEquals(
          arraySize * Long.SIZE,
          BloomFilter.create(Funnels.unencodedCharsFunnel(), i, fpp).bitSize());
    }
  }

    /** Account control bit flag: MNS logon user account */
    public static final int ACB_MNS = 32;
    /** Account control bit flag: Interdomain trust account */
    public static final int ACB_DOMTRUST = 64;
    /** Account control bit flag: Workstation trust account */
    public static final int ACB_WSTRUST = 128;
    /** Account control bit flag: Server trust account */
    public static final int ACB_SVRTRUST = 256;