buffer[offset + 20] = 0x02; // revision
        buffer[offset + 21] = 0x00; // padding
        SMBUtil.writeInt2(0, buffer, offset + 22); // size
        SMBUtil.writeInt4(4097, buffer, offset + 24); // ACE count > 4096
    }

    private void prepareSimpleSid(byte[] buffer, int offset) {
        buffer[offset] = 0x01; // revision
        buffer[offset + 1] = 0x01; // sub-authority count

                return sid.revision == this.revision;
            }
        }
        return false;
    }

    /**
     * Return the numeric representation of this sid such as
     * {@code S-1-5-21-1496946806-2192648263-3843101252-1029}.
     */
    @Override
    public String toString() {
        StringBuilder ret = new StringBuilder("S-").append(this.revision & 0xFF).append("-");

        assertEquals(domainInfo.name.maximum_length / 2, decodedInfo.name.buffer.length);

        // Verify SID
        assertNotNull(decodedInfo.sid);
        assertEquals(domainInfo.sid.revision, decodedInfo.sid.revision);
        assertEquals(domainInfo.sid.sub_authority_count, decodedInfo.sid.sub_authority_count);
    }

    @Test
    void testLsarDomainInfoEncodeDecodeWithNulls() throws NdrException {

            verify(mockNdrBuffer, times(8)).dec_ndr_small(); // revision + sub_authority_count + 6 identifier_authority bytes
            verify(mockNdrBuffer).advance(6); // identifier_authority advance
            verify(mockNdrBuffer).advance(8); // sub_authority advance (4 * 2)
            verify(mockNdrBuffer, times(2)).derive(anyInt());

            assertEquals((byte) 1, sid.revision);
            assertEquals((byte) 2, sid.sub_authority_count);

        // Create a minimal valid security descriptor binary
        // Format: revision(1) + sbz1(1) + control(2) + ownerOffset(4) + groupOffset(4) + saclOffset(4) + daclOffset(4) = 20 bytes minimum
        byte[] securityDescriptorBytes = new byte[20];
        securityDescriptorBytes[0] = 1; // revision
        securityDescriptorBytes[1] = 0; // sbz1
        // control flags (2 bytes)

        /**
         * Default constructor for sid_t.
         */
        public sid_t() {
            // Default constructor
        }

        /**
         * The revision level of the SID structure.
         */
        public byte revision;
        /**
         * The number of sub-authorities in this SID.
         */
        public byte sub_authority_count;
        /**

     *
     * @throws SmbException if the SID string is invalid
     */
    @Test
    void testStringConstructor() throws SmbException {
        SID sid = new SID(adminSidString);
        assertEquals(1, sid.revision);
        assertEquals(2, sid.sub_authority_count);
        assertEquals(5, sid.identifier_authority[5]);
        assertEquals(32, sid.sub_authority[0]);
        assertEquals(544, sid.sub_authority[1]);

        /**
         * Default constructor for sid_t.
         */
        public sid_t() {
            // Default constructor
        }

        /** The revision level of the SID structure */
        public byte revision;
        /** The number of sub-authorities in the SID */
        public byte sub_authority_count;
        /** The identifier authority value (6 bytes) */

import jcifs.SidResolver;
import jcifs.dcerpc.rpc;

class SIDTest {

    // Helper to build a minimal sid_t
    private static rpc.sid_t buildSidT(byte revision, byte[] identAuth, int... subs) {
        rpc.sid_t s = new rpc.sid_t();
        s.revision = revision;
        s.sub_authority_count = (byte) subs.length;
        s.identifier_authority = Arrays.copyOf(identAuth, 6);
        s.sub_authority = Arrays.copyOf(subs, subs.length);

	 * 
	 * #define SECURITY_NT_AUTHORITY           {0,0,0,0,0,5}
	 * 
	 * typedef struct _SID {
	 *    UCHAR Revision;
	 *    UCHAR SubAuthorityCount;
	 *    SID_IDENTIFIER_AUTHORITY IdentifierAuthority;
	 *    [size_is(SubAuthorityCount)] ULONG SubAuthority[*];
	 * } SID, *PSID;
	 */

	typedef struct {
		uint8_t revision;
		uint8_t sub_authority_count;
		uint8_t identifier_authority[6];