final String[] permissions = split(getValue(list, 2), ",").get(stream -> stream.map(permissionHelper::encode)
                            .filter(StringUtil::isNotBlank)
                            .distinct()
                            .toArray(n -> new String[n]));
                    final String[] labels = split(getValue(list, 3), ",")

    tags: set[str] = set()


@app.post("/items/", tags=["items"])
async def create_item(item: Item) -> Item:
    return item


@app.get("/items/", tags=["items"])
async def read_items():
    return [{"name": "Foo", "price": 42}]


@app.get("/users/", tags=["users"])
async def read_users():

    override fun channel(): String = "adhoc-%teamcity.build.branch%"

    override val type: PerformanceTestType
        get() = PerformanceTestType.AD_HOC

    override val failsStage: Boolean
        get() = false

    val buildSpecs: List<FlameGraphGenerationBuildSpec>
        get() =
            scenarios.flatMap { scenario ->
                Os.values().flatMap { os ->

  private final int size;
  private int position;

  /** Returns the element with the specified index. This method is called by {@link #next()}. */
  @ParametricNullness
  protected abstract E get(int index);

  /**
   * Constructs an iterator across a sequence of the given size whose initial position is 0. That
   * is, the first call to {@link #next()} will return the first element (or throw {@link

     * Retrieves a specific document by ID.
     *
     * @param id the document ID to retrieve
     * @return JSON response containing the document
     */
    // GET /api/admin/searchlist/doc/{doc_id}
    @Execute
    public JsonResponse<ApiResult> get$doc(final String id) {
        return asJson(new ApiDocResponse().doc(searchEngineClient.getDocument(fessConfig.getIndexDocumentUpdateIndex(), builder -> {

            }

            final Path resolved = Paths.get(exportPath, sanitized.toString()).normalize();
            final Path baseDir = Paths.get(exportPath).normalize();
            if (!resolved.startsWith(baseDir)) {
                logger.warn("Path traversal detected: url={}, resolved={}", url, resolved);
                return Paths.get(exportPath, "_invalid", hashString(url) + formatter.getFileExtension());
            }

              closed.set(true)
              super.close()
            }
          }.buffer()
        }
      }
    assertThat(body.string()).isEqualTo("hello")
    assertThat(closed.get()).isTrue()
  }

  @Test
  fun readerEmpty() {
    val body = body("")
    assertThat(exhaust(body.charStream())).isEqualTo("")
  }

  @Test
  fun readerLooksLikeBomButTooShort() {

def test_openapi_schema(client: TestClient):
    response = client.get("/openapi.json")
    assert response.status_code == 200, response.text
    assert response.json() == snapshot(
        {
            "openapi": "3.1.0",
            "info": {"title": "FastAPI", "version": "0.1.0"},
            "paths": {
                "/items/{item_id}": {
                    "get": {
                        "responses": {

    /** Service for managing path mapping configurations */
    @Resource
    private PathMappingService pathMappingService;

    // GET /api/admin/pathmap
    // PUT /api/admin/pathmap
    /**
     * Returns list of path mapping settings.
     * Supports both GET and PUT requests for retrieving paginated path mapping configurations.
     *
     * @param body search parameters for filtering and pagination

    //                                                                      ==============

    // GET /api/admin/relatedcontent/settings
    // PUT /api/admin/relatedcontent/settings
    /**
     * Returns list of related content settings.
     * Supports both GET and PUT requests for retrieving paginated related content configurations.
     *
     * @param body search parameters for filtering and pagination