SmbComClose close = new SmbComClose(fid, lastWriteTime);
        byte[] buffer = new byte[10];
        int written = close.writeParameterWordsWireFormat(buffer, 0);
        assertEquals(6, written, "writeParameterWordsWireFormat should return 6");
        // Only compare the first 6 bytes that were actually written
        byte[] actualWritten = new byte[6];
        System.arraycopy(buffer, 0, actualWritten, 0, 6);

        int pos = 8; // Position where content should be written
        int off = 0; // Offset where position should be written

        // Test with non-null source array
        int bytesWritten = NtlmMessage.writeSecurityBufferContent(dest, pos, off, src);
        assertEquals(src.length, bytesWritten, "Should return correct number of bytes written.");

        byte[] buffer = new byte[1024];

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

        // Should write exactly 56 bytes (structure size without data)
        assertEquals(56, written);
        // Check structure size (first 2 bytes should be 57)
        assertEquals(57, (buffer[0] & 0xFF) | ((buffer[1] & 0xFF) << 8));
    }

    }

    @Test
    void testWriteParameterWordsWireFormatLittleEndian() {
        byte[] dst = new byte[2];
        int written = instance.writeParameterWordsWireFormat(dst, 0);
        assertEquals(2, written, "writeParameterWordsWireFormat should write exactly 2 bytes");
        // SMBUtil.writeInt2 writes the low byte first (little‑endian)
        assertEquals((byte) (TEST_SID & 0xFF), dst[0]);

    void testWriteSetupWireFormat() {
        trans2FindFirst2 = new Trans2FindFirst2(mockConfig, "\\test", "*.*", 0x16, 10, 1024);

        byte[] buffer = new byte[10];
        int written = trans2FindFirst2.writeSetupWireFormat(buffer, 0);

        assertEquals(2, written);
        assertEquals((byte) Trans2FindFirst2.TRANS2_FIND_FIRST2, buffer[0]);
        assertEquals((byte) 0x00, buffer[1]);
    }

    @Test

// for the file metadata. [Writer] takes ownership of fh and may mutate
// its fields. The caller must not modify fh after calling [Writer.CreateHeader].
//
// This returns a [Writer] to which the file contents should be written.
// The file's contents must be written to the io.Writer before the next
// call to [Writer.Create], [Writer.CreateHeader], [Writer.CreateRaw], or [Writer.Close].

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

        // Verify structure size (should be 24)

        assertEquals(0x00, SMBUtil.readInt2(buffer, 10));

        // Verify filename
        String actualFilename = readString(buffer, 12, written - 12);
        assertEquals(TEST_FILENAME, actualFilename);

        // Verify total bytes written
        assertTrue(written >= 12 + TEST_FILENAME.length());
    }

    @Test
    void testWriteDataWireFormat() {
        // Test data wire format writing (should return 0)

        byte[] minBuffer = new byte[2];
        int written = trans2QueryFSInfo.writeSetupWireFormat(minBuffer, 0);
        assertEquals(2, written);

        // Test with exact parameter size
        byte[] paramBuffer = new byte[2];
        written = trans2QueryFSInfo.writeParametersWireFormat(paramBuffer, 0);
        assertEquals(2, written);

        // Test with zero-length data buffer

        // Fill buffer with non-zero values to ensure padding writes zeros
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = (byte) 0xFF;
        }

        int written = trans2SetFileInfo.writeDataWireFormat(buffer, 0);

        // Should report 26 bytes written (20 from encode + 6 increment)
        assertEquals(26, written);

        // Check that padding bytes are zeros