if (headerCount + 1 > dynamicTable.size) { // Need to grow the dynamic table.
            val doubled = arrayOfNulls<Header>(dynamicTable.size * 2)
            System.arraycopy(dynamicTable, 0, doubled, dynamicTable.size, dynamicTable.size)
            nextHeaderIndex = dynamicTable.size - 1
            dynamicTable = doubled
          }
          index = nextHeaderIndex--

    }

    /**
     * Validate file size from server
     *
     * @param size file size
     * @throws SmbException if size is invalid
     */
    public void validateFileSize(long size) throws SmbException {
        totalValidations.incrementAndGet();

        if (size < 0) {
            failedValidations.incrementAndGet();
            log.warn("Negative file size: {}", size);

        assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);

        VersionRange version = VersionRange.createFromVersion("1.0");
        assertSame(version, VersionRange.createFromVersion("1.0")); // same instance from version cache
        restrictions = version.getRestrictions();
        assertEquals(0, restrictions.size(), CHECK_NUM_RESTRICTIONS);

        assertFalse(

@pytest.mark.parametrize(
    "path,expected_response",
    [
        (
            "/items/0?q=&size=0.1",
            {"item_id": 0, "size": 0.1},
        ),
        (
            "/items/1000?q=somequery&size=10.4",
            {"item_id": 1000, "q": "somequery", "size": 10.4},
        ),
    ],
)
def test_read_items(client: TestClient, path, expected_response):
    response = client.get(path)

    this.threshold = Math.max(1, (int) (buckets * loadFactor));
  }

  private static int[] newTable(int size) {
    int[] array = new int[size];
    Arrays.fill(array, UNSET);
    return array;
  }

  private static long[] newEntries(int size) {
    long[] array = new long[size];
    Arrays.fill(array, UNSET);
    return array;
  }

  private int hashTableMask() {

  public void testSubList_size() {
    List<E> list = getList();
    int size = getNumElements();
    assertEquals(size, list.subList(0, size).size());
    assertEquals(size - 1, list.subList(0, size - 1).size());
    assertEquals(size - 1, list.subList(1, size).size());
    assertEquals(0, list.subList(size, size).size());
    assertEquals(0, list.subList(0, 0).size());
  }

  @CollectionSize.Require(absent = {ZERO})

  public void testSubList_size() {
    List<E> list = getList();
    int size = getNumElements();
    assertEquals(size, list.subList(0, size).size());
    assertEquals(size - 1, list.subList(0, size - 1).size());
    assertEquals(size - 1, list.subList(1, size).size());
    assertEquals(0, list.subList(size, size).size());
    assertEquals(0, list.subList(0, 0).size());
  }

  @CollectionSize.Require(absent = {ZERO})

            assertNotNull(parsers);
            assertEquals(1, parsers.size());
            Map<String, ModelParser> parsersMap = container.lookupMap(ModelParser.class);
            assertNotNull(parsersMap);
            assertEquals(1, parsersMap.size());
        }

        @Test
        void testGuice() throws Exception {
            List<Binding<ModelParser>> parsers =

        public String format(long size) {
            return format(size, null);
        }

        public String format(long size, ScaleUnit unit) {
            return format(size, unit, false);
        }

        public String format(long size, ScaleUnit unit, boolean omitSymbol) {
            if (size < 0L) {
                throw new IllegalArgumentException("file size cannot be negative: " + size);
            }

    }
    int size = this.size;
    if (size < requireEntries().length) {
      resizeEntries(size);
    }
    int minimumTableSize = CompactHashing.tableSize(size);
    int mask = hashTableMask();
    if (minimumTableSize < mask) { // smaller table size will always be less than current mask
      resizeTable(mask, minimumTableSize, UNSET, UNSET);
    }
  }

  @Override
  public void clear() {