// Max size is halved due to indexing into double-sized alternatingKeysAndValues
  private static final int BYTE_MAX_SIZE = 1 << (Byte.SIZE - 1); // 2^7 = 128
  private static final int SHORT_MAX_SIZE = 1 << (Short.SIZE - 1); // 2^15 = 32_768

  private static final int BYTE_MASK = (1 << Byte.SIZE) - 1; // 2^8 - 1 = 255
  private static final int SHORT_MASK = (1 << Short.SIZE) - 1; // 2^16 - 1 = 65_535

   */
  @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) {

        }

        @Test
        @DisplayName("size() method should return correct size")
        void testSizeMethod() {
            CreateContextRequest request = mock(CreateContextRequest.class);
            when(request.size()).thenReturn(64);

            int size = request.size();
            assertEquals(64, size);
            verify(request, times(1)).size();
        }

        @Test

    @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")

  @Param({"0", "1", "16", "256", "4096", "65536"})
  int size;

  LinkedHashMultiset<Object> linkedHashMultiset;
  HashMultiset<Object> hashMultiset;

  // TreeMultiset requires a Comparable element.
  TreeMultiset<Integer> treeMultiset;

  @BeforeExperiment
  void setUp() {
    hashMultiset = HashMultiset.create(size);
    linkedHashMultiset = LinkedHashMultiset.create(size);
    treeMultiset = TreeMultiset.create();

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

   *     size}
   * @throws IllegalArgumentException if {@code size} is negative
   */
  protected AbstractIndexedListIterator(int size, int position) {
    checkPositionIndex(position, size);
    this.size = size;
    this.position = position;
  }

  @Override
  public final boolean hasNext() {
    return position < size;
  }

  @Override
  @ParametricNullness

      return forwardList;
    }

    private int reverseIndex(int index) {
      int size = size();
      checkElementIndex(index, size);
      return (size - 1) - index;
    }

    private int reversePosition(int index) {
      int size = size();
      checkPositionIndex(index, size);
      return size - index;
    }

    @Override
    public void add(int index, @ParametricNullness T element) {

        when(mockInputData.size()).thenReturn(100);
        request.setInputData(mockInputData);

        int size = request.size();

        // Base size 120 + 100 = 220, aligned to 8 = 224
        assertEquals(224, size);
        verify(mockInputData).size();
    }

    @Test
    @DisplayName("Test size calculation with output data")
    void testSizeWithOutputData() {