assertEquals(WitnessNotification.WitnessIPAddress.IPV4, newIPv4.getFlags());

        // Check IPv6 address
        WitnessNotification.WitnessIPAddress newIPv6 = newAddresses.get(1);
        assertEquals(ipv6, newIPv6.getAddress());
        assertFalse(newIPv6.isIPv4());
        assertTrue(newIPv6.isIPv6());
        assertEquals(WitnessNotification.WitnessIPAddress.IPV6, newIPv6.getFlags());
    }

    @Test

        assertEquals(0x04030201, avFlags.getFlags(), "Flags should match the raw bytes (little-endian)");

        // Test with zero
        byte[] zeroBytes = new byte[] { 0x00, 0x00, 0x00, 0x00 };
        AvFlags zeroAvFlags = new AvFlags(zeroBytes);
        assertNotNull(zeroAvFlags, "AvFlags object should not be null for zero bytes");
        assertEquals(0, zeroAvFlags.getFlags(), "Flags should be 0 for zero bytes");

        queryPolicy = new MsrpcQueryInformationPolicy(mockPolicyHandle, level, mockNdrObject);

        // Assert
        assertEquals(expectedFlags, queryPolicy.getFlags());
        // Binary check for individual flags
        assertEquals(0x03, queryPolicy.getFlags()); // 0x01 | 0x02 = 0x03
    }

    @Test
    void getOpnum_shouldReturnCorrectValue() {
        // Arrange
        short level = 1;

            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

        // 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

    }

    @Test
    @DisplayName("getFlags delegates to underlying mechanism context")
    void testGetFlagsDelegates() {
        SpnegoContext ctx = newContext();
        when(this.mechContext.getFlags()).thenReturn(0xCAFE);
        assertEquals(0xCAFE, ctx.getFlags());
        verify(this.mechContext, times(1)).getFlags();
    }

    @Test

        @Test
        @DisplayName("Should add flags correctly")
        void testAddFlags() {
            assertEquals(0, testMessage.getFlags());
            testMessage.addFlags(ServerMessageBlock2.SMB2_FLAGS_SIGNED);
            assertEquals(ServerMessageBlock2.SMB2_FLAGS_SIGNED, testMessage.getFlags());
            testMessage.addFlags(ServerMessageBlock2.SMB2_FLAGS_DFS_OPERATIONS);

        }

        @Test
        @DisplayName("Should define getFlags method returning int")
        void shouldDefineGetFlags() {
            ACE ace = mock(ACE.class);
            when(ace.getFlags()).thenReturn(ACE.FLAGS_INHERITED);

            int flags = ace.getFlags();
            assertEquals(ACE.FLAGS_INHERITED, flags);
            verify(ace).getFlags();
        }

        @Test

        assertEquals(encodedSize, decodedSize);
        assertArrayEquals(context.getCompressionAlgorithms(), decodedContext.getCompressionAlgorithms());
        assertEquals(context.getFlags(), decodedContext.getFlags());
    }

    @Test
    @DisplayName("Test invalid buffer size for decoding")
    public void testInvalidBufferSize() {
        byte[] smallBuffer = new byte[4]; // Too small