"properties": {
                            "detail": {
                                "items": {
                                    "$ref": "#/components/schemas/ValidationError"
                                },
                                "type": "array",
                                "title": "Detail",
                            }
                        },

 */
public class SuggesterException extends RuntimeException {

    private static final long serialVersionUID = 1L;

    /**
     * Constructs a new SuggesterException with the specified detail message.
     * @param msg The detail message.
     */
    public SuggesterException(final String msg) {
        super(msg);
    }

    /**
     * Constructs a new SuggesterException with the specified cause.

            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Not authenticated",
            headers={"WWW-Authenticate": "Bearer"},
        )
    return user


async def get_current_active_user(current_user: User = Depends(get_current_user)):
    if current_user.disabled:
        raise HTTPException(status_code=400, detail="Inactive user")
    return current_user


@app.post("/token")

                return await original_route_handler(request)
            except RequestValidationError as exc:
                body = await request.body()
                detail = {"errors": exc.errors(), "body": body.decode()}
                raise HTTPException(status_code=422, detail=detail)

        return custom_route_handler


app = FastAPI()
app.router.route_class = ValidationErrorLoggingRoute


@app.post("/")

    try:
        yield "Rick"
    except OwnerError as e:
        raise HTTPException(status_code=400, detail=f"Owner error: {e}")


@app.get("/items/{item_id}")
def get_item(item_id: str, username: str = Depends(get_username)):
    if item_id not in data:
        raise HTTPException(status_code=404, detail="Item not found")
    item = data[item_id]
    if item["owner"] != username:
        raise OwnerError(username)

                "HTTPValidationError": {
                    "title": "HTTPValidationError",
                    "type": "object",
                    "properties": {
                        "detail": {
                            "title": "Detail",
                            "type": "array",
                            "items": {"$ref": "#/components/schemas/ValidationError"},
                        }
                    },

                "HTTPValidationError": {
                    "properties": {
                        "detail": {
                            "items": {
                                "$ref": "#/components/schemas/ValidationError",
                            },
                            "title": "Detail",
                            "type": "array",
                        },
                    },

     */
    public void addLanguage(final String lang) {
        languages.add(lang);
    }

    /**
     * Sets the detail flag.
     * @param detail The detail flag.
     */
    public void setDetail(final boolean detail) {
        this.detail = detail;
    }

    /**
     * Adds an exclude word.
     * @param excludeWord The word to exclude.
     */

     * @param message the detail message
     * @param cause the cause of the exception
     */
    public RobotsTxtException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new RobotsTxtException with the specified detail message.
     * @param message the detail message
     */

    assert response.status_code == 400
    assert response.json() == {"detail": "Invalid X-Token header"}


def test_read_nonexistent_item():
    response = client.get("/items/baz", headers={"X-Token": "coneofsilence"})
    assert response.status_code == 404
    assert response.json() == {"detail": "Item not found"}


def test_create_item():
    response = client.post(
        "/items/",