}

    @Override
    ImmutableCollection.Builder<V> newValueCollectionBuilderWithExpectedSize(int expectedSize) {
      return (valueComparator == null)
          ? ImmutableSet.builderWithExpectedSize(expectedSize)
          : new ImmutableSortedSet.Builder<V>(valueComparator, expectedSize);
    }

    @Override
    int expectedValueCollectionSize(int defaultExpectedValues, Iterable<?> values) {

   * @since 23.1
   */
  public static <K, V> Builder<K, V> builderWithExpectedSize(int expectedSize) {
    checkNonnegative(expectedSize, "expectedSize");
    return new Builder<>(expectedSize);
  }

  static void checkNoConflict(
      boolean safe, String conflictDescription, Object entry1, Object entry2) {
    if (!safe) {
      throw conflictException(conflictDescription, entry1, entry2);
    }
  }

    public Builder(Comparator<? super E> comparator) {
      this.comparator = checkNotNull(comparator);
    }

    Builder(Comparator<? super E> comparator, int expectedSize) {
      super(expectedSize);
      this.comparator = checkNotNull(comparator);
    }

    @CanIgnoreReturnValue
    @Override
    public Builder<E> add(E element) {
      super.add(element);
      return this;

    }

    @Test
    @DisplayName("size should return correct message size")
    void testSize() {
        int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 24;
        // size8 method rounds up to 8-byte boundary
        int expectedAlignedSize = (expectedSize + 7) & ~7;

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

    @Test

    }

    @Override
    ImmutableCollection.Builder<V> newValueCollectionBuilderWithExpectedSize(int expectedSize) {
      return (valueComparator == null)
          ? ImmutableSet.builderWithExpectedSize(expectedSize)
          : new ImmutableSortedSet.Builder<V>(valueComparator, expectedSize);
    }

    @Override
    int expectedValueCollectionSize(int defaultExpectedValues, Iterable<?> values) {

        builderMap = result;
      }
      return result;
    }

    ImmutableCollection.Builder<V> newValueCollectionBuilderWithExpectedSize(int expectedSize) {
      return ImmutableList.builderWithExpectedSize(expectedSize);
    }

    /**
     * Provides a hint for how many values will be associated with each key newly added to the

        void testSizeWithVariousCombinations(int algoCount, int saltSize, int expectedSize) {
            int[] hashAlgos = algoCount > 0 ? new int[algoCount] : null;
            byte[] salt = saltSize > 0 ? new byte[saltSize] : null;
            PreauthIntegrityNegotiateContext context = new PreauthIntegrityNegotiateContext(mockConfig, hashAlgos, salt);

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

   */
  @DoNotCall("Use naturalOrder (which does not accept an expected size)")
  @Deprecated
  public static <E> ImmutableSortedSet.Builder<E> builderWithExpectedSize(int expectedSize) {
    throw new UnsupportedOperationException();
  }

  /**
   * Not supported. <b>You are attempting to create a set that may contain a non-{@code Comparable}

// checkPart is a light check of an existing and size of a part, without doing a bitrot operation
// For any unexpected error, return checkPartUnknown (zero)
func (s *xlStorage) checkPart(volumeDir, path, dataDir string, partNum int, expectedSize int64, skipAccessCheck bool) (resp int) {
	partPath := pathJoin(path, dataDir, fmt.Sprintf("part.%d", partNum))
	filePath := pathJoin(volumeDir, partPath)
	st, err := Lstat(filePath)
	if err != nil {