qrList = new QueryResponseList(null, 0, 20, 0) {
            @Override
            public int size() {
                return 20;
            }
        };
        qrList.allRecordCount = 20;
        qrList.calculatePageInfo();
        pnList = qrList.getPageNumberList();
        assertEquals(1, pnList.size());
        assertEquals("1", pnList.get(0));

        qrList = new QueryResponseList(null, 0, 20, 0) {

    }
    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() {

        // The validation in getBuffer() ensures size is within bounds (0 < size <= 1MB)
        assertTrue(buffer.length > 0, "Buffer size should be positive");
        assertTrue(buffer.length <= 0x100000, "Buffer size should not exceed 1MB");
    }

    /**
     * Test that releaseBuffer validates buffer before accepting it.
     */
    @Test

   */
  @CanIgnoreReturnValue
  private @Nullable MoveDesc<E> removeAt(int index) {
    checkPositionIndex(index, size);
    modCount++;
    size--;
    if (size == index) {
      queue[size] = null;
      return null;
    }
    E actualLastElement = elementData(size);
    int lastElementAt = heapForIndex(size).swapWithConceptuallyLastElement(actualLastElement);
    if (lastElementAt == index) {

    for (int i = 0; i < expected.size(); i++) {
      actual.add(q.pollFirst());
    }
    assertEquals(expected, actual);
  }

  public void testCorrectOrdering_smallHeapsPollFirst() {
    for (int size = 2; size < 16; size++) {
      for (int attempts = 0; attempts < size * (size - 1); attempts++) {
        ArrayList<Integer> elements = createOrderedList(size);

    } else {
      assertNull(multimap().asMap().get(key));
    }

    assertEquals(values.size(), multimap().get(key).size());

    assertEquals(values.size() > 0, multimap().containsKey(key));
    assertEquals(values.size() > 0, multimap().keySet().contains(key));
    assertEquals(values.size() > 0, multimap().keys().contains(key));
  }

  protected final K k0() {
    return e0().getKey();
  }

   */
  @CanIgnoreReturnValue
  private @Nullable MoveDesc<E> removeAt(int index) {
    checkPositionIndex(index, size);
    modCount++;
    size--;
    if (size == index) {
      queue[size] = null;
      return null;
    }
    E actualLastElement = elementData(size);
    int lastElementAt = heapForIndex(size).swapWithConceptuallyLastElement(actualLastElement);
    if (lastElementAt == index) {

    @DisplayName("Should return max transact size")
    void testGetMaxTransactSize() throws Exception {
        // Given
        setPrivateField(response, "maxTransactSize", 1048576);

        // When
        int size = response.getMaxTransactSize();

        // Then
        assertEquals(1048576, size);
    }

    @Test
    @DisplayName("Should return transaction buffer size")

    }

    ensureCapacity(size + 1);
    keys[size] = key;
    values[size] = value;

    insertIntoTableKToV(size, keyHash);
    insertIntoTableVToK(size, valueHash);

    setSucceeds(lastInInsertionOrder, size);
    setSucceeds(size, ENDPOINT);
    size++;
    modCount++;
    return null;
  }

  @CanIgnoreReturnValue
  @Override

    }

    /**
     * Gets the page size.
     *
     * @return The page size.
     */
    public int getPageSize() {
        if (pageSize <= 0) {
            pageSize = getDefaultPageSize();
        }
        return pageSize;
    }

    /**
     * Sets the page size.
     *
     * @param pageSize The page size.
     */
    public void setPageSize(final int pageSize) {