int size = multimap().size();
    List<V> oldValues = new ArrayList<>(multimap().get(k0()));
    List<V> values = asList(v0(), v3(), v0());
    assertEquals(oldValues, new ArrayList<V>(multimap().replaceValues(k0(), values)));
    assertEquals(size - oldValues.size() + multimap().get(k0()).size(), multimap().size());
    assertTrue(multimap().get(k0()).containsAll(values));
  }

  @CollectionSize.Require(absent = ZERO)

    USING_DECODER_WITH_SIZE_HINT {
      @Override
      String read(ByteSource byteSource, Charset cs) throws IOException {
        Optional<Long> size = byteSource.sizeIfKnown();
        // if we know the size and it fits in an int
        if (size.isPresent() && size.get().longValue() == size.get().intValue()) {
          // otherwise try to presize a StringBuilder

        List<AnalyzeToken> tokensTitle = analyzer.analyze(text, "title", lang);
        assertNotNull(tokensTitle);
        assertEquals(2, tokensTitle.size());

        // Test with null field
        List<AnalyzeToken> tokensNull = analyzer.analyze(text, null, lang);
        assertNotNull(tokensNull);
        assertEquals(2, tokensNull.size());
    }

    @Test

    }
  }

  @Override
  final int distinctElements() {
    return backingMap.size();
  }

  @Override
  public final Iterator<E> iterator() {
    return Multisets.iteratorImpl(this);
  }

  @Override
  public final int size() {
    return Ints.saturatedCast(size);
  }

  /**

     * @return a hexadecimal string representation of the byte array
     */
    public static String toHexString(final byte[] src, final int srcIndex, int size) {
        final char[] c = new char[size];
        size = size % 2 == 0 ? size / 2 : size / 2 + 1;
        for (int i = 0, j = 0; i < size; i++) {
            c[j] = HEX_DIGITS[src[i] >> 4 & 0x0F];
            j++;
            if (j == c.length) {
                break;

        Smb2TreeDisconnectRequest request = new Smb2TreeDisconnectRequest(mockConfig);

        // When
        int size = request.size();

        // Then
        // Verify size includes SMB2_HEADER_LENGTH
        assertTrue(size >= Smb2Constants.SMB2_HEADER_LENGTH);

        // The actual calculation: (SMB2_HEADER_LENGTH + 4 + 7) & ~7

    /**
     * Gets the send buffer size of the underlying SMB connection
     * @return the send buffer size of the underlying connection
     * @throws CIFSException if an error occurs retrieving the buffer size
     */
    int getSendBufferSize() throws CIFSException;

    /**
     * Gets the receive buffer size of the underlying SMB connection
     * @return the receive buffer size of the underlying connection

		return bw.Sum(nil)
	}
	return nil
}

// Returns the size of the file with bitrot protection
func bitrotShardFileSize(size int64, shardSize int64, algo BitrotAlgorithm) int64 {
	if algo != HighwayHash256S {
		return size
	}
	return ceilFrac(size, shardSize)*int64(algo.New().Size()) + size
}

// bitrotVerify a single stream of data.

   *     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

    }

    @Test
    @DisplayName("Test size method returns 8")
    void testSize() {
        assertEquals(8, fileInfo.size());

        // Test with different instance
        FileEndOfFileInformation info = new FileEndOfFileInformation(999L);
        assertEquals(8, info.size());
    }

    @Test
    @DisplayName("Test encode method with valid buffer")