// 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

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

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

    /**
     * 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 {

     *
     * @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(", ");
            }

            byte[] buffer1 = new byte[1024];
            int bytesRead1 = stream1.read(buffer1);
            assertEquals(testContent, new String(buffer1, 0, bytesRead1, "UTF-8"));
        }

        // Second read - should work independently
        try (InputStream stream2 = cache.getInputStream()) {
            byte[] buffer2 = new byte[1024];
            int bytesRead2 = stream2.read(buffer2);

                buffer.append(" | ");
            }
        }

        int pad = lastLength - buffer.length();
        lastLength = buffer.length();
        pad(buffer, pad);
        buffer.append('\r');
        out.print(buffer);
        out.flush();
        buffer.setLength(0);
    }

    private void pad(StringBuilder buffer, int spaces) {
        String block = "                                        ";

            writeLittleEndianInt(baos, PacConstants.PAC_VERSION); // version

            // Buffer 1: LOGON_INFO
            writeLittleEndianInt(baos, PacConstants.LOGON_INFO);
            writeLittleEndianInt(baos, 8); // minimal size
            writeLittleEndianLong(baos, 72); // offset (aligned)

            // Buffer 2: SERVER_CHECKSUM
            writeLittleEndianInt(baos, PacConstants.SERVER_CHECKSUM);