final InputStream in = ResourceUtil.getResourceAsStream("extractor/program/test.java");
        final Map<String, String> params = new HashMap<String, String>();
        params.put("Content-Type", "text/plain");
        params.put("resourceName", "test.java");
        final ExtractData extractData = tikaExtractor.getText(in, params);
        final String content = extractData.getContent();
        CloseableUtil.closeQuietly(in);

@app.get("/items/")
async def read_items(commons: Annotated[dict, Depends(common_parameters)]):
    return {"message": "Hello Items!", "params": commons}


@app.get("/users/")
async def read_users(commons: Annotated[dict, Depends(common_parameters)]):
    return {"message": "Hello Users!", "params": commons}


client = TestClient(app)


async def override_dependency(q: str | None = None):

    /**
     * Creates and returns a new instance of {@link ConcurrentHashMap}.
     *
     * @param <K> the key type of {@link ConcurrentHashMap}
     * @param <V> the value type of {@link ConcurrentHashMap}
     * @param initialCapacity the initial capacity
     * @param loadFactor the load factor threshold for resizing
     * @param concurrencyLevel the estimated number of threads for concurrent updates

                            "name": "item_id",
                            "in": "path",
                        }
                    ],
                }
            },
            "/path/param/{item_id}": {
                "get": {
                    "responses": {
                        "200": {
                            "description": "Successful Response",

     *
     * @param <T>
     *            The return type of the method
     * @param method
     *            The method. Cannot be {@literal null}
     * @param target
     *            The object on which the underlying method is to be called. {@literal null} for {@literal static} methods
     * @param args
     *            The arguments used for the method call

    /**
     * Resolve part of an array of SIDs using a cache and at most one MSRPC request.
     *
     * @param tc the CIFS context to use
     * @param authorityServerName the server to use for SID resolution
     * @param sids the array of SIDs to resolve
     * @param off the starting offset in the array
     * @param len the number of SIDs to resolve
     * @throws CIFSException if there is an error resolving the SIDs
     */

     * using the specified class loader.
     *
     * @param <T>
     *            The class represented by the returned {@link Class} object
     * @param className
     *            The fully qualified name of the desired class. Must not be {@literal null} or empty.
     * @param loader
     *            The class loader to use to load the class

     * @param dst the destination byte array
     * @param di the starting index in the destination array
     * @param enc the time encoding type (e.g., TIME_1970_SEC_32BE)
     * @return the number of bytes written
     */
    public static int enc_time(final Date date, final byte[] dst, final int di, final int enc) {
        long t;

        return switch (enc) {

     *
     * @param <T> The type of objects to retrieve.
     * @param clazz The class of the objects to retrieve.
     * @param sessionId The session ID to filter by (optional).
     * @param queryBuilder The query builder for search criteria (optional).
     * @param from The starting index for pagination (optional).
     * @param size The maximum number of results to return (optional).

     * </p>
     *
     * @param rootDir the root directory (must not be {@literal null})
     * @param baseDirectory the base directory
     * @param handler the handler to process resources (must not be {@literal null})
     */