)


async def request_validation_exception_handler(
    request: Request, exc: RequestValidationError
) -> JSONResponse:
    return JSONResponse(
        status_code=HTTP_422_UNPROCESSABLE_ENTITY,
        content={"detail": jsonable_encoder(exc.errors())},
    )


async def websocket_request_validation_exception_handler(
    websocket: WebSocket, exc: WebSocketRequestValidationError
) -> None:

from starlette.responses import JSONResponse


def http_exception_handler(request, exception):
    return JSONResponse({"exception": "http-exception"})


def request_validation_exception_handler(request, exception):
    return JSONResponse({"exception": "request-validation"})


def server_error_exception_handler(request, exception):
    return JSONResponse(status_code=500, content={"exception": "server-error"})


app = FastAPI(

        )
    return {"item": items[item_id]}


@app.get("/http-no-body-statuscode-exception")
async def no_body_status_code_exception():
    raise HTTPException(status_code=204)


@app.get("/http-no-body-statuscode-with-detail-exception")
async def no_body_status_code_with_detail_exception():
    raise HTTPException(status_code=204, detail="I should just disappear!")

    return {"message": "OK"}


app.include_router(router)
app.add_middleware(ContentSizeLimitMiddleware, max_content_size=2**8)


client = TestClient(app)


def test_custom_middleware_exception(tmp_path: Path):
    default_pydantic_max_size = 2**16
    path = tmp_path / "test.txt"
    path.write_bytes(b"x" * (default_pydantic_max_size + 1))

    with client:
        with open(path, "rb") as file:

        assertThat(toSqlDateJdbcEscape(null), is(nullValue()));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testToSqlDate_EmptyString() throws Exception {
        assertThat(toSqlDateJdbcEscape(""), is(nullValue()));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testToSqlDate_ShortStyle() throws Exception {

    Exception exception = new SampleCheckedException();
    ExecutionException e =
        assertThrows(
            ExecutionException.class,
            () ->
                timeLimiter.callWithTimeout(
                    callableThrowing(exception), DELAY_MS, TimeUnit.MILLISECONDS));
    assertThat(e.getCause()).isEqualTo(exception);
  }

    Exception exception = new SampleCheckedException();
    ExecutionException e =
        assertThrows(
            ExecutionException.class,
            () ->
                timeLimiter.callWithTimeout(
                    callableThrowing(exception), DELAY_MS, TimeUnit.MILLISECONDS));
    assertThat(e.getCause()).isEqualTo(exception);
  }

    }

    /**
     * @throws Exception
     */
    @Test
    public void testGetLastEntry() throws Exception {
        assertThat(list.getLastEntry(), is(nullValue()));
        list.addLast("1");
        assertThat(list.getLastEntry().getElement(), is("1"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGetLast() throws Exception {
        try {
            list.getLast();

    assertThat(e).hasCauseThat().isSameInstanceAs(exception);
    assertEquals(Service.State.FAILED, service.state());
  }

  public void testFunctionalStop_failed() {
    final Exception exception = new Exception("deliberate");
    AbstractIdleService service =
        new DefaultService() {
          @Override
          protected void shutDown() throws Exception {
            throw exception;
          }
        };

public class NumberConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testConvertNumber_byte() throws Exception {
        assertEquals(new Byte("1"), NumberConversionUtil.convertNumber(Byte.class, "1"));
    }

    /**
     * @throws Exception
     */
    public void testConvertNumber_primitiveWrapper() throws Exception {