}
    }
}

fun readCapabilitiesFromJson() {
    val capabilitiesFile = repoRoot().file("gradle/dependency-management/capabilities.json").asFile
    val capabilities: List<CapabilitySpec> = readCapabilities(capabilitiesFile)
    capabilities.forEach {
        it.configure(dependencies.components, configurations)
    }
}

fun readCapabilities(source: File): List<CapabilitySpec> {

    @Test
    @DisplayName("should handle icon rendering based on terminal capabilities")
    void shouldHandleIconRenderingBasedOnTerminalCapabilities() {
        UpgradeContext context = TestUtils.createMockContext(Paths.get("/test"));

        // Test that icon rendering doesn't throw exceptions
        // The actual icons used depend on the terminal's charset capabilities
        context.success("Icon rendering test");

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

    /**

        }
        snd_buf_size = Math.min(snd_buf_size, server.maxBufferSize);
        capabilities &= server.capabilities;
        if ((server.capabilities & CAP_EXTENDED_SECURITY) == CAP_EXTENDED_SECURITY) {
            capabilities |= CAP_EXTENDED_SECURITY; // & doesn't copy high bit
        }

        if ((capabilities & SmbConstants.CAP_UNICODE) == 0) {
            // server doesn't want unicode

    void testDecodeValidBuffer() throws SMBProtocolDecodingException {
        // Prepare test data
        byte[] buffer = new byte[64];
        int bufferIndex = 10;

        // Set capabilities (4 bytes)
        int testCapabilities = 0x12345678;
        SMBUtil.writeInt4(testCapabilities, buffer, bufferIndex);

        // Set server GUID (16 bytes)
        byte[] testGuid = new byte[16];

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

    /** Default capabilities */
    int DEFAULT_CAPABILITIES =
            (USE_NTSMBS ? CAP_NT_SMBS : 0) | (USE_NTSTATUS ? CAP_STATUS32 : 0) | (USE_UNICODE ? CAP_UNICODE : 0) | CAP_DFS;
    /** FLAGS2 value */
    int FLAGS2 = Config.getInt("jcifs.smb1.smb.client.flags2", DEFAULT_FLAGS2);
    /** Capabilities value */

        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;

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

        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());