}

    @Override
    public byte[] toByteArray() throws IOException {
        int size = 48;
        int flags = getFlags();
        final String targetName = getTarget();
        final byte[] targetInformationBytes = getTargetInformation();
        byte[] targetBytes = {};

        if (getFlag(NTLMSSP_REQUEST_TARGET)) {
            if (targetName != null && targetName.length() != 0) {

        pos += 8;
        final int skOff = writeSecurityBuffer(type3, 52, sessionKeyBytes);
        pos += 8;

        writeULong(type3, pos, getFlags());
        pos += 4;

        if (getFlag(NTLMSSP_NEGOTIATE_VERSION)) {
            System.arraycopy(NTLMSSP_VERSION, 0, type3, pos, NTLMSSP_VERSION.length);
            pos += NTLMSSP_VERSION.length;
        } else if (micBytes != null) {

                        || !msg2.getFlag(NtlmFlags.NTLMSSP_NEGOTIATE_EXTENDED_SESSIONSECURITY))) {
                    throw new SmbUnsupportedOperationException("Server does not support extended NTLMv2 key exchange");
                }

                if (!msg2.getFlag(NtlmFlags.NTLMSSP_NEGOTIATE_128)) {

        assertEquals(0b0101, message.getFlags(), "Flag 0b0100 should be added to existing flags.");

        // Test clearing a flag
        message.setFlag(0b0001, false);
        assertEquals(0b0100, message.getFlags(), "Flag 0b0001 should be cleared.");

        message.setFlag(0b0100, false);
        assertEquals(0, message.getFlags(), "Flag 0b0100 should be cleared.");

            assertTrue(message.isFlagSet(DcerpcConstants.RPC_C_PF_BROADCAST));
        }

        @Test
        @DisplayName("setFlag should add specified flags")
        void testSetFlag() {
            // Test setting a new flag
            message.flags = 0;
            message.setFlag(DcerpcConstants.RPC_C_PF_BROADCAST);
            assertTrue(message.isFlagSet(DcerpcConstants.RPC_C_PF_BROADCAST));

        assertTrue((unicodeType1.getFlags() & NtlmFlags.NTLMSSP_NEGOTIATE_UNICODE) != 0);
        // Default is OEM, so both flags are set due to OR operation
        assertTrue((unicodeType1.getFlags() & NtlmFlags.NTLMSSP_NEGOTIATE_OEM) != 0);

        // OEM flag is default when isUseUnicode() is false
        assertTrue((oemType1.getFlags() & NtlmFlags.NTLMSSP_NEGOTIATE_OEM) != 0);

        // Act
        lookupSids = new MsrpcLookupSids(mockPolicyHandle, testSids);

        // Assert
        assertTrue((lookupSids.getFlags() & DcerpcConstants.DCERPC_FIRST_FRAG) != 0);
        assertTrue((lookupSids.getFlags() & DcerpcConstants.DCERPC_LAST_FRAG) != 0);
    }

    @Test
    void constructor_shouldPassCorrectCountToSuperclass() throws Exception {
        // Arrange

            return this.supportedMechs.length > 0 && Objects.equals(this.supportedMechs[0], selectedMech);
        }

        @Override
        public int getFlags() {
            return this.flags;
        }

        @Override
        public ASN1ObjectIdentifier[] getSupportedMechs() {
            return this.supportedMechs.clone();
        }

    }

    @Test
    @DisplayName("Test getFlags returns correct value")
    void testGetFlags() {
        ace.flags = 0x00;
        assertEquals(0x00, ace.getFlags());

        ace.flags = 0xFF;
        assertEquals(0xFF, ace.getFlags());

        ace.flags = ACE.FLAGS_OBJECT_INHERIT | ACE.FLAGS_CONTAINER_INHERIT | ACE.FLAGS_INHERIT_ONLY;
        assertEquals(0x0B, ace.getFlags());
    }

    @Test

            // When
            Type2Message parsedMessage = new Type2Message(rawMessage);

            // Then
            assertNotNull(parsedMessage);
            assertEquals(originalMessage.getFlags(), parsedMessage.getFlags());
            assertNull(parsedMessage.getChallenge()); // Should be null if all zeros
            assertNull(parsedMessage.getTarget());