doNothing().when(transport).connect();

        // Setup response for tree connect
        doAnswer(invocation -> {
            ServerMessageBlock request = invocation.getArgument(0);
            ServerMessageBlock response = invocation.getArgument(1);
            if (request instanceof SmbComTreeConnectAndX && response instanceof SmbComTreeConnectAndXResponse) {

    }

    @Test
    void testInstall_ng() {
        checkPostMethod(Collections.emptyMap(), getInstallEndpointSuffix()).then().body("response.status", equalTo(1));
    }

    @Test
    void testDelete_ng() {
        checkDeleteMethod(Collections.emptyMap()).then().body("response.status", equalTo(1));
    }

    @Test

 */

package jcifs.internal.smb1.trans;

import jcifs.Configuration;
import jcifs.internal.SMBProtocolDecodingException;

/**
 * Response for SMB1 TRANS_CALL_NAMED_PIPE transaction.
 *
 * This response contains the data returned from the named pipe
 * after a call transaction has been processed by the server.
 */
public class TransCallNamedPipeResponse extends SmbComTransactionResponse {

## Beschreibung der Response in der Dokumentation – OpenAPI

Um die Beschreibung der Response zu definieren, welche in der Oberfläche der Dokumentation angezeigt wird, lesen Sie die Dokumentation unter [Tutorial – Pfadoperation-Konfiguration – Beschreibung der Response](../tutorial/path-operation-configuration.md#beschreibung-der-response){.internal-link target=_blank}.

     * @param <Response> the response type
     * @param action     the action to execute
     * @param request    the action request
     * @return a future for the action response
     */
    @Override
    public <Request extends ActionRequest, Response extends ActionResponse> ActionFuture<Response> execute(
            final ActionType<Response> action, final Request request) {

      }

    /**
     * Adds an HTTP 1xx response to precede this response. Note that this response's
     * [headers delay][headersDelay] applies after this response is transmitted. Set a
     * headers delay on that response to delay its transmission.
     */
    public fun addInformationalResponse(response: MockResponse): Builder =
      apply {
        informationalResponses_ += response
      }

    val call1 = localClient.newCall(Request(server.url("/")))

    call1.execute().use { response ->
      assertThat(response.body.string()).isEqualTo("Req1")
      assertThat(response.handshake).isNotNull()
      assertThat(response.protocol == Protocol.HTTP_1_1)
    }

    eventListener.closed = true

    val call2 = localClient.newCall(Request(server.url("/")))

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.

                        // response
                        if (negoResp.getSelectedDialect().atLeast(DialectVersion.SMB300) || response.isSigned()) {
                            response.setDigest(dgst);
                            byte[] payload = response.getRawPayload();
                            if (!response.verifySignature(payload, 0, payload.length)) {

    void testReadParameterWordsWireFormat() {
        SmbComWriteAndXResponse response = new SmbComWriteAndXResponse();
        byte[] buffer = new byte[] { 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; // count = 10

        int bytesRead = response.readParameterWordsWireFormat(buffer, 0);

        // The count should be read from the buffer.
        assertEquals(10L, response.count);
        // The method should return the number of bytes read.