} while (true);
        } else {
            request.setResponse(response);
        }
        if (response == null) {
            throw new IOException("Invalid response");
        }
        return response;
    }

    @Override
    protected <T extends Response> boolean handleIntermediate(final Request request, final T response) {
        if (!this.smb2) {
            return false;
        }

        }
    }

    private FileEntry advance() throws CIFSException {
        final int n =
                this.response.getStatus() == WinError.ERROR_MORE_DATA ? this.response.getNumEntries() - 1 : this.response.getNumEntries();
        while (this.ridx < n) {
            final FileEntry itm = this.response.getResults()[this.ridx];
            this.ridx++;
            if (filter(itm)) {
                return itm;
            }

///

### Before and after the `response` { #before-and-after-the-response }

You can add code to be run with the `request`,  before any *path operation* receives it.

And also after the `response` is generated, before returning it.

For example, you could add a custom header `X-Process-Time` containing the time in seconds that it took to process the request and generate a response:

import org.codelibs.fess.util.RenderDataUtil;
import org.dbflute.optional.OptionalEntity;
import org.dbflute.optional.OptionalThing;
import org.lastaflute.web.Execute;
import org.lastaflute.web.response.HtmlResponse;
import org.lastaflute.web.response.render.RenderData;
import org.lastaflute.web.ruts.process.ActionRuntime;

import jakarta.annotation.Resource;

/**
 * Admin action for Path Map management.
 *
 */

client = TestClient(app)


def test_form_default_url_encoded():
    response = client.post("/urlencoded", data={"age": ""})
    assert response.status_code == 200
    assert response.text == "null"


def test_form_default_multi_part():
    response = client.post("/multipart", data={"age": ""})
    assert response.status_code == 200

            "partial-asynchronous-method-gen-dependency",
        ),
    ],
)
def test_dependency_types_with_partial(route: str, value: str) -> None:
    response = client.get(route)
    assert response.status_code == 200, response.text

            .url("https://publicobject.com/robots.txt")
            .build();

        try (Response response = client.newCall(request).execute()) {
          if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

          for (Certificate certificate : response.handshake().peerCertificates()) {
            System.out.println(CertificatePinner.pin(certificate));
          }
        }

/**
 * SMB2 Write response message.
 *
 * This response contains information about the write operation,
 * including the number of bytes actually written.
 *
 * @author mbechler
 */
public class Smb2WriteResponse extends ServerMessageBlock2Response {

    private int count;
    private int remaining;

    /**
     * Creates a new SMB2 write response.
     *

    val request =
      Request
        .Builder()
        .url("https://valid-isrgrootx1.letsencrypt.org/robots.txt")
        .build()
    client.newCall(request).execute().use { response ->
      assertThat(response.code).isEqualTo(404)
      assertThat(response.protocol).isEqualTo(Protocol.HTTP_2)
    }
  }

import org.codelibs.fess.suggest.request.Response;

/**
 * Represents the response for popular words request.
 */
public class PopularWordsResponse implements Response {

    /**
     * The index associated with the response.
     */
    protected final String index;

    /**
     * The time taken to generate the response in milliseconds.
     */
    protected final long tookMs;