*/

    /** The operation completed successfully */
    int NT_STATUS_SUCCESS = 0x00000000;
    /** The request is pending */
    int NT_STATUS_PENDING = 0x00000103;
    /** A notify change request is being completed and information is being returned */
    int NT_STATUS_NOTIFY_ENUM_DIR = 0x0000010C;
    /** The data was too large to fit into the specified buffer */
    int NT_STATUS_BUFFER_OVERFLOW = 0x80000005;

        // Then
        assertEquals(16, bytesRead);
        assertEquals(wireData.length, bytesRead);
        assertEquals((byte) 0x01, response.getShareType());
        assertEquals(0x00000001, response.getShareFlags());
        assertEquals(0x00000008, response.getCapabilities());
        assertEquals(0x001F01FF, response.getMaximalAccess());
    }

    @Test
    @DisplayName("Should not modify buffer during write operation")

outputLen: 48, dsbyte: dsbyteSHA3} } // New512 returns a new Digest computing the SHA3-512 hash. func New512() *Digest { return &Digest{rate: rateK1024, outputLen: 64, dsbyte: dsbyteSHA3} } const ( dsbyteSHA3 = 0b00000110 dsbyteKeccak = 0b00000001 dsbyteShake = 0b00011111 dsbyteCShake = 0b00000100 // rateK[c] is the rate in bytes for Keccak[c] where c is the capacity in // bits. Given the sponge size is 1600 bits, the rate is 1600 - c bits. rateK256 = (1600 - 256) / 8 rateK448 = (1600 - 448) / 8 rateK512...

    @DisplayName("Test readDataWireFormat with single share")
    void testReadDataWireFormatSingleShare() throws Exception {
        // Prepare test data
        String shareName = "SHARE1";
        int shareType = 0x00000000; // Disk share
        String remark = "Test share";

        // Calculate buffer size
        int shareNameSize = 14; // 13 bytes + null terminator (fixed field)
        int typeSize = 2;

    FAST_REGISTRATION   // Fast memory region registration
}

public class RdmaCapabilities {
    // RDMA transform capabilities
    public static final int SMB_DIRECT_RESPONSE_REQUESTED = 0x00000001;
    
    // Default RDMA settings
    public static final int DEFAULT_RDMA_READ_WRITE_SIZE = 1048576;  // 1MB
    public static final int DEFAULT_RECEIVE_CREDIT_MAX = 255;

    }

    private void prepareSimpleSid(byte[] buffer, int offset) {
        buffer[offset] = 0x01; // revision
        buffer[offset + 1] = 0x01; // sub-authority count
        // Identifier authority (0x00-00-00-00-00-01)
        buffer[offset + 2] = 0x00;
        buffer[offset + 3] = 0x00;
        buffer[offset + 4] = 0x00;
        buffer[offset + 5] = 0x00;
        buffer[offset + 6] = 0x00;
        buffer[offset + 7] = 0x01;

    int flags2 = FLAGS2;
    int maxMpxCount = MAX_MPX_COUNT;
    int snd_buf_size = SND_BUF_SIZE;
    int rcv_buf_size = RCV_BUF_SIZE;
    int capabilities = CAPABILITIES;
    int sessionKey = 0x00000000;
    boolean useUnicode = USE_UNICODE;
    String tconHostName = null;

    SmbTransport(final UniAddress address, final int port, final InetAddress localAddr, final int localPort) {
        this.address = address;

    private boolean rssCapable;  // Receive Side Scaling
    private boolean rdmaCapable;
    
    // Capability flags
    public static final int NETWORK_INTERFACE_CAP_RSS = 0x00000001;
    public static final int NETWORK_INTERFACE_CAP_RDMA = 0x00000002;
    
    public NetworkInterfaceInfo(InetAddress address, int linkSpeed) {
        this.address = address;
        this.linkSpeed = linkSpeed;

}

var x86OperandTests = []operandTest{
	{"$(2.928932188134524e-01)", "$(0.29289321881345243)"},
	{"$-1", "$-1"},
	{"$0", "$0"},
	{"$0x00000000", "$0"},
	{"$runtime·badmcall(SB)", "$runtime.badmcall(SB)"},
	{"$setg_gcc<>(SB)", "$setg_gcc<>(SB)"},
	{"$~15", "$-16"},
	{"(-64*1024+104)(SP)", "-65432(SP)"},
	{"(0*4)(BP)", "(BP)"},
	{"(1*4)(DI)", "4(DI)"},

			// Argsize set below.
		},
	}
	nameAddr.Sym.Func().Text = prog
	prog.To.Val = int32(argSize)
	p.append(prog, "", true)
}

// asmData assembles a DATA pseudo-op.
// DATA masks<>+0x00(SB)/4, $0x00000000
func (p *Parser) asmData(operands [][]lex.Token) {
	if len(operands) != 2 {
		p.errorf("expect two operands for DATA")
		return
	}

	// Operand 0 has the general form foo<>+0x04(SB)/4.
	op := operands[0]