* Get interface capabilities
     *
     * @return capability flags
     */
    public int getCapability() {
        return capability;
    }

    /**
     * Set interface capabilities
     *
     * @param capability capability flags
     */
    public void setCapability(int capability) {
        this.capability = capability;
        // Update capability flags based on bitmask

     */
    public static final int SEQUENCE_CHECKING = 0x10;
    /**
     * Context flag for anonymity capability
     */
    public static final int ANONYMITY = 0x08;
    /**
     * Context flag for confidentiality (encryption) capability
     */
    public static final int CONFIDENTIALITY = 0x04;
    /**
     * Context flag for integrity (signing) capability
     */

    int CAP_NONE = 0x0000;
    /** Raw mode capability */
    int CAP_RAW_MODE = 0x0001;
    /** MPX mode capability */
    int CAP_MPX_MODE = 0x0002;
    /** Unicode capability */
    int CAP_UNICODE = 0x0004;
    /** Large files capability */
    int CAP_LARGE_FILES = 0x0008;
    /** NT SMBs capability */
    int CAP_NT_SMBS = 0x0010;
    /** RPC remote APIs capability */
    int CAP_RPC_REMOTE_APIS = 0x0020;

    }

    @Nested
    @DisplayName("Global Capability Constants")
    class GlobalCapabilityConstants {

        @Test
        @DisplayName("DFS capability should be 0x1")
        void testGlobalCapDfs() {
            assertEquals(0x1, Smb2Constants.SMB2_GLOBAL_CAP_DFS, "DFS capability must be 0x1");
        }

        @Test
        @DisplayName("Leasing capability should be 0x2")
        void testGlobalCapLeasing() {

        assertTrue((response.getShareFlags() & Smb2TreeConnectResponse.SMB2_SHAREFLAG_ENCRYPT_DATA) != 0);
    }

    @Test
    @DisplayName("Should handle all capability flags")
    void testAllCapabilityFlags() throws SMBProtocolDecodingException {
        // Test each capability flag individually
        int[] capabilityFlags = { Smb2TreeConnectResponse.SMB2_SHARE_CAP_DFS,

    /**
     * Raw mode transfers are supported capability.
     */
    int CAP_RAW_MODE = 0x0001;
    /**
     * Multiplex mode is supported capability.
     */
    int CAP_MPX_MODE = 0x0002;
    /**
     * Unicode strings are supported capability.
     */
    int CAP_UNICODE = 0x0004;
    /**
     * Large files are supported capability.
     */
    int CAP_LARGE_FILES = 0x0008;
    /**

        assertFalse(request.isSigningEnforced());
        assertTrue(request instanceof ServerMessageBlock2Request);
    }

    @Test
    @DisplayName("Should set DFS capability when enabled")
    void testDfsCapability() {
        // Given
        when(mockConfig.isDfsDisabled()).thenReturn(false);

        // When
        request = new Smb2NegotiateRequest(mockConfig, 0);

        this.linkSpeed = linkSpeed;
        this.ipv6 = address.getAddress().length == 16;
        this.capability = 0;
        
        // Check for RSS capability (simplified - would need OS-specific checks)
        this.rssCapable = checkRSSCapability();
        if (rssCapable) {
            this.capability |= NETWORK_INTERFACE_CAP_RSS;
        }
    }
    
    public boolean isUsableForChannel() {

    void testHaveCapabilityTrue() {
        // Arrange
        int capability = 0x00000001;
        when(negotiationResponse.haveCapabilitiy(capability)).thenReturn(true);

        // Act
        boolean result = negotiationResponse.haveCapabilitiy(capability);

        // Assert
        assertTrue(result);
        verify(negotiationResponse).haveCapabilitiy(capability);
    }

    @Test

        verify(transport, times(1)).hasCapability(cap);
    }

    // Invalid input: simulate underlying SmbException when capability check fails
    @Test
    @DisplayName("hasCapability throws SmbException when underlying error occurs")
    void hasCapability_throws() throws SmbException {
        doThrow(new SmbException("capability check failed")).when(transport).hasCapability(eq(42));