assume().that(graphIsMutable()).isTrue();

    addEdge(N1, N2, E12);
    IllegalArgumentException e =
        assertThrows(
            IllegalArgumentException.class, () -> networkAsMutableNetwork.addEdge(N4, N5, E12));
    assertThat(e).hasMessageThat().contains(ERROR_REUSE_EDGE);
    e = assertThrows(IllegalArgumentException.class, () -> addEdge(N2, N1, E12));
    assertThat(e).hasMessageThat().contains(ERROR_REUSE_EDGE);

  }

  public void testOnlyElementMultiple() {
    IllegalArgumentException expected =
        assertThrows(IllegalArgumentException.class, () -> Stream.of(1, 2).collect(onlyElement()));
    assertThat(expected).hasMessageThat().contains("1, 2");
  }

  public void testOnlyElementMany() {
    IllegalArgumentException expected =
        assertThrows(
            IllegalArgumentException.class,

   *
   * @param expression a boolean expression
   * @throws IllegalArgumentException if {@code expression} is false
   */
  public static void checkArgument(boolean expression) {
    if (!expression) {
      throw new IllegalArgumentException();
    }
  }

  /**
   * Ensures the truth of an expression involving one or more parameters to the calling method.

    Resources.copy(resource, out);
    assertThat(out.toString("UTF-8")).isEqualTo(I18N);
  }

  public void testGetResource_notFound() {
    IllegalArgumentException e =
        assertThrows(
            IllegalArgumentException.class, () -> Resources.getResource("no such resource"));
    assertThat(e).hasMessageThat().isEqualTo("resource no such resource not found.");
  }

    try {
      builder.callTimeout(Duration.ofNanos(1))
    } catch (ignored: IllegalArgumentException) {
    }
    try {
      builder.connectTimeout(Duration.ofNanos(1))
    } catch (ignored: IllegalArgumentException) {
    }
    try {
      builder.writeTimeout(Duration.ofNanos(1))
    } catch (ignored: IllegalArgumentException) {
    }
    try {
      builder.readTimeout(Duration.ofNanos(1))

  public void testBigIntegersOffsetExceptions() {
    assertThrows(
        IllegalArgumentException.class,
        () -> DiscreteDomain.bigIntegers().offset(BigInteger.ZERO, -1));
  }

  public void testCustomOffsetExceptions() {
    assertThrows(IllegalArgumentException.class, () -> new MyIntegerDomain().offset(0, -1));
    assertThrows(
        IllegalArgumentException.class, () -> new MyIntegerDomain().offset(Integer.MAX_VALUE, 1));
  }

  public <T> void testWhere_incompatibleGenericArrayMapping() {
    assertThrows(
        IllegalArgumentException.class,
        () -> new TypeResolver().where(new TypeCapture<T[]>() {}.capture(), String.class));
  }

  public <T> void testWhere_incompatibleParameterizedTypeMapping() {
    assertThrows(
        IllegalArgumentException.class,
        () -> new TypeResolver().where(new TypeCapture<Iterable<T>>() {}.capture(), List.class));

        if (version.isPresent() == false) {
            throw new IllegalArgumentException("version not specified for jdk [" + name + "]");
        }
        if (platform.isPresent() == false) {
            throw new IllegalArgumentException("platform not specified for jdk [" + name + "]");
        }
        if (vendor.isPresent() == false) {
            throw new IllegalArgumentException("vendor not specified for jdk [" + name + "]");
        }

  @CanIgnoreReturnValue
  static int checkPositive(String role, int x) {
    if (x <= 0) {
      throw new IllegalArgumentException(role + " (" + x + ") must be > 0");
    }
    return x;
  }

  @CanIgnoreReturnValue
  static long checkPositive(String role, long x) {
    if (x <= 0) {
      throw new IllegalArgumentException(role + " (" + x + ") must be > 0");
    }
    return x;
  }

  @CanIgnoreReturnValue

    assertThrows(IllegalArgumentException.class, () -> range.gap(Range.closed(2, 3)));
  }

  public void testGap_invalidRangesWithInfinity() {
    assertThrows(IllegalArgumentException.class, () -> Range.atLeast(1).gap(Range.atLeast(2)));

    assertThrows(IllegalArgumentException.class, () -> Range.atLeast(2).gap(Range.atLeast(1)));