val response = call.execute()
    assertThat(response.body.string()).isEqualTo("ABC")
    assertThat(response.protocol).isEqualTo(protocol)

    // Confirm a single ping was sent and received, and its reply was sent and received.
    val logs = testLogHandler.takeAll()
    assertThat(countFrames(logs, "FINE: >> 0x00000000     8 PING          "))
      .isEqualTo(1)

         * 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 (this.andx == null || !getConfig().isUseBatching()

 * and their completion status.
 */
public class RdmaWorkRequest {

    /**
     * Type of RDMA work request
     */
    public enum RequestType {
        /** Send operation */
        SEND,
        /** Receive operation */
        RECEIVE,
        /** RDMA read operation */
        READ,
        /** RDMA write operation */
        WRITE
    }

    private final long requestId;

            when(existsResponse.getAttributes()).thenReturn(0); // Not found
            when(mockTreeHandle.send(any(), any(SmbComQueryInformationResponse.class))).thenReturn(existsResponse);

            // Mock the actual mkdir call
            when(mockTreeHandle.send(any(SmbComCreateDirectory.class), any(SmbComBlankResponse.class)))
                    .thenReturn(mock(SmbComBlankResponse.class));

        }).when(transport).send(any(ServerMessageBlock.class), any(ServerMessageBlock.class));

        session.send(req, resp);
        // Response state should be reset
        assertFalse(resp.received, "Response flag should be reset");
        // transport.send should be called at least once (for sessionSetup and the actual request)

            request.flags2 &= ~SmbConstants.FLAGS2_RESOLVE_PATHS_IN_DFS;
        }
    }

    void send(final ServerMessageBlock request, final ServerMessageBlock response) throws SmbException {
        for (;;) {
            resolveDfs(request);
            try {
                tree.send(request, response);
                break;
            } catch (final DfsReferral dre) {

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Mock witness service for integration testing.
 * Simulates a basic witness service that can accept registrations
 * and send notifications.
 */
public class MockWitnessService implements AutoCloseable {
    private static final Logger log = LoggerFactory.getLogger(MockWitnessService.class);

    private ServerSocket serverSocket;

        }

        int r, n;
        final SmbComReadAndXResponse response = new SmbComReadAndXResponse(b, off);
        do {
            r = len > readSize ? readSize : len;
            file.send(new SmbComReadAndX(file.fid, fp, r, null), response);
            n = response.dataLength;
            if (n <= 0) {
                return (int) (fp - start > 0L ? fp - start : -1);
            }
            fp += n;

  ) : SocketEffect

  /**
   * On HTTP/2, send a [GOAWAY frame](https://tools.ietf.org/html/rfc7540#section-6.8) immediately
   * after the response and will close the connection when the client's socket is exhausted.
   *
   * On HTTP/1 this closes the socket.
   */
  public object ShutdownConnection : SocketEffect

  /**
   * On HTTP/2 this will send the error code on the stream.
   *

        }

        override fun onMessage(
          webSocket: WebSocket,
          bytes: ByteString,
        ) {
          webSocket.send(bytes)
        }

        override fun onMessage(
          webSocket: WebSocket,
          text: String,
        ) {
          webSocket.send(text)
        }

        override fun onClosing(
          webSocket: WebSocket,
          code: Int,
          reason: String,