self._errors = errors
        self.endpoint_ctx = endpoint_ctx

        ctx = endpoint_ctx or {}
        self.endpoint_function = ctx.get("function")
        self.endpoint_path = ctx.get("path")
        self.endpoint_file = ctx.get("file")
        self.endpoint_line = ctx.get("line")

    def errors(self) -> Sequence[Any]:
        return self._errors

    def _format_endpoint_context(self) -> str:

            case "expression":
                factory = scriptModule.engines.get("expression").compile("test", "doc['n'].value", ScoreScript.CONTEXT, Map.of());
                break;
            case "metal":
                factory = bareMetalScript();
                break;
            case "painless_cast":
                factory = scriptModule.engines.get("painless")
                    .compile(
                        "test",

from fastapi import FastAPI, Path

app = FastAPI()


@app.get("/items/{item_id}")
async def read_items(*, item_id: int = Path(title="The ID of the item to get"), q: str):
    results = {"item_id": item_id}
    if q:
        results.update({"q": q})

    try {
      future.get();
      Assert.fail("This call was supposed to throw an ExecutionException");
    } catch (ExecutionException expected) {
      Assert.assertSame(expectedCause, expected.getCause());
    }
  }

  public void assertTimeout() throws Exception {
    // Verify that the listener does not get called in a reasonable amount of
    // time.

    assertEquals(expectedValue, future.get());
  }

  public void testCancelledFuture() throws InterruptedException, ExecutionException {
    assertTrue(future.isDone());
    assertTrue(future.isCancelled());

    assertTrue(latch.await(5, SECONDS));
    assertTrue(future.isDone());
    assertTrue(future.isCancelled());

    assertThrows(CancellationException.class, future::get);
  }

  @Override
  protected abstract LoadingCache<K, V> delegate();

  @CanIgnoreReturnValue // TODO(b/27479612): consider removing this
  @Override
  public V get(K key) throws ExecutionException {
    return delegate().get(key);
  }

  @CanIgnoreReturnValue // TODO(b/27479612): consider removing this
  @Override
  public V getUnchecked(K key) {
    return delegate().getUnchecked(key);
  }

 * <b>indiscriminately</b> to the methods of the delegate. For example, overriding {@link #get(long,
 * TimeUnit)} alone <b>will not</b> change the behavior of {@link #get()}, which can lead to
 * unexpected behavior. In this case, you should override {@code get()} as well.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code

    browser = playwright.chromium.launch(headless=False)
    context = browser.new_context()
    page = context.new_page()
    page.goto("http://localhost:8000/docs")
    page.get_by_role("button", name="GET /items/ Read Items").click()
    page.get_by_role("button", name="Try it out").click()
    page.get_by_role("heading", name="Servers").click()
    # Manually add the screenshot

from fastapi import FastAPI, Path

app = FastAPI()


@app.get("/items/{item_id}")
async def read_items(
    *, item_id: int = Path(title="The ID of the item to get", ge=1), q: str
):
    results = {"item_id": item_id}
    if q:
        results.update({"q": q})

     *
     * @param id the ID of the bad word to retrieve
     * @return JSON response containing the bad word configuration
     */
    // GET /api/admin/badword/{id}
    @Execute
    public JsonResponse<ApiResult> get$setting(final String id) {

        final BadWord entity = badWordService.getBadWord(id).orElseGet(() -> {