response = new Smb2QueryDirectoryResponse(mockConfig, Smb2QueryDirectoryRequest.FILE_BOTH_DIRECTORY_INFO);

        byte[] buffer = new byte[1024];
        int bufferIndex = 200;
        int headerStart = 50;

        // Set structure size to 9
        SMBUtil.writeInt2(9, buffer, bufferIndex);
        // Set buffer offset (relative to header start)
        SMBUtil.writeInt2(300, buffer, bufferIndex + 2);

            System.arraycopy(this.txn_buf, this.bufParameterOffset, dst, this.headerStart + this.parameterOffset, this.parameterCount);
            end = Math.max(end, this.headerStart + this.parameterOffset + this.parameterCount + this.pad2);
        }

        if (this.dataCount > 0) {
            System.arraycopy(this.txn_buf, this.bufDataOffset, dst, this.headerStart + this.dataOffset, this.dataCount);

        if (this.digest != null) {
            this.digest.sign(dst, this.headerStart, this.length, this, this.response);
        }

        return this.length;
    }

    @Override
    public int decode(final byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException {
        final int start = this.headerStart = bufferIndex;

        bufferIndex += readHeaderWireFormat(buffer, bufferIndex);

        // Verify negotiate context offset is set
        int contextOffset = SMBUtil.readInt4(buffer, 28);
        assertTrue(contextOffset > 0);

        // Skip detailed context verification since we can't access headerStart
        // Just verify that contexts were written
        assertTrue(bytesWritten > 60); // Should be larger than basic negotiate request
    }

    @Test

        void testPad8() {
            testMessage.encode(new byte[1024], 0);
            // After header is written, padding depends on position
            int headerStart = testMessage.getHeaderStart();
            assertEquals(0, headerStart); // Should start at 0
        }
    }

    @Nested
    @DisplayName("Encode/Decode Tests")
    class EncodeDecodeTests {

        @Test

            testBlock.setUseUnicode(true);
            byte[] buffer = new byte[100];
            String testString = "Test";

            // Test odd Unicode alignment - headerStart affects alignment
            int bytesWritten = testBlock.writeString(testString, buffer, 2);

            // When even alignment (offset 2), Unicode string starts immediately

        } else {

            /*
             * Set bufferIndex according to andxOffset
             */

            bufferIndex = this.headerStart + this.andxOffset;

            this.andx.headerStart = this.headerStart;
            this.andx.setCommand(this.andxCommand);
            this.andx.setErrorCode(getErrorCode());
            this.andx.setFlags(getFlags());

    @Test
    @DisplayName("readAndXWireFormat applies Snap server workaround (offset 0)")
    void testReadAndXWireFormatSnapWorkaround() {
        DummyAndXBlock block = new DummyAndXBlock();
        block.headerStart = 0;

        byte[] buf = new byte[64];
        buf[0] = 4; // wordCount
        buf[1] = 0x42; // andxCommand
        // andxOffset = 0 triggers workaround -> treat as no andx

    protected int writeParameterWordsWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        this.dataOffset = dstIndex - this.headerStart + 26; // 26 = off from here to pad

        this.pad = (this.dataOffset - this.headerStart) % 4;
        this.pad = this.pad == 0 ? 0 : 4 - this.pad;
        this.dataOffset += this.pad;

        SMBUtil.writeInt2(this.fid, dst, dstIndex);

func (h *headerGNU) realSize() []byte    { return h[483:][:12] }

type headerSTAR [blockSize]byte

func (h *headerSTAR) v7() *headerV7      { return (*headerV7)(h) }
func (h *headerSTAR) magic() []byte      { return h[257:][:6] }
func (h *headerSTAR) version() []byte    { return h[263:][:2] }
func (h *headerSTAR) userName() []byte   { return h[265:][:32] }
func (h *headerSTAR) groupName() []byte  { return h[297:][:32] }