// Test multiple capabilities
            int combinedCaps = Smb2TreeConnectResponse.SMB2_SHARE_CAP_DFS | Smb2TreeConnectResponse.SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY;
            setPrivateField(response, "capabilities", combinedCaps);
            assertEquals(combinedCaps, response.getCapabilities(), "Should handle multiple capabilities");
        }

        @Test
        @DisplayName("Should handle maximal access")

    @Test
    @DisplayName("Should return capabilities")
    void testGetCapabilities() throws Exception {
        // Given
        setPrivateField(response, "capabilities", 0x7F);

        // When
        int caps = response.getCapabilities();

        // Then
        assertEquals(0x7F, caps);
    }

    @Test
    @DisplayName("Should return common capabilities")

    private final SmbComNegotiateResponse negotiated;
    private int capabilities;

    /**
     * Constructs a session setup AndX request.
     *
     * @param tc the CIFS context containing configuration and credentials
     * @param negotiated the negotiation response containing server capabilities
     * @param andx the next command in the AndX chain, or null

        capabilities = session.transport.capabilities;

        if (session.transport.server.security == SECURITY_USER) {
            if (cred instanceof final NtlmPasswordAuthentication auth) {
                if (auth == NtlmPasswordAuthentication.ANONYMOUS) {
                    lmHash = new byte[0];
                    ntHash = new byte[0];
                    capabilities &= ~SmbConstants.CAP_EXTENDED_SECURITY;

 */
package jcifs.internal.smb2.rdma;

/**
 * Constants for RDMA capabilities and default configuration values.
 * Based on MS-SMBD specification for SMB Direct protocol.
 */
public class RdmaCapabilities {

    /**
     * RDMA transform capabilities flag indicating response is requested
     */
    public static final int SMB_DIRECT_RESPONSE_REQUESTED = 0x00000001;

    /**

        buffer.putInt(8192); // maxBufferSize
        buffer.putInt(65536); // maxRawSize
        buffer.putInt(123456789); // sessionKey
        buffer.putInt(SmbConstants.CAP_UNICODE | SmbConstants.CAP_NT_SMBS); // capabilities
        buffer.putLong(new Date().getTime()); // serverTime
        buffer.putShort((short) -480); // serverTimeZone
        buffer.put((byte) 8); // encryptionKeyLength

        byte[] paramWords = buffer.array();

        assertTrue((testConfig.getFlags2() & SmbConstants.FLAGS2_EXTENDED_ATTRIBUTES) != 0);

        // Check capabilities
        assertTrue(testConfig.getCapabilities() != 0, "Capabilities should be non-zero");

        // Check broadcast address
        assertNotNull(testConfig.getBroadcastAddress());

    @DisplayName("Test encode with maximum capabilities value")
    void testEncodeWithMaxCapabilities() {
        ValidateNegotiateInfoRequest request =
                new ValidateNegotiateInfoRequest(0xFFFFFFFF, defaultClientGuid, DEFAULT_SECURITY_MODE, defaultDialects);

        byte[] buffer = new byte[request.size()];
        request.encode(buffer, 0);

        // Verify max capabilities value (comparing as unsigned long)

        return (getSecurityMode() & Smb2Constants.SMB2_NEGOTIATE_SIGNING_REQUIRED) != 0;
    }

    /**
     * Gets the client capabilities flags.
     *
     * @return the capabilities
     */
    public int getCapabilities() {
        return this.capabilities;
    }

    /**
     * Gets the array of SMB dialect versions supported by the client.
     *
     * @return the dialects
     */

                'ERROR: TensorFlow only supports small CUDA compute'
                ' capabilities of sm_30 and higher. Please re-specify the list'
                ' of compute capabilities excluding version %s.' % ver)
            all_valid = False
          if ver < 35:
            print('WARNING: XLA does not support CUDA compute capabilities '
                  'lower than sm_35. Disable XLA when running on older GPUs.')
      else: