assertEquals(20, multimap.expectedValuesPerKey);
  }

  public void testCreateFromIllegalSizes() {
    assertThrows(IllegalArgumentException.class, () -> ArrayListMultimap.create(15, -2));

    assertThrows(IllegalArgumentException.class, () -> ArrayListMultimap.create(-15, 2));
  }

  public void testCreateFromHashMultimap() {
    Multimap<String, Integer> original = HashMultimap.create();

    assertThrows(IllegalArgumentException.class, () -> EnumMultiset.create(empty));
  }

  public void testCreateEmptyWithClass() {
    Multiset<Color> ms = EnumMultiset.create(ImmutableList.<Color>of(), Color.class);
    ms.add(Color.RED);
  }

  public void testCreateEmptyWithoutClassFails() {
    assertThrows(

            .isNotEqualTo(paramType);
      } catch (IllegalArgumentException notSubtype1) {
        // The raw class isn't even a subclass.
      }
    }
    if (!spec.suppressGetSupertype()) {
      try {
        assertThat(getSupertype(paramType, TypeToken.of(returnType).getRawType()))
            .isNotEqualTo(returnType);
      } catch (IllegalArgumentException notSubtype2) {
        // The raw class isn't even a subclass.

   * avoids the need for expensive resizing operations later, but setting this value unnecessarily
   * high wastes memory.
   *
   * @return this {@code CacheBuilder} instance (for chaining)
   * @throws IllegalArgumentException if {@code initialCapacity} is negative
   * @throws IllegalStateException if an initial capacity was already set
   */
  @CanIgnoreReturnValue
  public CacheBuilder<K, V> initialCapacity(int initialCapacity) {

   *
   * @param value any value in the range of the {@code char} type
   * @return the {@code char} value that equals {@code value}
   * @throws IllegalArgumentException if {@code value} is greater than {@link Character#MAX_VALUE}
   *     or less than {@link Character#MIN_VALUE}
   */
  public static char checkedCast(long value) {
    char result = (char) value;

    assertThrows(IllegalArgumentException.class, () -> resetMap(entries));
  }

  @MapFeature.Require(REJECTS_DUPLICATES_AT_CREATION)
  @CollectionSize.Require(absent = {ZERO, ONE})
  public void testCreateWithDuplicates_nonNullDuplicatesRejected() {
    Entry<K, V>[] entries = getEntriesMultipleNonNullKeys();
    assertThrows(IllegalArgumentException.class, () -> resetMap(entries));
  }

   * future-proof algorithms <a
   * href="https://datatracker.ietf.org/doc/html/rfc6151#section-2.3">over {@code hmacMd5}</a>.
   *
   * @param key the secret key
   * @throws IllegalArgumentException if the given key is inappropriate for initializing this MAC
   * @since 20.0
   */
  public static HashFunction hmacMd5(Key key) {
    return new MacHashFunction("HmacMD5", key, hmacToString("hmacMd5", key));

   * relative to the natural ordering of the elements, and returns them via {@link #topK} in
   * ascending order.
   *
   * @throws IllegalArgumentException if {@code k < 0} or {@code k > Integer.MAX_VALUE / 2}
   */
  public static <T extends Comparable<? super T>> TopKSelector<T> least(int k) {
    return least(k, Ordering.natural());
  }

  /**

  override fun parse(string: String): MediaType = string.toMediaType()

  override fun assertInvalid(
    string: String,
    exceptionMessage: String?,
  ) {
    val e =
      assertFailsWith<IllegalArgumentException> {
        parse(string)
      }
    assertEquals(exceptionMessage, e.message)
  }

        assertThrows(
            IllegalArgumentException.class,
            () -> GeneralRange.range(ORDERING, 4, lboundType, 2, uboundType));
      }
    }
  }

  public void testCreateEmptyRangeOpenOpenFails() {
    for (Integer i : IN_ORDER_VALUES) {
      assertThrows(
          IllegalArgumentException.class,