assertTrue(flag >= 0x00 && flag <= 0xFF,
                        String.format("Fragment flag 0x%02X should be in valid byte range 0x00-0xFF", flag));
            }
        }

        @Test
        @DisplayName("RPC packet flags should be within byte range")
        void testRpcPacketFlagsRange() {
            // Verify that RPC packet flags are within byte range (0x00-0xFF)

        // Then
        assertEquals(6, result);
        assertEquals(fid, (dst[1] << 8) | (dst[0] & 0xFF));
        assertEquals(Trans2SetFileInformation.SMB_FILE_BASIC_INFO, (dst[3] << 8) | (dst[2] & 0xFF));
        assertEquals(0, (dst[5] << 8) | (dst[4] & 0xFF));
    }

    @Test
    void testWriteDataWireFormat() {
        // Given

        byte[] dst = new byte[4];

        SMB1SigningDigest.writeUTime(mockConfig, 0L, dst, 0);

        assertEquals((byte) 0xFF, dst[0]);
        assertEquals((byte) 0xFF, dst[1]);
        assertEquals((byte) 0xFF, dst[2]);
        assertEquals((byte) 0xFF, dst[3]);
    }

    @Test
    @DisplayName("Test writeUTime with max time")
    void testWriteUTimeWithMaxTime() {

     */
    public byte[] getAddress() {
        final byte[] addr = new byte[4];
        addr[0] = (byte) (this.address >>> 24 & 0xFF);
        addr[1] = (byte) (this.address >>> 16 & 0xFF);
        addr[2] = (byte) (this.address >>> 8 & 0xFF);
        addr[3] = (byte) (this.address & 0xFF);
        return addr;
    }

    /**
     * To convert this address to an <code>InetAddress</code>.
     *

        request.writeBytesWireFormat(buffer, 0);

        // Control code is at offset 4 (4 bytes)
        int encodedControlCode = (buffer[4] & 0xFF) | ((buffer[5] & 0xFF) << 8) | ((buffer[6] & 0xFF) << 16) | ((buffer[7] & 0xFF) << 24);
        assertEquals(testControlCode, encodedControlCode);
    }

		0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff,
		0xff, 0xff, 0xff, 0x31, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x50, 0x4b, 0x06, 0x07, 0x00,
		0x00, 0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x50,
		0x4b, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0xff,
		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,

        int len = cmd.writeParametersWireFormat(buffer, 0);
        assertTrue(len >= 2);
        // writeInt2 writes in little-endian format (LSB first)
        assertEquals(0xAB, buffer[0] & 0xFF);
        assertEquals(0x12, buffer[1] & 0xFF);
        // Check that the path is written after the referral level
        // The path should be written starting at index 2
        // writeString adds null terminator

        // Check FID (little-endian)
        assertEquals(0x34, dst[0] & 0xFF);
        assertEquals(0x12, dst[1] & 0xFF);
        // Check count
        assertEquals(10, dst[2] & 0xFF);
        assertEquals(0, dst[3] & 0xFF);
        // Check offset
        assertEquals(0x78, dst[4] & 0xFF);
        assertEquals(0x56, dst[5] & 0xFF);
    }

    /**
     * Test writeBytesWireFormat writes data correctly

    void testWriteAndXWireFormatWithoutAndx() {
        DummyAndXBlock block = new DummyAndXBlock();
        byte[] buf = new byte[128];
        int n = block.writeAndXWireFormat(buf, 0);

        assertTrue(n > 0);
        // Common AndX header: command at +1, reserved at +2, offset at +3/+4

    void constructorMasksValue(int input) {
        NdrShort ns = new NdrShort(input);
        // NdrShort masks to 0xFF (8 bits) in its constructor
        int expected = input & 0xFF;
        assertEquals(expected, ns.value, "value should be masked to 0xFF before storing");
    }

    /**
     * Round-trip encode/decode for a selection of representative values.
     */
    @ParameterizedTest