return new ASN1ObjectIdentifier[] { SPNEGO_MECH_OID };
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.smb.SSPContext#getFlags()
     */
    @Override
    public int getFlags() {
        return this.mechContext.getFlags();
    }

    @Override
    public boolean isSupported(final ASN1ObjectIdentifier mechanism) {
        // prevent nesting
        return false;
    }

        this.suppliedWorkstation = suppliedWorkstation;
    }

    @Override
    public byte[] toByteArray() {
        try {
            int flags = getFlags();
            int size = 8 * 4 + ((flags & NTLMSSP_NEGOTIATE_VERSION) != 0 ? 8 : 0);

            byte[] domain = {};
            final String suppliedDomainString = getSuppliedDomain();

        final MsrpcSamrConnect4 request = new MsrpcSamrConnect4(server, access, this.policyHandle);

        // Then
        assertEquals(0, request.getPtype());
        assertEquals(DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG, request.getFlags());
    }

     */
    public AvFlags(final int flags) {
        this(encode(flags));
    }

    /**
     * Gets the flags as an integer value
     * @return flags
     */
    public int getFlags() {
        return SMBUtil.readInt4(this.getRaw(), 0);
    }

    private static byte[] encode(final int flags) {
        final byte[] raw = new byte[4];
        SMBUtil.writeInt4(flags, raw, 0);
        return raw;

        // Verify that the 'flags' field is set to DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG
        int expectedFlags = DcerpcConstants.DCERPC_FIRST_FRAG | DcerpcConstants.DCERPC_LAST_FRAG;
        assertEquals(expectedFlags, msrpc.getFlags(), "The 'flags' field should be initialized to DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG.");

        // Although we cannot directly verify the super constructor call with Mockito for a real class,

        if (type1 == null) {
            return getDefaultFlags(tc);
        }
        int flags = NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_VERSION;
        final int type1Flags = type1.getFlags();
        flags |= (type1Flags & NTLMSSP_NEGOTIATE_UNICODE) != 0 ? NTLMSSP_NEGOTIATE_UNICODE : NTLMSSP_NEGOTIATE_OEM;
        if ((type1Flags & NTLMSSP_REQUEST_TARGET) != 0) {

        int expectedFlags = 0x01 | 0x02; // DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG
        assertEquals(expectedFlags, msrpcSamrOpenDomain.getFlags(), "flags should be initialized to DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG");

        // Since SamrOpenDomain's constructor is called, we implicitly test that the arguments

    void testFlags() {
        // Given
        int flags = 0x0001; // Encrypted flag

        // When
        transformHeader.setFlags(flags);

        // Then
        assertEquals(flags, transformHeader.getFlags());
    }

    @Test
    @DisplayName("Should set and get session ID")
    void testSessionId() {
        // When
        transformHeader.setSessionId(testSessionId);

        // Then

        when(gssContext.getConfState()).thenReturn(false);
        when(gssContext.getIntegState()).thenReturn(false);

        int flags = ctx.getFlags();
        assertEquals(0, flags);
    }

    @Test
    @DisplayName("getFlags combines all flag bits when true")
    void getFlags_allTrue() {
        when(gssContext.getCredDelegState()).thenReturn(true);

        assertEquals(0, msrpcLsarClose.getPtype(), "ptype should be 0");
        assertEquals(DcerpcConstants.DCERPC_FIRST_FRAG | DcerpcConstants.DCERPC_LAST_FRAG, msrpcLsarClose.getFlags(),
                "flags should be DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG");

        // Although we cannot directly assert that super(handle) was called with Mockito for a constructor,