}
  }

  @Test fun closeReservedSetThrows() {
    data.write("880203ec".decodeHex()) // Close with code 1004
    data.write("880203ed".decodeHex()) // Close with code 1005
    data.write("880203ee".decodeHex()) // Close with code 1006
    for (i in 1015..2999) {
      data.write(("8802" + format("%04X", i)).decodeHex()) // Close with code 'i'
    }
    var count = 0

    response = client.get("/items/1001?q=somequery")
    assert response.status_code == 422, response.text
    assert response.json() == {
        "detail": [
            {
                "loc": ["path", "item_id"],
                "input": "1001",
                "msg": "Input should be less than or equal to 1000",
                "type": "less_than_equal",
                "ctx": {"le": 1000},
            }
        ]
    }

      Route(
        factory.newAddress(uriHost = "1.2.3.4", uriPort = 1003),
        Proxy.NO_PROXY,
        InetSocketAddress(ipv4Address, 1003),
      ).toString(),
    ).isEqualTo("1.2.3.4:1003")
    assertThat(
      Route(
        factory.newAddress(uriHost = "example.com", uriPort = 1003),
        Proxy.NO_PROXY,
        InetSocketAddress(ipv4Address, 1003),
      ).toString(),
    ).isEqualTo("example.com at 1.2.3.4:1003")

        params.put("delayMillisAfterProcessing", 100L);
        params.put("delayMillisAtNoUrlInQueue", 200L);
        params.put("delayMillisBeforeProcessing", 300L);
        params.put("delayMillisForWaitingNewUrl", 400L);

        final DefaultIntervalController controller = new DefaultIntervalController(params);

        assertEquals(100L, controller.getDelayMillisAfterProcessing());

        CacheBuilder.newBuilder().expireAfterAccess(1000, MILLISECONDS).ticker(fakeTicker).build();

    cache.put(0, 10);
    cache.put(2, 30);

    fakeTicker.advance(999, MILLISECONDS);
    assertThat(cache.getIfPresent(2)).isEqualTo(30);
    fakeTicker.advance(1, MILLISECONDS);
    assertThat(cache.getIfPresent(2)).isEqualTo(30);
    fakeTicker.advance(1000, MILLISECONDS);
    assertThat(cache.getIfPresent(0)).isNull();

     * Test that crawling intervals for the same host work correctly.
     */
    public void test_delayBeforeProcessing() {
        // Number of concurrent tasks
        final int numTasks = 100;
        // Interval in milliseconds
        final Long waittime = 100L;

        CrawlingParameterUtil.setUrlQueue(new UrlQueueImpl());
        final UrlQueue q = CrawlingParameterUtil.getUrlQueue();
        for (int i = 0; i < numTasks; i++) {

    BloomFilter<Long> bf1 = BloomFilter.create(new CustomFunnel(), 100);
    BloomFilter<Long> bf2 = BloomFilter.create(new CustomFunnel(), 100);
    assertEquals(bf1, bf2);
  }

  public void testSerializationWithCustomFunnel() {
    SerializableTester.reserializeAndAssert(BloomFilter.create(new CustomFunnel(), 100));
  }

  private static final class CustomFunnel implements Funnel<Long> {

        assertEquals(2, response2.getNum());

        // Sleep only until next second to ensure unique index name (typically <100ms)
        long currentMillis = System.currentTimeMillis();
        long millisUntilNextSecond = 1000 - (currentMillis % 1000);
        Thread.sleep(millisUntilNextSecond + 10); // +10ms buffer
        suggester.createNextIndex();
        SuggestItem[] items2 = getItemSet2();

        } else {
            originalValue = Integer.parseInt(limitPercentage);
        }

        if (originalValue > 100) {
            this.limitPercentage = 100;
        } else if (originalValue < 1) {
            this.limitPercentage = 1;
        } else {
            this.limitPercentage = originalValue;
        }

			Mode:     420,
			Uid:      1000,
			Gid:      1000,
			Size:     200,
			ModTime:  time.Unix(1392395740, 0),
			Typeflag: 0x53,
			Linkname: "",
			Uname:    "david",
			Gname:    "david",
			Devmajor: 0,
			Devminor: 0,
			Format:   FormatGNU,
		}, {
			Name:     "sparse-posix-0.0",
			Mode:     420,
			Uid:      1000,
			Gid:      1000,
			Size:     200,