* response will not read a batched command and therefore
         * the 'received' member of the response object will not
         * be set to true indicating the send and sendTransaction
         * methods that the next part should be sent. This is a
         * very indirect and simple batching control mechanism.
         */

        if (andx == null || !USE_BATCHING || batchLevel >= getBatchLimit(andx.command)) {

    }

    @Test
    @DisplayName("send with multiple params returns the stubbed response")
    void send_withParams_returnsResponse() throws Exception {
        // Arrange
        when(tree.send(eq(request), eq(RequestParam.NO_TIMEOUT), eq(RequestParam.NO_RETRY))).thenReturn(response);

        // Act
        CommonServerMessageBlockResponse out = tree.send(request, RequestParam.NO_TIMEOUT, RequestParam.NO_RETRY);

    }
    
    /**
     * Establish RDMA connection
     */
    public abstract void connect() throws IOException;
    
    /**
     * Send data using RDMA
     */
    public abstract void send(ByteBuffer data, RdmaMemoryRegion region) throws IOException;
    
    /**
     * Receive data using RDMA  
     */
    public abstract ByteBuffer receive(int timeout) throws IOException;

import org.dbflute.mail.send.SMailDeliveryDepartment;
import org.dbflute.mail.send.SMailPostalMotorbike;
import org.dbflute.mail.send.SMailPostalParkingLot;
import org.dbflute.mail.send.SMailPostalPersonnel;
import org.dbflute.mail.send.embedded.personnel.SMailDogmaticPostalPersonnel;
import org.dbflute.mail.send.embedded.receptionist.SMailConventionReceptionist;
import org.dbflute.mail.send.supplement.async.SMailAsyncStrategy;

 *  New: `okhttp-sse` is an early preview of Server-Sent Events (SSE). This feature is incomplete
    and is only suitable for experimental use.
 *  New: MockWebServer now supports client authentication (mutual TLS). Call `requestClientAuth()`
    to permit an optional client certificate or `requireClientAuth()` to require one.
 *  New: `RecordedRequest.getHandshake()` returns the HTTPS handshake of a request sent to
    `MockWebServer`.

                    response.b[response.off] = 42; // Return byte value 42
                }
                return null;
            }
        }).when(smbFile).send(any(SmbComReadAndX.class), any(SmbComReadAndXResponse.class));

        int result = smbRandomAccessFile.read();
        assertEquals(42, result);
        assertEquals(1, smbRandomAccessFile.getFilePointer());
    }

   *
   * @param request the request sent over the network. It is an error to access the body of this
   *     request.
   */
  open fun requestHeadersEnd(
    call: Call,
    request: Request,
  ) {
  }

  /**
   * Invoked just prior to sending a request body.  Will only be invoked for request allowing and
   * having a request body to send.
   *

        ServerMessageBlock response = new SmbComOpenAndXResponse();

        // Execute send
        tree.send(request, response);

        // Verify session.send was called and tid was set
        verify(session).send(request, response);
        assertEquals(123, request.tid);
    }

    @Test
    void testSendWithDfs() throws SmbException {

    }

    <T extends CommonServerMessageBlockResponse> T send(final CommonServerMessageBlockRequest request, final T response)
            throws CIFSException {
        return send(request, response, Collections.<RequestParam> emptySet());
    }

    <T extends CommonServerMessageBlockResponse> T send(final CommonServerMessageBlockRequest request, final T response,

   * sent.
   */
  private fun recover(
    e: IOException,
    call: RealCall,
    userRequest: Request,
  ): Boolean {
    val requestSendStarted = e !is ConnectionShutdownException

    // The application layer has forbidden retries.
    if (!client.retryOnConnectionFailure) return false

    // We can't send the request body again.