assertEquals("Test IO Exception", thrown.getMessage());
        }
    }

    @Nested
    @DisplayName("Send/Receive Tests")
    class SendReceiveTests {

        @Test
        @DisplayName("Should handle basic send/receive fragment methods")
        void testSendReceiveFragmentMethods() throws IOException {
            // Given: Test handle with configured return values

nós
nun
nunha
nuns
nunhas
o
os
ou
ó
ós
para
pero
pode
pois
pola
polas
polo
polos
por
que
se
senón
ser
seu
seus
sexa
sido
sobre
súa
súas
tamén
tan
te
ten
teñen
teño
ter
teu
teus
ti
tido
tiña
tiven
túa
túas
un
unha
unhas
uns
vos
vosa
vosas

             */
            out.write(BUF, 0, 4 + n);
        }
    }

    /**
     * Internal method to send a request to the server.
     *
     * @param request the request to send
     * @throws IOException if an I/O error occurs
     */
    protected void doSend0(final Request request) throws IOException {
        try {
            doSend(request);

        } catch (final Exception e) {
            this.treeHandle.release();
            throw e;
        }

    }

    private FileEntry open() throws CIFSException {
        this.treeHandle.send(this.request, this.response);
        checkStatus();
        final FileEntry n = advance();
        if (n == null) {
            doClose();
        }
        return n;
    }

    /**

                        request.setRemainingBytes(Math.min(len - r, 1024 * 1024)); // Hint up to 1MB for read-ahead

                        try {
                            final Smb2ReadResponse resp = th.send(request, RequestParam.NO_RETRY);
                            n = resp.getDataLength();
                        } catch (final SmbException e) {

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

    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

            if (aggregations != null) {
                builder.facetResponse(new FacetResponse(aggregations));
            }

        });
        return builder.build();
    }

    /**
     * Sends a search request to OpenSearch with the specified parameters.
     *
     * @param query the search query string
     * @param params the search request parameters

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

    /**