bufferIndex += 2;
                pathOffset = readInt2(buffer, bufferIndex);
                bufferIndex += 2;
                altPathOffset = readInt2(buffer, bufferIndex);
                bufferIndex += 2;
                nodeOffset = readInt2(buffer, bufferIndex);
                bufferIndex += 2;

                path = readString(buffer, start + pathOffset, len, (flags2 & FLAGS2_UNICODE) != 0);

        byte[] buffer = new byte[100];
        int offset = 20;

        // Prepare data at offset
        int dataOffset = offset;
        SMBUtil.writeInt4(0, buffer, dataOffset);
        dataOffset += 4;
        SMBUtil.writeInt4(8, buffer, dataOffset);
        dataOffset += 4;
        SMBUtil.writeInt4(1000000, buffer, dataOffset);
        dataOffset += 4;
        SMBUtil.writeInt4(500000, buffer, dataOffset);

    /**
     * Creates a security descriptor by decoding from a byte buffer.
     *
     * @param buffer the byte buffer containing the security descriptor data
     * @param bufferIndex the starting offset in the buffer
     * @param len the length of data to decode
     * @throws IOException if an I/O error occurs during decoding
     */
    public SecurityDescriptor(final byte[] buffer, final int bufferIndex, final int len) throws IOException {

        domainInfo.name = new rpc.unicode_string();
        domainInfo.name.buffer = null;
        domainInfo.sid = null;

        // Encode to buffer
        byte[] buffer = new byte[1024];
        NdrBuffer encodeBuffer = new NdrBuffer(buffer, 0);
        domainInfo.encode(encodeBuffer);

        // Decode from buffer
        NdrBuffer decodeBuffer = new NdrBuffer(buffer, 0);
        lsarpc.LsarDomainInfo decodedInfo = new lsarpc.LsarDomainInfo();

     *
     * @param buffer memory buffer to register
     * @param access access permissions
     */
    public RdmaMemoryRegion(ByteBuffer buffer, EnumSet<RdmaAccess> access) {
        this.buffer = buffer;
        this.accessFlags = access;
        this.localKey = generateLocalKey();
        this.remoteKey = generateRemoteKey();
        this.address = getBufferAddress(buffer);
        this.valid = true;
    }

    public String getLocation() {
        StringBuilder buffer = new StringBuilder(256);

        if (!getSource().isEmpty()) {
            if (!buffer.isEmpty()) {
                buffer.append(", ");
            }
            buffer.append(getSource());
        }

        if (getLineNumber() > 0) {
            if (!buffer.isEmpty()) {
                buffer.append(", ");
            }

        assertNotNull(emptyUnicodeStringTrue.buffer, "Buffer should not be null for empty string with zterm");
        assertEquals(1, emptyUnicodeStringTrue.buffer.length, "Buffer length should be 1 for empty string with zterm");
        assertEquals(0, emptyUnicodeStringTrue.buffer[0], "Buffer should contain only zero for empty string with zterm");

        // Test with an empty string and zterm = false

            // Create a buffer with null terminator within the max length
            byte[] buffer = new byte[20];
            System.arraycopy("Test".getBytes(), 0, buffer, 0, 4);
            buffer[4] = 0; // null terminator
            System.arraycopy("String".getBytes(), 0, buffer, 5, 6);

            String result = testBlock.readString(buffer, 0, buffer.length, 10, false);

            assertEquals("Test", result);

            int bytesWritten = context.encode(buffer, 0);

            assertEquals(6, bytesWritten);
            assertEquals(2, SMBUtil.readInt2(buffer, 0));
            assertEquals(EncryptionNegotiateContext.CIPHER_AES128_CCM, SMBUtil.readInt2(buffer, 2));
            assertEquals(EncryptionNegotiateContext.CIPHER_AES128_GCM, SMBUtil.readInt2(buffer, 4));
        }

        @Test

        this.dataCount = dataCount;
    }

    /**
     * Sets the transaction buffer
     * @param buffer
     *            the transaction buffer to use
     */
    public void setBuffer(final byte[] buffer) {
        this.txn_buf = buffer;
    }

    /**
     * Releases and returns the transaction buffer
     * @return the txn_buf
     */
    public byte[] releaseBuffer() {