* it <i>should</i> hold {@code expectedSize} elements without growth.
   *
   * @param expectedSize the number of elements you expect to add to the returned set
   * @return a new, empty {@code ObjectCountLinkedHashMap} with enough capacity to hold {@code
   *     expectedSize} elements without resizing
   * @throws IllegalArgumentException if {@code expectedSize} is negative
   */

    this(CompactHashing.DEFAULT_SIZE);
  }

  CompactLinkedHashMap(int expectedSize) {
    this(expectedSize, false);
  }

  CompactLinkedHashMap(int expectedSize, boolean accessOrder) {
    super(expectedSize);
    this.accessOrder = accessOrder;
  }

  @Override
  void init(int expectedSize) {
    super.init(expectedSize);
    this.firstEntry = ENDPOINT;
    this.lastEntry = ENDPOINT;
  }

    void testGetSendBufferSizeStandard() {
        // Arrange
        int expectedSize = 65536;
        when(negotiationResponse.getSendBufferSize()).thenReturn(expectedSize);

        // Act
        int size = negotiationResponse.getSendBufferSize();

        // Assert
        assertEquals(expectedSize, size);
        verify(negotiationResponse).getSendBufferSize();
    }

    @Test

      Map<K, V> newHashMapWithExpectedSize(int expectedSize) {
    return Maps.newHashMapWithExpectedSize(expectedSize);
  }

  static <K extends @Nullable Object, V extends @Nullable Object>
      Map<K, V> newLinkedHashMapWithExpectedSize(int expectedSize) {
    return Maps.newLinkedHashMapWithExpectedSize(expectedSize);
  }

  private static final class Factory<C, V> implements Supplier<Map<C, V>>, Serializable {
    final int expectedSize;

    Factory(int expectedSize) {
      this.expectedSize = expectedSize;
    }

    @Override
    public Map<C, V> get() {
      return Maps.newLinkedHashMapWithExpectedSize(expectedSize);
    }

    @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;
  }

  private static final class Factory<C, V> implements Supplier<Map<C, V>>, Serializable {
    final int expectedSize;

    Factory(int expectedSize) {
      this.expectedSize = expectedSize;
    }

    @Override
    public Map<C, V> get() {
      return Maps.newLinkedHashMapWithExpectedSize(expectedSize);
    }

    @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;
  }

        request = new Smb2CreateRequest(mockConfig, "test.txt");

        int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 56;
        int nameLen = 2 * "test.txt".length();
        expectedSize += ((nameLen + 7) / 8) * 8; // size8(nameLen)
        expectedSize = ((expectedSize + 7) / 8) * 8; // size8(size)

        assertEquals(expectedSize, request.size());
    }

    @Test

   * sized appropriately to hold {@code expectedSize} elements.
   */
  @SuppressWarnings("rawtypes") // https://github.com/google/guava/issues/989
  public static Builder<Comparable> expectedSize(int expectedSize) {
    return new Builder<Comparable>(Ordering.natural()).expectedSize(expectedSize);
  }

  /**

            buffer = new DfsReferralRequestBuffer(path, maxReferralLevel);

            assertNotNull(buffer);
            // Verify through encode since there are no getters
            int expectedSize = 4 + 2 * path.length();
            assertEquals(expectedSize, buffer.size());
        }

        @Test
        @DisplayName("Should create buffer with empty path")
        void testConstructorWithEmptyPath() {
            String path = "";

            Smb2LockRequest req = new Smb2LockRequest(mockConfig, testFileId, singleLock);

            int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 24 + 24; // header + structure + 1 lock
            expectedSize = ((expectedSize + 7) / 8) * 8; // 8-byte alignment
            assertEquals(expectedSize, req.size());
        }

        @Test
        @DisplayName("Should calculate size correctly with multiple locks")