public void testForUriStringBad() {
    assertThrows(IllegalArgumentException.class, () -> InetAddresses.forUriString(""));

    assertThrows(
        IllegalArgumentException.class, () -> InetAddresses.forUriString("192.168.999.888"));

    assertThrows(
        IllegalArgumentException.class, () -> InetAddresses.forUriString("www.google.com"));

    assertThrows(IllegalArgumentException.class, () -> InetAddresses.forUriString("[1:2e]"));

        final FessAdminAction action = createAction();
        assertThrows(IllegalArgumentException.class, () -> action.validateFilePath(""));
    }

    @Test
    public void test_validateFilePath_nullPath() {
        final FessAdminAction action = createAction();
        assertThrows(IllegalArgumentException.class, () -> action.validateFilePath(null));
    }

    @Test

      if (isNullOrEmpty(value)) {
        throw new IllegalArgumentException("value of key " + key + " omitted");
      }
      try {
        parseInteger(spec, Integer.parseInt(value));
      } catch (NumberFormatException e) {
        throw new IllegalArgumentException(
            format("key %s value set to %s, must be integer", key, value), e);
      }
    }
  }

      if (isNullOrEmpty(value)) {
        throw new IllegalArgumentException("value of key " + key + " omitted");
      }
      try {
        parseInteger(spec, Integer.parseInt(value));
      } catch (NumberFormatException e) {
        throw new IllegalArgumentException(
            format("key %s value set to %s, must be integer", key, value), e);
      }
    }
  }

     *
     * @param format the format name
     * @return the formatter instance
     * @throws IllegalArgumentException if the format is null, empty, or not supported
     */
    protected IndexExportFormatter createFormatter(final String format) {
        if (format == null || format.trim().isEmpty()) {
            throw new IllegalArgumentException("Export format must not be null or empty");
        }
        switch (format.trim().toLowerCase()) {

        "1.2.3" | "1.2.4"
    }

    def "invalid version format is rejected"() {
        when:
        ReleasedVersionsHelperKt.bumpPatchVersion(version)

        then:
        thrown(IllegalArgumentException)

        where:
        version << ["9.4", "9", "9.4.0.1", "not.a.version", "9.4.0-SNAPSHOT"]
    }

   * possible.
   *
   * @param value a value between 0 and 2<sup>32</sup>-1 inclusive
   * @return the {@code int} value that, when treated as unsigned, equals {@code value}
   * @throws IllegalArgumentException if {@code value} is negative or greater than or equal to
   *     2<sup>32</sup>
   * @since 21.0
   */
  public static int checkedCast(long value) {

      checkNotNull(node);
      throw new IllegalArgumentException(String.format(NODE_NOT_IN_GRAPH, node));
    }
    return connections;
  }

  final N checkedReferenceNode(E edge) {
    N referenceNode = edgeToReferenceNode.get(edge);
    if (referenceNode == null) {
      checkNotNull(edge);
      throw new IllegalArgumentException(String.format(EDGE_NOT_IN_GRAPH, edge));
    }

    this.allowsSelfLoops = allowsSelfLoops;
    return this;
  }

  /**
   * Specifies the expected number of nodes in the graph.
   *
   * @throws IllegalArgumentException if {@code expectedNodeCount} is negative
   */
  @CanIgnoreReturnValue
  public GraphBuilder<N> expectedNodeCount(int expectedNodeCount) {
    this.expectedNodeCount = checkNonNegative(expectedNodeCount);

  }

  /**
   * Creates an {@code MonitorBasedArrayBlockingQueue} with the given (fixed) capacity and default
   * access policy.
   *
   * @param capacity the capacity of this queue
   * @throws IllegalArgumentException if {@code capacity} is less than 1
   */
  public MonitorBasedArrayBlockingQueue(int capacity) {
    this(capacity, false);
  }

  /**