}

    @Test
    void testWriteULong() {
        // Test writeULong
        byte[] data = new byte[4];
        ByteBuffer expectedBuffer = ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN);

        // Test with a positive value
        int value = 0x12345678;
        NtlmMessage.writeULong(data, 0, value);
        expectedBuffer.putInt(0, value);

    @Test
    @DisplayName("writeULong writes little endian bytes")
    void testWriteULong() {
        byte[] dest = new byte[4];
        NtlmMessage.writeULong(dest, 0, 0x01020304);
        assertArrayEquals(new byte[] { 4, 3, 2, 1 }, dest, "Writer must be little‑endian");
    }

    @Test
    @DisplayName("writeULong handles negative values as unsigned")
    void testWriteULongNegative() {

            }
            final byte[] type1 = new byte[hostInfo ? 32 + domain.length + workstation.length : 16];
            System.arraycopy(NTLMSSP_SIGNATURE, 0, type1, 0, 8);
            writeULong(type1, 8, 1);
            writeULong(type1, 12, flags);
            if (hostInfo) {
                writeSecurityBuffer(type1, 16, 32, domain);
                writeSecurityBuffer(type1, 24, 32 + domain.length, workstation);
            }

            Type2Message.writeULong(truncatedMessage, 8, Type2Message.NTLMSSP_TYPE2);
            // Set empty target name buffer
            Type2Message.writeUShort(truncatedMessage, 12, 0); // length
            Type2Message.writeUShort(truncatedMessage, 14, 0); // max length
            Type2Message.writeULong(truncatedMessage, 16, 48); // offset (past the end)
            // Set flags

        final int offset = readULong(src, index + 4);
        final byte[] buffer = new byte[length];
        System.arraycopy(src, offset, buffer, 0, length);
        return buffer;
    }

    static void writeULong(final byte[] dest, final int offset, final int ulong) {
        dest[offset] = (byte) (ulong & 0xff);
        dest[offset + 1] = (byte) (ulong >> 8 & 0xff);
        dest[offset + 2] = (byte) (ulong >> 16 & 0xff);

        pos += NTLMSSP_SIGNATURE.length;

        writeULong(type2, pos, NTLMSSP_TYPE2);
        pos += 4;

        // TargetNameFields
        final int targetNameOff = writeSecurityBuffer(type2, pos, targetBytes);
        pos += 8;

        writeULong(type2, pos, flags);
        pos += 4;

        // ServerChallenge

        final int offset = readULong(src, index + 4);
        final byte[] buffer = new byte[length];
        System.arraycopy(src, offset, buffer, 0, length);
        return buffer;
    }

    static void writeULong(final byte[] dest, final int offset, final int ulong) {
        dest[offset] = (byte) (ulong & 0xff);
        dest[offset + 1] = (byte) (ulong >> 8 & 0xff);
        dest[offset + 2] = (byte) (ulong >> 16 & 0xff);

            int pos = 0;

            System.arraycopy(NTLMSSP_SIGNATURE, 0, type1, 0, NTLMSSP_SIGNATURE.length);
            pos += NTLMSSP_SIGNATURE.length;

            writeULong(type1, pos, NTLMSSP_TYPE1);
            pos += 4;

            writeULong(type1, pos, flags);
            pos += 4;

            final int domOffOff = writeSecurityBuffer(type1, pos, domain);
            pos += 8;

            System.arraycopy(NTLMSSP_SIGNATURE, 0, type2, 0, 8);
            writeULong(type2, 8, 2);
            writeSecurityBuffer(type2, 12, data, target);
            writeULong(type2, 20, flags);
            System.arraycopy(challenge != null ? challenge : new byte[8], 0, type2, 24, 8);
            if (context != null) {

            final byte[] type3 = new byte[64 + domainLength + userLength + workstationLength + lmLength + ntLength + keyLength];
            System.arraycopy(NTLMSSP_SIGNATURE, 0, type3, 0, 8);
            writeULong(type3, 8, 3);
            int offset = 64;
            writeSecurityBuffer(type3, 12, offset, lmResponse);
            offset += lmLength;
            writeSecurityBuffer(type3, 20, offset, ntResponse);