}

        final SmbTreeHandleImpl th = getTreeHandle();
        this.response = new Trans2FindFirst2Response(th.getConfig());

        try {
            th.send(new Trans2FindFirst2(th.getConfig(), unc, this.getWildcard(), this.getSearchAttributes(), th.getConfig().getListCount(),
                    th.getConfig().getListSize() - FIND_OVERHEAD), this.response);

     *
     * Operations larger than this size will use RDMA read/write
     * instead of send/receive.
     *
     * @return threshold in bytes
     */
    int getRdmaReadWriteThreshold();

    /**
     * Get maximum RDMA send size
     *
     * @return max send size in bytes
     */
    int getRdmaMaxSendSize();

    /**
     * Get maximum RDMA receive size
     *

   * closing, closed, or canceled.
   *
   * This method returns immediately.
   */
  fun send(bytes: ByteString): Boolean

  /**
   * Attempts to initiate a graceful shutdown of this web socket. Any already-enqueued messages will
   * be transmitted before the close message is sent but subsequent calls to [send] will return
   * false and their messages will not be enqueued.
   *

                }
            });
        } catch (final Exception e) {
            logger.warn("Failed to write a thread dump to {}", 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) {

            if (LogStream.level > 2) {
                ex.printStackTrace(log);
            }
        } finally {
            tryClose();
        }
    }

    void send(final NameServicePacket request, final NameServicePacket response, int timeout) throws IOException {
        Integer nid = null;
        int max = NbtAddress.NBNS.length;

        if (max == 0) {

import jcifs.internal.smb2.rdma.RdmaProvider;

/**
 * TCP fallback RDMA provider.
 *
 * This provider uses regular TCP connections but maintains the RDMA
 * interface for compatibility. It only supports send/receive operations
 * and does not provide true RDMA read/write capabilities.
 */
public class TcpRdmaProvider implements RdmaProvider {

    /**
     * Creates a new TCP RDMA provider instance
     */

     *
     * @param config the configuration to use
     * @param fid the file ID of the named pipe
     * @param data the data buffer to send
     * @param off the offset in the data buffer
     * @param len the length of data to send
     */
    public TransTransactNamedPipe(final Configuration config, final int fid, final byte[] data, final int off, final int len) {

                    req.setFileInformation(new FileBasicInfo(ctime, atime, mtime, 0L, attrs));
                    dh.send(req);
                } else if (dh.hasCapability(SmbConstants.CAP_NT_SMBS)) {
                    // use the open file descriptor
                    dh.send(new Trans2SetFileInformation(dh.getConfig(), dfd.getFid(), attrs, ctime, mtime, atime),

        }
    }

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

        try {
            // In real implementation, this would send using DiSNI:

            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