// Read GUID components in little-endian order
        int data1 = bb.getInt(); // first 4 bytes (little-endian)
        short data2 = bb.getShort(); // next 2 bytes (little-endian)
        short data3 = bb.getShort(); // next 2 bytes (little-endian)

        // The last 8 bytes are read as big-endian (network byte order for the high/low parts)

public class SMBUtil {

    /**
     * Private constructor to prevent instantiation of utility class.
     */
    private SMBUtil() {
    }

    /**
     * Writes a 16-bit integer value to a byte array in little-endian format
     * @param val the value to write
     * @param dst the destination byte array
     * @param dstIndex the starting index in the destination array
     */

    @Test
    @DisplayName("readULong correctly interprets little endian")
    void testReadULong() {
        byte[] a = new byte[] { (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04 };
        int result = NtlmMessage.readULong(a, 0);
        assertEquals(0x04030201, result, "ULong should be little‑endian");
    }

    @Test
    @DisplayName("readUShort correctly interprets little endian")
    void testReadUShort() {

        buf.enc_ndr_small(5); /* RPC version */
        buf.enc_ndr_small(0); /* minor version */
        buf.enc_ndr_small(this.ptype);
        buf.enc_ndr_small(this.flags);
        buf.enc_ndr_long(0x00000010); /* Little-endian / ASCII / IEEE */
        buf.enc_ndr_short(this.length);
        buf.enc_ndr_short(0); /* length of auth_value */
        buf.enc_ndr_long(this.call_id);
    }

        if (str == null) {
            return new byte[0];
        }
        return str.getBytes(encoding);
    }

    /**
     * Encodes a string into UTF-16LE (Unicode Little Endian) bytes.
     *
     * @param str the string to encode
     * @return the string as bytes (UTF16-LE)
     */
    public static byte[] getUNIBytes(final String str) {
        return getBytes(str, UNI_ENCODING);

        byte[] rawBytes = new byte[] { 0x01, 0x02, 0x03, 0x04 }; // Represents 0x04030201 (little-endian)
        AvFlags avFlags = new AvFlags(rawBytes);
        assertNotNull(avFlags, "AvFlags object should not be null");
        assertEquals(0x04030201, avFlags.getFlags(), "Flags should match the raw bytes (little-endian)");

        // Test with zero
        byte[] zeroBytes = new byte[] { 0x00, 0x00, 0x00, 0x00 };

    @Test
    public void testReadShort() throws IOException {
        // Little-endian 0x1234 -> 0x34 0x12
        byte[] data = new byte[] { 0x34, 0x12, 0x00, 0x00 };
        PacDataInputStream pdis = createInputStream(data);
        assertEquals((short) 0x1234, pdis.readShort());
    }

    @Test
    public void testReadInt() throws IOException {
        // Little-endian 0x12345678 -> 0x78 0x56 0x34 0x12

    }

    @Test
    public void testToStringContainsCount() {
        // Little-endian: count = 512 (0x0200)
        byte[] buf = new byte[12];
        buf[0] = 0x00;
        buf[1] = 0x02; // count = 512 in little-endian
        resp.readParameterWordsWireFormat(buf, 0);
        String str = resp.toString();

            assertEquals(context.size(), encodedSize);
            assertEquals(1, buffer[0]); // hash algo count (little endian)
            assertEquals(0, buffer[1]);
            assertEquals(8, buffer[2]); // salt length (little endian)
            assertEquals(0, buffer[3]);
            assertEquals(1, buffer[4]); // SHA512 hash algo (little endian)
            assertEquals(0, buffer[5]);

        dst[di++] = (byte) (i >> 16 & 0xFF);
        dst[di++] = (byte) (i >> 8 & 0xFF);
        dst[di] = (byte) (i & 0xFF);
        return 4;
    }

    /**
     * Encodes a 16-bit unsigned integer in little-endian byte order.
     *
     * @param s the short value to encode
     * @param dst the destination byte array
     * @param di the starting index in the destination array
     * @return the number of bytes written (2)