public enum RdmaCapability {
    /**
     * Remote direct read operations
     */
    RDMA_READ,

    /**
     * Remote direct write operations
     */
    RDMA_WRITE,

    /**
     * Traditional send/receive with RDMA
     */
    RDMA_SEND_RECEIVE,

    /**
     * Dynamic memory registration
     */
    MEMORY_REGISTRATION,

    /**
     * Fast memory region registration
     */

     * @return the negotiated capabilities
     */
    public int getNegotiatedCapabilities() {
        return this.capabilities;
    }

    /**
     * Gets the negotiated send buffer size.
     *
     * @return negotiated send buffer size
     */
    public int getNegotiatedSendBufferSize() {
        return this.snd_buf_size;
    }

    /**
     * Gets the negotiated multiplex count.
     *

era
eras
éramos
erais
eran
fui
fuiste
fue
fuimos
fuisteis
fueron
fuera
fueras
fuéramos
fuerais
fueran
fuese
fueses
fuésemos
fueseis
fuesen
siendo
sido
tengo
tienes
tiene
tenemos
tenéis
tienen
tenga
tengas
tengamos
tengáis
tengan
tendré
tendrás
tendrá
tendremos
tendréis
tendrán
tendría

    void getSendBufferSize_throws() throws Exception {
        // Arrange
        when(handle.getSendBufferSize()).thenThrow(new CIFSException("send size failed"));

        // Act + Assert
        CIFSException ex = assertThrows(CIFSException.class, () -> handle.getSendBufferSize());
        assertEquals("send size failed", ex.getMessage());
        verify(handle).getSendBufferSize();
    }

    @Test

    /**
     * Default maximum number of receive credits
     */
    public static final int DEFAULT_RECEIVE_CREDIT_MAX = 255;

    /**
     * Default target number of send credits
     */
    public static final int DEFAULT_SEND_CREDIT_TARGET = 32;

    /**
     * Default maximum receive size (8KB)
     */
    public static final int DEFAULT_MAX_RECEIVE_SIZE = 8192;

    /**

     */
    protected Curl() {
        // nothing
    }

    /**
     * Creates a new CurlRequest with the HTTP GET method for the specified URL.
     *
     * @param url the URL to send the GET request to
     * @return a CurlRequest object configured with the GET method and the specified URL
     */
    public static CurlRequest get(final String url) {
        return new CurlRequest(Method.GET, url);
    }

                }
            });
        } catch (final Exception e) {
            logger.warn("Failed to write thread dump: file={}", file, e);
        }
    }

    /**
     * Processes all thread information and sends it to the provided consumer.
     *
     * @param writer the consumer that will handle each line of thread dump output
     */
    public static void processThreadDump(final Consumer<String> writer) {

        } catch (IOException e) {
            state = RdmaConnectionState.ERROR;
            throw new IOException("TCP RDMA connection failed", e);
        }
    }

    @Override
    public void send(ByteBuffer data, RdmaMemoryRegion region) throws IOException {
        if (state != RdmaConnectionState.ESTABLISHED && state != RdmaConnectionState.CONNECTED) {
            throw new IOException("Connection not established");

            }

            if (log.isTraceEnabled()) {
                log.trace("Sending NtTransNotifyChange for " + this.handle);
            }
            try {
                resp = th.send(req, resp, RequestParam.NO_TIMEOUT, RequestParam.NO_RETRY);
            } catch (final SmbException e) {
                if (e.getNtStatus() == 0xC0000120) {
                    // cancelled

            int attempt = 0;
            while (attempt < MAX_REDIRECTS) {
                connection.setRequestProperty(authProperty, authMethod + ' ' + Base64.encode(type1.toByteArray()));
                connection.connect(); // send type 1
                response = parseResponseCode();
                if (response != HTTP_UNAUTHORIZED && response != HTTP_PROXY_AUTH) {
                    return;
                }