}

  /**
   * We delay sending the last byte of the request body 1500 ms. The 1000 ms read timeout should
   * only elapse 1000 ms after the request body is sent.
   */
  @Test
  fun headersReadTimeoutDoesNotStartUntilLastRequestBodyByteFire() {
    enableProtocol(Protocol.HTTP_2)
    server.enqueue(
      MockResponse.Builder()
        .headersDelay(1500, TimeUnit.MILLISECONDS)
        .build(),
    )
    val request =

  integrity sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==
  dependencies:
    resolve-from "^5.0.0"

resolve-from@^5.0.0:
  version "5.0.0"
  resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-5.0.0.tgz#c35225843df8f776df21c57557bc087e9dfdfc69"
  integrity sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==

    stopwatch.reset();
    stopwatch.start();
    ticker.advance((long) (1.5 * 60 * 1000000000L));
    assertEquals("1.500 min", stopwatch.toString());
    stopwatch.reset();
    stopwatch.start();
    ticker.advance((long) (2.5 * 60 * 60 * 1000000000L));
    assertEquals("2.500 h", stopwatch.toString());
    stopwatch.reset();
    stopwatch.start();
    ticker.advance((long) (7.25 * 24 * 60 * 60 * 1000000000L));

    stopwatch.reset();
    stopwatch.start();
    ticker.advance((long) (1.5 * 60 * 1000000000L));
    assertEquals("1.500 min", stopwatch.toString());
    stopwatch.reset();
    stopwatch.start();
    ticker.advance((long) (2.5 * 60 * 60 * 1000000000L));
    assertEquals("2.500 h", stopwatch.toString());
    stopwatch.reset();
    stopwatch.start();
    ticker.advance((long) (7.25 * 24 * 60 * 60 * 1000000000L));

    backend.shutdown()
  }

  @Test fun test() {
    val t1 = System.nanoTime() / 1e6

    val delays = mutableListOf(TimeUnit.MILLISECONDS.toNanos(1000), -1L)
    queue.schedule("task", TimeUnit.MILLISECONDS.toNanos(750)) {
      log.put("runOnce delays.size=${delays.size}")
      return@schedule delays.removeAt(0)
    }

    assertThat(log.take()).isEqualTo("runOnce delays.size=2")
    val t2 = System.nanoTime() / 1e6 - t1

@callback_router5.get("/")
async def callback5(level5: str):
    pass  # pragma: nocover


app = FastAPI(
    dependencies=[Depends(dep0)],
    responses={
        400: {"description": "Client error level 0"},
        500: {"description": "Server error level 0"},
    },
    default_response_class=ResponseLevel0,
    callbacks=callback_router0.routes,
)

router2_override = APIRouter(
    prefix="/level2",

    name: str


app = FastAPI()


@app.get("/valid1", responses={"500": {"model": int}})
def valid1():
    pass


@app.get("/valid2", responses={"500": {"model": List[int]}})
def valid2():
    pass


@app.get("/valid3", responses={"500": {"model": Model}})
def valid3():
    pass


@app.get("/valid4", responses={"500": {"model": List[Model]}})
def valid4():
    pass

	<modelVersion>4.0.0</modelVersion>
	<groupId>org.codelibs.fess</groupId>
	<artifactId>fess-crawler-parent</artifactId>
	<version>15.0.0-SNAPSHOT</version>
	<packaging>pom</packaging>
	<name>Fess Crawler Project</name>
	<description>Fess Crawler is Crawler Framework.</description>
	<url>https://github.com/codelibs/fess-crawler</url>
	<issueManagement>

class JsonApiError(BaseModel):
    errors: typing.List[Error]


@app.get(
    "/a",
    response_class=JsonApiResponse,
    responses={500: {"description": "Error", "model": JsonApiError}},
)
async def a():
    pass  # pragma: no cover


@app.get("/b", responses={500: {"description": "Error", "model": Error}})
async def b():
    pass  # pragma: no cover


client = TestClient(app)

            assertEquals(128, crawlingInfoHelper.generateId(value.substring(0, 490)).length());
            assertEquals(128, crawlingInfoHelper.generateId(value.substring(0, 500)).length());
            assertEquals(128, crawlingInfoHelper.generateId(value.substring(0, 510)).length());
            assertEquals(128, crawlingInfoHelper.generateId(value.substring(0, 520)).length());