fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testCheckPositive_maxInt() {
    MathPreconditions.checkPositive("int", Integer.MAX_VALUE);
  }

  public void testCheckPositive_minInt() {
    try {
      MathPreconditions.checkPositive("int", Integer.MIN_VALUE);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

    assertThrows(IllegalArgumentException.class, () -> parse("weakValues=true"));
  }

  public void testParse_repeatedValueStrength() {
    assertThrows(IllegalArgumentException.class, () -> parse("softValues, softValues"));

    assertThrows(IllegalArgumentException.class, () -> parse("softValues, weakValues"));

    assertThrows(IllegalArgumentException.class, () -> parse("weakValues, softValues"));

    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 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]"));

  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));
  }

    try {
      HostAndPort.fromParts("gmail.com:80", 81);
      fail("Expected IllegalArgumentException");
    } catch (IllegalArgumentException expected) {
    }

    try {
      HostAndPort.fromParts("gmail.com", -1);
      fail("Expected IllegalArgumentException");
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testFromHost() {

      fail();
    } catch (IllegalArgumentException expected) {
    }
    try {
      range.gap(Range.closed(2, 3));
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testGap_invalidRangesWithInfinity() {
    try {
      Range.atLeast(1).gap(Range.atLeast(2));
      fail();
    } catch (IllegalArgumentException expected) {
    }

    try {

    assertNodeNotInGraphErrorMessage(
        assertThrows(IllegalArgumentException.class, () -> graph.adjacentNodes(N1)));
    assertNodeNotInGraphErrorMessage(
        assertThrows(IllegalArgumentException.class, () -> graph.predecessors(N1)));
    assertNodeNotInGraphErrorMessage(
        assertThrows(IllegalArgumentException.class, () -> graph.successors(N1)));
    assertNodeNotInGraphErrorMessage(

      fail("no exception thrown");
    } catch (IllegalArgumentException expected) {
      verifySimpleMessage(expected);
    }
  }

  public void testCheckArgument_nullMessage_failure() {
    try {
      Preconditions.checkArgument(false, null);
      fail("no exception thrown");
    } catch (IllegalArgumentException expected) {
      assertThat(expected).hasMessageThat().isEqualTo("null");
    }

  }

  public void testMapping_infiniteX1() {
    assertThrows(
        IllegalArgumentException.class,
        () -> LinearTransformation.mapping(Double.POSITIVE_INFINITY, 3.4));
  }

  public void testMapping_infiniteY1() {
    assertThrows(
        IllegalArgumentException.class,
        () -> LinearTransformation.mapping(1.2, Double.NEGATIVE_INFINITY));
  }