}

  public void testGetInstance_withTypeVariable() {
    assertThrows(
        IllegalArgumentException.class, () -> map.getInstance(this.<Number>anyIterableType()));
  }

  public void testPutInstance_withTypeVariable() {
    assertThrows(
        IllegalArgumentException.class,
        () -> map.putInstance(this.<Integer>anyIterableType(), ImmutableList.of(1)));
  }

    public Builder() {
      this.entries = new ArrayList<>();
    }

    /**
     * Associates the specified range with the specified value.
     *
     * @throws IllegalArgumentException if {@code range} is empty
     */
    @CanIgnoreReturnValue
    public Builder<K, V> put(Range<K> range, V value) {
      checkNotNull(range);
      checkNotNull(value);

  @Test
  fun requestHeaderValidationIsStrict() {
    assertFailsWith<IllegalArgumentException> {
      Request
        .Builder()
        .addHeader("a\tb", "Value")
    }
    assertFailsWith<IllegalArgumentException> {
      Request
        .Builder()
        .addHeader("Name", "c\u007fd")
    }
    assertFailsWith<IllegalArgumentException> {
      Request
        .Builder()

        assertNotNull(trans2);

        byte[] buffer = new byte[256];
        assertThrows(IllegalArgumentException.class, () -> {
            trans2.writeParametersWireFormat(buffer, 0);
        }, "Should throw IllegalArgumentException for invalid information level: " + invalidLevel);
    }

    @Test
    @DisplayName("Test buffer boundary conditions")

    Files.write(ASCII, temp1, UTF_8);
    assertThrows(IllegalArgumentException.class, () -> Files.copy(temp1, temp2));
    assertEquals(ASCII, Files.toString(temp1, UTF_8));
  }

  public void testCopySameFile() throws IOException {
    File temp = createTempFile();
    Files.write(ASCII, temp, UTF_8);
    assertThrows(IllegalArgumentException.class, () -> Files.copy(temp, temp));

    /*
     * We throw IllegalStateException, since the call could succeed later. Perhaps we "should" throw
     * IllegalArgumentException, since the call could succeed with a different argument. Those
     * exceptions' docs suggest that either is acceptable. Google's Java Practices page recommends
     * IllegalArgumentException here, in part to keep its recommendation simple: Static methods

  private int initialCapacity = 16;

  public MapMaker() {}

  @CanIgnoreReturnValue
  public MapMaker initialCapacity(int initialCapacity) {
    if (initialCapacity < 0) {
      throw new IllegalArgumentException();
    }
    this.initialCapacity = initialCapacity;
    return this;
  }

  @CanIgnoreReturnValue
  public MapMaker concurrencyLevel(int concurrencyLevel) {
    checkArgument(

   *
   * @param values a series of values, which will be converted to {@code double} values (this may
   *     cause loss of precision)
   * @throws IllegalArgumentException if the dataset is empty
   */
  public static double meanOf(Iterable<? extends Number> values) {
    return meanOf(values.iterator());
  }

  /**

  }

  public void testHashCodeNull() {
    assertEquals(control(NE, 1).hashCode(), entry(NE, 1).hashCode());
  }

  public void testNegativeCount() {
    assertThrows(IllegalArgumentException.class, () -> entry("foo", -1));
  }

  @CollectionSize.Require(SEVERAL)
  public void testSetValue_valuePresent() {
    for (Entry<K, V> entry : getMap().entrySet()) {
      if (entry.getKey().equals(k0())) {
        assertThrows(IllegalArgumentException.class, () -> entry.setValue(v1()));
      }
    }
    expectUnchanged();
  }

  @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_VALUES)
  @CollectionSize.Require(absent = ZERO)