val call = client.newCall(networkRequest)

    call.execute().use { response ->
      assertThat(response.code).isEqualTo(200)
      assertThat(response.cacheResponse).isNull()
    }

    val cachedCall = client.newCall(request)

    cachedCall.execute().use { response ->
      assertThat(response.code).isEqualTo(200)
      assertThat(response.cacheResponse).isNotNull()
    }
  }

  @Test

    }

    /**
     * Gets the response sequence number returned by the server.
     * This should match the request sequence number in a successful response.
     *
     * @return the response sequence number
     */
    public long getResponseSequenceNumber() {
        return responseSequenceNumber;
    }

    /**
     * Sets the response sequence number.
     *

    public void setDocumentItems(final List<Map<String, Object>> documentItems) {
        this.documentItems = documentItems;
    }

    /**
     * Sets the facet response containing aggregated search facets.
     *
     * @param facetResponse The facet response
     */
    public void setFacetResponse(final FacetResponse facetResponse) {
        this.facetResponse = facetResponse;
    }

    /**

In diesem Fall möchten Sie möglicherweise dokumentieren, wie diese externe API aussehen *sollte*. Welche *Pfadoperation* sie haben sollte, welchen Body sie erwarten sollte, welche <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr> sie zurückgeben sollte, usw.

## Eine Anwendung mit Callbacks { #an-app-with-callbacks }

Sehen wir uns das alles anhand eines Beispiels an.

    }

    /**
     * Returns whether this rule is a default rule that matches all responses.
     * @return true if this is a default rule, false otherwise
     */
    public boolean isDefaultRule() {
        return defaultRule;
    }

    /**
     * Sets whether this rule should be a default rule that matches all responses.
     * @param defaultRule true to make this a default rule, false otherwise
     */

import org.dbflute.optional.OptionalEntity;
import org.dbflute.optional.OptionalThing;
import org.lastaflute.web.Execute;
import org.lastaflute.web.response.ActionResponse;
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 Bad Word management.
 *

        self.limit = limit


@app.get("/items/")
async def read_items(commons=Depends(CommonQueryParams)):
    response = {}
    if commons.q:
        response.update({"q": commons.q})
    items = fake_items_db[commons.skip : commons.skip + commons.limit]
    response.update({"items": items})

import org.codelibs.fess.app.web.base.FessSearchAction;
import org.codelibs.fess.app.web.base.SearchForm;
import org.codelibs.fess.util.RenderDataUtil;
import org.lastaflute.web.Execute;
import org.lastaflute.web.response.HtmlResponse;

/**
 * The action for the root of the application.
 */
public class RootAction extends FessSearchAction {

    /**
     * Constructor.
     */
    public RootAction() {
        super();

    Request request = new Request.Builder()
        .url(ENDPOINT)
        .build();

    // Execute the request and retrieve the response.
    try (Response response = client.newCall(request).execute()) {
      // Deserialize HTTP response to concrete type.
      ResponseBody body = response.body();
      List<Contributor> contributors = CONTRIBUTORS_JSON_ADAPTER.fromJson(body.source());

      // Sort list by the most contributions.

// error if the server message is invalid.  Calling Step after a conversation
// completes is also an error.
func (x *XDGSCRAMClient) Step(challenge string) (response string, err error) {
	response, err = x.ClientConversation.Step(challenge)
	return response, err
}

// Done returns true if the conversation is completed or has errored.
func (x *XDGSCRAMClient) Done() bool {
	return x.ClientConversation.Done()