*/
    void sign(final byte[] data, final int offset, final int length, final ServerMessageBlock request, final ServerMessageBlock response) {
        request.signSeq = signSequence;
        if (response != null) {
            response.signSeq = signSequence + 1;
            response.verifyFailed = false;
        }

        try {
            update(macSigningKey, 0, macSigningKey.length);

                        response = (TreeConnectResponse) request.getResponse();
                        if (response.isReceived() && !response.isError() && response.getErrorCode() == NtStatus.NT_STATUS_SUCCESS) {
                            if (!transport.isDisconnected()) {
                                treeConnected(transport, sess, response);
                            }
                            throw se;

                request.setFlags(registration.getFlags());

                WitnessRegisterResponse response = rpcClient.register(request);

                if (response != null && response.isSuccess()) {
                    registration.setState(WitnessRegistrationState.REGISTERED);
                    registration.setContextHandle(response.getContextHandle());
                    registrations.put(registration.getRegistrationId(), registration);

///

### Antes y después de la `response` { #before-and-after-the-response }

Puedes añadir código que se ejecute con la `request`, antes de que cualquier *path operation* la reciba.

Y también después de que se genere la `response`, antes de devolverla.

Por ejemplo, podrías añadir un custom header `X-Process-Time` que contenga el tiempo en segundos que tomó procesar la request y generar una response:

    val response = call.execute()
    assertThat(response.code).isEqualTo(200)
    assertThat(response.handshake!!.cipherSuite).isNotNull()
    assertThat(response.handshake!!.tlsVersion).isNotNull()
    assertThat(response.handshake!!.localCertificates).isEmpty()
    assertThat(response.handshake!!.localPrincipal).isNull()
    assertThat(response.handshake!!.peerCertificates).isEmpty()

import org.junit.jupiter.api.Test;

/**
 * Tests for the SmbComBlankResponse class.
 */
class SmbComBlankResponseTest {

    private SmbComBlankResponse response;
    private byte[] buffer;

    @BeforeEach
    void setUp() {
        response = new SmbComBlankResponse();
        buffer = new byte[100];
    }

    /**
     * Test for the writeParameterWordsWireFormat method.
     * It should always return 0.

        String response = checkPostMethod(requestBody, ITEM_ENDPOINT_SUFFIX).asString();

        // Test: access admin api using a new token
        String id = JsonPath.from(response).get("response.id");
        response = checkGetMethod(requestBody, ITEM_ENDPOINT_SUFFIX + "/" + id).asString();
        String token = JsonPath.from(response).get("response.setting.token");

     *
     * @param request the negotiation request
     * @param response the negotiation response
     * @param negoReqBuffer the raw request buffer
     * @param negoRespBuffer the raw response buffer
     *
     */
    public SmbNegotiation(final SmbNegotiationRequest request, final SmbNegotiationResponse response, final byte[] negoReqBuffer,
            final byte[] negoRespBuffer) {
        this.request = request;

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public class GetExample {
  final OkHttpClient client = new OkHttpClient();

  String run(String url) throws IOException {
    Request request = new Request.Builder()
        .url(url)
        .build();

    try (Response response = client.newCall(request).execute()) {
      return response.body().string();
    }
  }

        headerStartField.set(response, headerStart);

        // When
        int bytesRead = response.readBytesWireFormat(buffer, bodyStart);

        // Then
        assertEquals(dataOffsetFromHeader + dataLength - bodyStart, bytesRead);
        assertEquals(dataLength, response.getDataLength());
        assertEquals(dataRemaining, response.getDataRemaining());